diff --git a/quic/core/quic_config.cc b/quic/core/quic_config.cc
index a3840ec..135fb64 100644
--- a/quic/core/quic_config.cc
+++ b/quic/core/quic_config.cc
@@ -420,7 +420,8 @@
       stateless_reset_token_(kSRST, PRESENCE_OPTIONAL),
       max_incoming_unidirectional_streams_(kMIUS, PRESENCE_OPTIONAL),
       max_ack_delay_ms_(kMAD, PRESENCE_OPTIONAL),
-      ack_delay_exponent_(kADE, PRESENCE_OPTIONAL) {
+      ack_delay_exponent_(kADE, PRESENCE_OPTIONAL),
+      max_packet_size_(0, PRESENCE_OPTIONAL) {
   SetDefaults();
 }
 
@@ -579,6 +580,22 @@
   return ack_delay_exponent_.GetReceivedValue();
 }
 
+void QuicConfig::SetMaxPacketSizeToSend(uint32_t max_packet_size) {
+  max_packet_size_.SetSendValue(max_packet_size);
+}
+
+uint32_t QuicConfig::GetMaxPacketSizeToSend() const {
+  return max_packet_size_.GetSendValue();
+}
+
+bool QuicConfig::HasReceivedMaxPacketSize() const {
+  return max_packet_size_.HasReceivedValue();
+}
+
+uint32_t QuicConfig::ReceivedMaxPacketSize() const {
+  return max_packet_size_.GetReceivedValue();
+}
+
 bool QuicConfig::HasSetBytesForConnectionIdToSend() const {
   return bytes_for_connection_id_.HasSendValue();
 }
@@ -806,6 +823,7 @@
   SetMaxAckDelayToSendMs(kDefaultDelayedAckTimeMs);
   SetSupportMaxHeaderListSize();
   SetAckDelayExponentToSend(kDefaultAckDelayExponent);
+  SetMaxPacketSizeToSend(kMaxIncomingPacketSize);
 }
 
 void QuicConfig::ToHandshakeMessage(
@@ -921,7 +939,7 @@
             sizeof(stateless_reset_token));
   }
 
-  params->max_packet_size.set_value(kMaxIncomingPacketSize);
+  params->max_packet_size.set_value(GetMaxPacketSizeToSend());
   params->initial_max_data.set_value(
       GetInitialSessionFlowControlWindowToSend());
   // The max stream data bidirectional transport parameters can be either local
@@ -1008,10 +1026,13 @@
     stateless_reset_token_.SetReceivedValue(stateless_reset_token);
   }
 
-  if (params.max_packet_size.value() < kMaxOutgoingPacketSize) {
-    // TODO(dschinazi) act on this.
-    QUIC_DLOG(ERROR) << "Ignoring peer's requested max packet size of "
-                     << params.max_packet_size.value();
+  if (params.max_packet_size.IsValid()) {
+    max_packet_size_.SetReceivedValue(params.max_packet_size.value());
+    if (ReceivedMaxPacketSize() < kMaxOutgoingPacketSize) {
+      // TODO(dschinazi) act on this.
+      QUIC_DLOG(ERROR) << "Ignoring peer's requested max packet size of "
+                       << ReceivedMaxPacketSize();
+    }
   }
 
   initial_session_flow_control_window_bytes_.SetReceivedValue(
diff --git a/quic/core/quic_config.h b/quic/core/quic_config.h
index ecece2a..357344e 100644
--- a/quic/core/quic_config.h
+++ b/quic/core/quic_config.h
@@ -456,6 +456,12 @@
   bool HasReceivedAckDelayExponent() const;
   uint32_t ReceivedAckDelayExponent() const;
 
+  // IETF QUIC max_packet_size transport parameter.
+  void SetMaxPacketSizeToSend(uint32_t max_packet_size);
+  uint32_t GetMaxPacketSizeToSend() const;
+  bool HasReceivedMaxPacketSize() const;
+  uint32_t ReceivedMaxPacketSize() const;
+
   bool negotiated() const;
 
   void SetCreateSessionTagIndicators(QuicTagVector tags);
@@ -573,6 +579,9 @@
   // to serialize frames and this node uses to deserialize them.
   QuicFixedUint32 ack_delay_exponent_;
 
+  // max_packet_size IEFT QUIC transport parameter.
+  QuicFixedUint32 max_packet_size_;
+
   // Custom transport parameters that can be sent and received in the TLS
   // handshake.
   TransportParameters::ParameterMap custom_transport_parameters_to_send_;
diff --git a/quic/core/quic_config_test.cc b/quic/core/quic_config_test.cc
index e0eb304..882516e 100644
--- a/quic/core/quic_config_test.cc
+++ b/quic/core/quic_config_test.cc
@@ -21,6 +21,8 @@
 namespace test {
 namespace {
 
+const uint32_t kMaxPacketSizeForTest = 1234;
+
 class QuicConfigTest : public QuicTestWithParam<QuicTransportVersion> {
  protected:
   QuicConfig config_;
@@ -47,6 +49,8 @@
   EXPECT_FALSE(
       config_.HasReceivedInitialMaxStreamDataBytesOutgoingBidirectional());
   EXPECT_FALSE(config_.HasReceivedInitialMaxStreamDataBytesUnidirectional());
+  EXPECT_EQ(kMaxIncomingPacketSize, config_.GetMaxPacketSizeToSend());
+  EXPECT_FALSE(config_.HasReceivedMaxPacketSize());
 }
 
 TEST_P(QuicConfigTest, AutoSetIetfFlowControl) {
@@ -391,6 +395,7 @@
       3 * kMinimumFlowControlSendWindow);
   config_.SetInitialMaxStreamDataBytesUnidirectionalToSend(
       4 * kMinimumFlowControlSendWindow);
+  config_.SetMaxPacketSizeToSend(kMaxPacketSizeForTest);
 
   TransportParameters params;
   config_.FillTransportParameters(&params);
@@ -404,6 +409,8 @@
 
   EXPECT_EQ(static_cast<uint64_t>(kMaximumIdleTimeoutSecs * 1000),
             params.idle_timeout_milliseconds.value());
+
+  EXPECT_EQ(kMaxPacketSizeForTest, params.max_packet_size.value());
 }
 
 TEST_P(QuicConfigTest, ProcessTransportParametersServer) {
@@ -415,6 +422,7 @@
       3 * kMinimumFlowControlSendWindow);
   params.initial_max_stream_data_uni.set_value(4 *
                                                kMinimumFlowControlSendWindow);
+  params.max_packet_size.set_value(kMaxPacketSizeForTest);
 
   std::string error_details;
   EXPECT_EQ(QUIC_NO_ERROR,
@@ -433,6 +441,9 @@
   ASSERT_TRUE(config_.HasReceivedInitialMaxStreamDataBytesUnidirectional());
   EXPECT_EQ(4 * kMinimumFlowControlSendWindow,
             config_.ReceivedInitialMaxStreamDataBytesUnidirectional());
+
+  ASSERT_TRUE(config_.HasReceivedMaxPacketSize());
+  EXPECT_EQ(kMaxPacketSizeForTest, config_.ReceivedMaxPacketSize());
 }
 
 }  // namespace