diff --git a/quiche/quic/core/quic_coalesced_packet.cc b/quiche/quic/core/quic_coalesced_packet.cc
index 802fac4..67091d6 100644
--- a/quiche/quic/core/quic_coalesced_packet.cc
+++ b/quiche/quic/core/quic_coalesced_packet.cc
@@ -11,7 +11,7 @@
 namespace quic {
 
 QuicCoalescedPacket::QuicCoalescedPacket()
-    : length_(0), max_packet_length_(0) {}
+    : length_(0), max_packet_length_(0), ecn_codepoint_(ECN_NOT_ECT) {}
 
 QuicCoalescedPacket::~QuicCoalescedPacket() { Clear(); }
 
@@ -19,7 +19,8 @@
     const SerializedPacket& packet, const QuicSocketAddress& self_address,
     const QuicSocketAddress& peer_address,
     quiche::QuicheBufferAllocator* allocator,
-    QuicPacketLength current_max_packet_length) {
+    QuicPacketLength current_max_packet_length,
+    QuicEcnCodepoint ecn_codepoint) {
   if (packet.encrypted_length == 0) {
     QUIC_BUG(quic_bug_10611_1) << "Trying to coalesce an empty packet";
     return true;
@@ -52,6 +53,10 @@
       // Do not coalesce packets of the same encryption level.
       return false;
     }
+    if (ecn_codepoint != ecn_codepoint_) {
+      // Do not coalesce packets with different ECN codepoints.
+      return false;
+    }
   }
 
   if (length_ + packet.encrypted_length > max_packet_length_) {
@@ -66,6 +71,7 @@
   if (length_ > 0) {
     QUIC_CODE_COUNT(QUIC_SUCCESSFULLY_COALESCED_MULTIPLE_PACKETS);
   }
+  ecn_codepoint_ = ecn_codepoint;
   length_ += packet.encrypted_length;
   transmission_types_[packet.encryption_level] = packet.transmission_type;
   if (packet.encryption_level == ENCRYPTION_INITIAL) {
diff --git a/quiche/quic/core/quic_coalesced_packet.h b/quiche/quic/core/quic_coalesced_packet.h
index 21a6e1e..b362937 100644
--- a/quiche/quic/core/quic_coalesced_packet.h
+++ b/quiche/quic/core/quic_coalesced_packet.h
@@ -26,7 +26,8 @@
                            const QuicSocketAddress& self_address,
                            const QuicSocketAddress& peer_address,
                            quiche::QuicheBufferAllocator* allocator,
-                           QuicPacketLength current_max_packet_length);
+                           QuicPacketLength current_max_packet_length,
+                           QuicEcnCodepoint ecn_codepoint);
 
   // Clears this coalesced packet.
   void Clear();
@@ -66,6 +67,8 @@
 
   std::vector<size_t> packet_lengths() const;
 
+  QuicEcnCodepoint ecn_codepoint() const { return ecn_codepoint_; }
+
  private:
   friend class test::QuicCoalescedPacketPeer;
 
@@ -89,6 +92,9 @@
   // frames are copied to allow it be re-serialized when this coalesced packet
   // gets sent.
   std::unique_ptr<SerializedPacket> initial_packet_;
+
+  // A coalesced packet shares an ECN codepoint.
+  QuicEcnCodepoint ecn_codepoint_;
 };
 
 }  // namespace quic
diff --git a/quiche/quic/core/quic_coalesced_packet_test.cc b/quiche/quic/core/quic_coalesced_packet_test.cc
index eb69372..00ba7d8 100644
--- a/quiche/quic/core/quic_coalesced_packet_test.cc
+++ b/quiche/quic/core/quic_coalesced_packet_test.cc
@@ -31,7 +31,7 @@
   packet1.retransmittable_frames.push_back(
       QuicFrame(QuicStreamFrame(1, true, 0, 100)));
   ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet1, self_address, peer_address,
-                                            &allocator, 1500));
+                                            &allocator, 1500, ECN_NOT_ECT));
   EXPECT_EQ(PTO_RETRANSMISSION,
             coalesced.TransmissionTypeOfPacket(ENCRYPTION_INITIAL));
   EXPECT_EQ(1500u, coalesced.max_packet_length());
@@ -40,12 +40,14 @@
   EXPECT_EQ(
       "total_length: 1500 padding_size: 1000 packets: {ENCRYPTION_INITIAL}",
       coalesced.ToString(1500));
+  EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
 
   // Cannot coalesce packet of the same encryption level.
   SerializedPacket packet2(QuicPacketNumber(2), PACKET_4BYTE_PACKET_NUMBER,
                            buffer, 500, false, false);
-  EXPECT_FALSE(coalesced.MaybeCoalescePacket(packet2, self_address,
-                                             peer_address, &allocator, 1500));
+  EXPECT_FALSE(coalesced.MaybeCoalescePacket(
+      packet2, self_address, peer_address, &allocator, 1500, ECN_NOT_ECT));
+  EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
 
   SerializedPacket packet3(QuicPacketNumber(3), PACKET_4BYTE_PACKET_NUMBER,
                            buffer, 500, false, false);
@@ -53,7 +55,7 @@
   packet3.encryption_level = ENCRYPTION_ZERO_RTT;
   packet3.transmission_type = LOSS_RETRANSMISSION;
   ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet3, self_address, peer_address,
-                                            &allocator, 1500));
+                                            &allocator, 1500, ECN_NOT_ECT));
   EXPECT_EQ(1500u, coalesced.max_packet_length());
   EXPECT_EQ(1000u, coalesced.length());
   EXPECT_EQ(2u, coalesced.NumberOfPackets());
@@ -63,6 +65,7 @@
       "total_length: 1500 padding_size: 500 packets: {ENCRYPTION_INITIAL, "
       "ENCRYPTION_ZERO_RTT}",
       coalesced.ToString(1500));
+  EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
 
   SerializedPacket packet4(QuicPacketNumber(4), PACKET_4BYTE_PACKET_NUMBER,
                            buffer, 500, false, false);
@@ -70,28 +73,31 @@
   // Cannot coalesce packet of changed self/peer address.
   EXPECT_FALSE(coalesced.MaybeCoalescePacket(
       packet4, QuicSocketAddress(QuicIpAddress::Loopback4(), 3), peer_address,
-      &allocator, 1500));
+      &allocator, 1500, ECN_NOT_ECT));
 
   // Packet does not fit.
   SerializedPacket packet5(QuicPacketNumber(5), PACKET_4BYTE_PACKET_NUMBER,
                            buffer, 501, false, false);
   packet5.encryption_level = ENCRYPTION_FORWARD_SECURE;
-  EXPECT_FALSE(coalesced.MaybeCoalescePacket(packet5, self_address,
-                                             peer_address, &allocator, 1500));
+  EXPECT_FALSE(coalesced.MaybeCoalescePacket(
+      packet5, self_address, peer_address, &allocator, 1500, ECN_NOT_ECT));
   EXPECT_EQ(1500u, coalesced.max_packet_length());
   EXPECT_EQ(1000u, coalesced.length());
   EXPECT_EQ(2u, coalesced.NumberOfPackets());
+  EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
 
   // Max packet number length changed.
   SerializedPacket packet6(QuicPacketNumber(6), PACKET_4BYTE_PACKET_NUMBER,
                            buffer, 100, false, false);
   packet6.encryption_level = ENCRYPTION_FORWARD_SECURE;
-  EXPECT_QUIC_BUG(coalesced.MaybeCoalescePacket(packet6, self_address,
-                                                peer_address, &allocator, 1000),
-                  "Max packet length changes in the middle of the write path");
+  EXPECT_QUIC_BUG(
+      coalesced.MaybeCoalescePacket(packet6, self_address, peer_address,
+                                    &allocator, 1000, ECN_NOT_ECT),
+      "Max packet length changes in the middle of the write path");
   EXPECT_EQ(1500u, coalesced.max_packet_length());
   EXPECT_EQ(1000u, coalesced.length());
   EXPECT_EQ(2u, coalesced.NumberOfPackets());
+  EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
 }
 
 TEST(QuicCoalescedPacketTest, CopyEncryptedBuffers) {
@@ -111,10 +117,11 @@
   packet2.encryption_level = ENCRYPTION_FORWARD_SECURE;
 
   ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet1, self_address, peer_address,
-                                            &allocator, 1500));
+                                            &allocator, 1500, ECN_NOT_ECT));
   ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet2, self_address, peer_address,
-                                            &allocator, 1500));
+                                            &allocator, 1500, ECN_NOT_ECT));
   EXPECT_EQ(1000u, coalesced.length());
+  EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
 
   char copy_buffer[1000];
   size_t length_copied = 0;
@@ -152,7 +159,7 @@
   packet1.retransmittable_frames.push_back(
       QuicFrame(QuicStreamFrame(1, true, 0, 100)));
   ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet1, self_address, peer_address,
-                                            &allocator, 1500));
+                                            &allocator, 1500, ECN_NOT_ECT));
   EXPECT_EQ(PTO_RETRANSMISSION,
             coalesced.TransmissionTypeOfPacket(ENCRYPTION_INITIAL));
   EXPECT_EQ(1500u, coalesced.max_packet_length());
@@ -160,16 +167,17 @@
   EXPECT_EQ(
       "total_length: 1500 padding_size: 1000 packets: {ENCRYPTION_INITIAL}",
       coalesced.ToString(1500));
-  // Neuter initial packet.
+  EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
   coalesced.NeuterInitialPacket();
   EXPECT_EQ(0u, coalesced.max_packet_length());
   EXPECT_EQ(0u, coalesced.length());
   EXPECT_EQ("total_length: 0 padding_size: 0 packets: {}",
             coalesced.ToString(0));
+  EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
 
   // Coalesce initial packet again.
   ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet1, self_address, peer_address,
-                                            &allocator, 1500));
+                                            &allocator, 1500, ECN_NOT_ECT));
 
   SerializedPacket packet2(QuicPacketNumber(3), PACKET_4BYTE_PACKET_NUMBER,
                            buffer, 500, false, false);
@@ -177,7 +185,7 @@
   packet2.encryption_level = ENCRYPTION_ZERO_RTT;
   packet2.transmission_type = LOSS_RETRANSMISSION;
   ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet2, self_address, peer_address,
-                                            &allocator, 1500));
+                                            &allocator, 1500, ECN_NOT_ECT));
   EXPECT_EQ(1500u, coalesced.max_packet_length());
   EXPECT_EQ(1000u, coalesced.length());
   EXPECT_EQ(LOSS_RETRANSMISSION,
@@ -186,6 +194,7 @@
       "total_length: 1500 padding_size: 500 packets: {ENCRYPTION_INITIAL, "
       "ENCRYPTION_ZERO_RTT}",
       coalesced.ToString(1500));
+  EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
 
   // Neuter initial packet.
   coalesced.NeuterInitialPacket();
@@ -194,18 +203,52 @@
   EXPECT_EQ(
       "total_length: 1500 padding_size: 1000 packets: {ENCRYPTION_ZERO_RTT}",
       coalesced.ToString(1500));
+  EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
 
   SerializedPacket packet3(QuicPacketNumber(5), PACKET_4BYTE_PACKET_NUMBER,
                            buffer, 501, false, false);
   packet3.encryption_level = ENCRYPTION_FORWARD_SECURE;
   EXPECT_TRUE(coalesced.MaybeCoalescePacket(packet3, self_address, peer_address,
-                                            &allocator, 1500));
+                                            &allocator, 1500, ECN_NOT_ECT));
   EXPECT_EQ(1500u, coalesced.max_packet_length());
   EXPECT_EQ(1001u, coalesced.length());
+  EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
   // Neuter initial packet.
   coalesced.NeuterInitialPacket();
   EXPECT_EQ(1500u, coalesced.max_packet_length());
   EXPECT_EQ(1001u, coalesced.length());
+  EXPECT_EQ(coalesced.ecn_codepoint(), ECN_NOT_ECT);
+}
+
+TEST(QuicCoalescedPacketTest, DoNotCoalesceDifferentEcn) {
+  QuicCoalescedPacket coalesced;
+  EXPECT_EQ("total_length: 0 padding_size: 0 packets: {}",
+            coalesced.ToString(0));
+  quiche::SimpleBufferAllocator allocator;
+  EXPECT_EQ(0u, coalesced.length());
+  EXPECT_EQ(0u, coalesced.NumberOfPackets());
+  char buffer[1000];
+  QuicSocketAddress self_address(QuicIpAddress::Loopback4(), 1);
+  QuicSocketAddress peer_address(QuicIpAddress::Loopback4(), 2);
+  SerializedPacket packet1(QuicPacketNumber(1), PACKET_4BYTE_PACKET_NUMBER,
+                           buffer, 500, false, false);
+  packet1.transmission_type = PTO_RETRANSMISSION;
+  QuicAckFrame ack_frame(InitAckFrame(1));
+  packet1.nonretransmittable_frames.push_back(QuicFrame(&ack_frame));
+  packet1.retransmittable_frames.push_back(
+      QuicFrame(QuicStreamFrame(1, true, 0, 100)));
+  ASSERT_TRUE(coalesced.MaybeCoalescePacket(packet1, self_address, peer_address,
+                                            &allocator, 1500, ECN_ECT1));
+  EXPECT_EQ(coalesced.ecn_codepoint(), ECN_ECT1);
+
+  SerializedPacket packet2(QuicPacketNumber(2), PACKET_4BYTE_PACKET_NUMBER,
+                           buffer, 500, false, false);
+  packet2.nonretransmittable_frames.push_back(QuicFrame(QuicPaddingFrame(100)));
+  packet2.encryption_level = ENCRYPTION_ZERO_RTT;
+  packet2.transmission_type = LOSS_RETRANSMISSION;
+  EXPECT_FALSE(coalesced.MaybeCoalescePacket(
+      packet2, self_address, peer_address, &allocator, 1500, ECN_NOT_ECT));
+  EXPECT_EQ(coalesced.ecn_codepoint(), ECN_ECT1);
 }
 
 }  // namespace
diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc
index 9fd036f..4ff1e85 100644
--- a/quiche/quic/core/quic_connection.cc
+++ b/quiche/quic/core/quic_connection.cc
@@ -3119,7 +3119,7 @@
     const BufferedPacket& packet = buffered_packets_.front();
     WriteResult result = SendPacketToWriter(
         packet.data.get(), packet.length, packet.self_address.host(),
-        packet.peer_address, per_packet_options_, writer_);
+        packet.peer_address, writer_, packet.ecn_codepoint);
     QUIC_DVLOG(1) << ENDPOINT << "Sending buffered packet, result: " << result;
     if (IsMsgTooBig(writer_, result) && packet.length > long_term_mtu_) {
       // When MSG_TOO_BIG is returned, the system typically knows what the
@@ -3438,7 +3438,8 @@
       if (!coalesced_packet_.MaybeCoalescePacket(
               *packet, send_from_address, send_to_address,
               helper_->GetStreamSendBufferAllocator(),
-              packet_creator_.max_packet_length())) {
+              packet_creator_.max_packet_length(),
+              GetEcnCodepointToSend(send_to_address))) {
         // Failed to coalesce packet, flush current coalesced packet.
         if (!FlushCoalescedPacket()) {
           QUIC_BUG_IF(quic_connection_connected_after_flush_coalesced_failure,
@@ -3451,7 +3452,8 @@
         if (!coalesced_packet_.MaybeCoalescePacket(
                 *packet, send_from_address, send_to_address,
                 helper_->GetStreamSendBufferAllocator(),
-                packet_creator_.max_packet_length())) {
+                packet_creator_.max_packet_length(),
+                GetEcnCodepointToSend(send_to_address))) {
           // Failed to coalesce packet even it is the only packet, raise a write
           // error.
           QUIC_DLOG(ERROR) << ENDPOINT << "Failed to coalesce packet";
@@ -3466,12 +3468,14 @@
         packet_creator_.SetSoftMaxPacketLength(
             coalesced_packet_.max_packet_length() - coalesced_packet_.length());
       }
+      last_ecn_codepoint_sent_ = coalesced_packet_.ecn_codepoint();
       break;
     case BUFFER:
       QUIC_DVLOG(1) << ENDPOINT << "Adding packet: " << packet->packet_number
                     << " to buffered packets";
+      last_ecn_codepoint_sent_ = GetEcnCodepointToSend(send_to_address);
       buffered_packets_.emplace_back(*packet, send_from_address,
-                                     send_to_address);
+                                     send_to_address, last_ecn_codepoint_sent_);
       break;
     case SEND_TO_WRITER:
       // Stop using coalescer from now on.
@@ -3484,9 +3488,9 @@
       //
       // writer_->WritePacket transfers buffer ownership back to the writer.
       packet->release_encrypted_buffer = nullptr;
-      result = SendPacketToWriter(packet->encrypted_buffer, encrypted_length,
-                                  send_from_address.host(), send_to_address,
-                                  per_packet_options_, writer_);
+      result = SendPacketToWriter(
+          packet->encrypted_buffer, encrypted_length, send_from_address.host(),
+          send_to_address, writer_, GetEcnCodepointToSend(send_to_address));
       // This is a work around for an issue with linux UDP GSO batch writers.
       // When sending a GSO packet with 2 segments, if the first segment is
       // larger than the path MTU, instead of EMSGSIZE, the linux kernel returns
@@ -3521,7 +3525,7 @@
       QUIC_DVLOG(1) << ENDPOINT << "Adding packet: " << packet->packet_number
                     << " to buffered packets";
       buffered_packets_.emplace_back(*packet, send_from_address,
-                                     send_to_address);
+                                     send_to_address, last_ecn_codepoint_sent_);
     }
   }
 
@@ -3946,7 +3950,8 @@
       first_serialized_one_rtt_packet_ == nullptr &&
       serialized_packet.encryption_level == ENCRYPTION_FORWARD_SECURE) {
     first_serialized_one_rtt_packet_ = std::make_unique<BufferedPacket>(
-        serialized_packet, self_address(), peer_address());
+        serialized_packet, self_address(), peer_address(),
+        GetEcnCodepointToSend(peer_address()));
   }
   SendOrQueuePacket(std::move(serialized_packet));
 }
@@ -4212,13 +4217,13 @@
 
 WriteResult QuicConnection::SendPacketToWriter(
     const char* buffer, size_t buf_len, const QuicIpAddress& self_address,
-    const QuicSocketAddress& destination_address, PerPacketOptions* options,
-    QuicPacketWriter* writer) {
+    const QuicSocketAddress& destination_address, QuicPacketWriter* writer,
+    const QuicEcnCodepoint ecn_codepoint) {
   QuicEcnCodepoint original_codepoint = GetNextEcnCodepoint();
-  last_ecn_codepoint_sent_ = GetEcnCodepointToSend(destination_address);
-  MaybeSetEcnCodepoint(last_ecn_codepoint_sent_);
-  WriteResult result = writer->WritePacket(buffer, buf_len, self_address,
-                                           destination_address, options);
+  last_ecn_codepoint_sent_ = ecn_codepoint;
+  MaybeSetEcnCodepoint(ecn_codepoint);
+  WriteResult result = writer->WritePacket(
+      buffer, buf_len, self_address, destination_address, per_packet_options_);
   MaybeSetEcnCodepoint(original_codepoint);
   return result;
 }
@@ -4970,17 +4975,18 @@
 
 QuicConnection::BufferedPacket::BufferedPacket(
     const SerializedPacket& packet, const QuicSocketAddress& self_address,
-    const QuicSocketAddress& peer_address)
+    const QuicSocketAddress& peer_address, const QuicEcnCodepoint ecn_codepoint)
     : BufferedPacket(packet.encrypted_buffer, packet.encrypted_length,
-                     self_address, peer_address) {}
+                     self_address, peer_address, ecn_codepoint) {}
 
 QuicConnection::BufferedPacket::BufferedPacket(
     const char* encrypted_buffer, QuicPacketLength encrypted_length,
     const QuicSocketAddress& self_address,
-    const QuicSocketAddress& peer_address)
+    const QuicSocketAddress& peer_address, const QuicEcnCodepoint ecn_codepoint)
     : length(encrypted_length),
       self_address(self_address),
-      peer_address(peer_address) {
+      peer_address(peer_address),
+      ecn_codepoint(ecn_codepoint) {
   data = std::make_unique<char[]>(encrypted_length);
   memcpy(data.get(), encrypted_buffer, encrypted_length);
 }
@@ -5159,7 +5165,7 @@
                        packet->encrypted_buffer, packet->encrypted_length));
   WriteResult result = SendPacketToWriter(
       packet->encrypted_buffer, packet->encrypted_length, self_address.host(),
-      peer_address, per_packet_options_, writer);
+      peer_address, writer, GetEcnCodepointToSend(peer_address));
 
   // If using a batch writer and the probing packet is buffered, flush it.
   if (writer->IsBatchMode() && result.status == WRITE_STATUS_OK &&
@@ -6057,11 +6063,13 @@
                   << "Buffering coalesced packet of len: " << length;
     buffered_packets_.emplace_back(
         buffer, static_cast<QuicPacketLength>(length),
-        coalesced_packet_.self_address(), coalesced_packet_.peer_address());
+        coalesced_packet_.self_address(), coalesced_packet_.peer_address(),
+        coalesced_packet_.ecn_codepoint());
   } else {
     WriteResult result = SendPacketToWriter(
         buffer, length, coalesced_packet_.self_address().host(),
-        coalesced_packet_.peer_address(), per_packet_options_, writer_);
+        coalesced_packet_.peer_address(), writer_,
+        coalesced_packet_.ecn_codepoint());
     if (IsWriteError(result.status)) {
       OnWriteError(result.error_code);
       return false;
@@ -6073,7 +6081,8 @@
                       << "Buffering coalesced packet of len: " << length;
         buffered_packets_.emplace_back(
             buffer, static_cast<QuicPacketLength>(length),
-            coalesced_packet_.self_address(), coalesced_packet_.peer_address());
+            coalesced_packet_.self_address(), coalesced_packet_.peer_address(),
+            coalesced_packet_.ecn_codepoint());
       }
     }
   }
@@ -6425,7 +6434,7 @@
         buffered_packets_.emplace_back(
             first_serialized_one_rtt_packet_->data.get(),
             first_serialized_one_rtt_packet_->length, self_address(),
-            peer_address());
+            peer_address(), first_serialized_one_rtt_packet_->ecn_codepoint);
         packet_buffered = true;
       }
       break;
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index 09c1eed..5645e96 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -1480,11 +1480,13 @@
   struct QUIC_EXPORT_PRIVATE BufferedPacket {
     BufferedPacket(const SerializedPacket& packet,
                    const QuicSocketAddress& self_address,
-                   const QuicSocketAddress& peer_address);
+                   const QuicSocketAddress& peer_address,
+                   QuicEcnCodepoint ecn_codepoint);
     BufferedPacket(const char* encrypted_buffer,
                    QuicPacketLength encrypted_length,
                    const QuicSocketAddress& self_address,
-                   const QuicSocketAddress& peer_address);
+                   const QuicSocketAddress& peer_address,
+                   QuicEcnCodepoint ecn_codepoint);
     // Please note, this buffered packet contains random bytes (and is not
     // *actually* a QUIC packet).
     BufferedPacket(QuicRandom& random, QuicPacketLength encrypted_length,
@@ -1500,6 +1502,7 @@
     // Self and peer addresses when the packet is serialized.
     const QuicSocketAddress self_address;
     const QuicSocketAddress peer_address;
+    QuicEcnCodepoint ecn_codepoint = ECN_NOT_ECT;
   };
 
   // ReceivedPacketInfo comprises the received packet information.
@@ -1983,18 +1986,13 @@
   // Set the ECN codepoint, but only if set_per_packet_options has been called.
   void MaybeSetEcnCodepoint(QuicEcnCodepoint ecn_codepoint);
 
-  // Writes the packet to |writer| with the ECN mark specified in |options|. If
-  // by spec the connection should not send an ECN mark, or the packet is
-  // not on the default path, or it's PTO probe before an ECN packet has been
-  // successfully acked on the path, or QUIC reloadable flag quic_send_ect1 is
-  // false, then it sends Not-ECT instead. Will also set last_ecn_sent_
-  // appropriately. At the end, restores the original setting unless the flag
-  // is false.
+  // Writes the packet to |writer| with the ECN mark specified in
+  // |ecn_codepoint|. Will also set last_ecn_sent_ appropriately.
   WriteResult SendPacketToWriter(const char* buffer, size_t buf_len,
                                  const QuicIpAddress& self_address,
                                  const QuicSocketAddress& destination_address,
-                                 PerPacketOptions* options,
-                                 QuicPacketWriter* writer);
+                                 QuicPacketWriter* writer,
+                                 const QuicEcnCodepoint ecn_codepoint);
 
   QuicConnectionContext context_;
 
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index 64a0358..6a0e9d0 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -17571,6 +17571,66 @@
   EXPECT_EQ(per_packet_options.ecn_codepoint, ECN_NOT_ECT);
 }
 
+TEST_P(QuicConnectionTest, StateMatchesSentEcn) {
+  SetQuicReloadableFlag(quic_send_ect1, true);
+  EXPECT_CALL(*send_algorithm_, SupportsECT1()).WillRepeatedly(Return(true));
+  TestPerPacketOptions per_packet_options;
+  per_packet_options.ecn_codepoint = ECN_ECT1;
+  connection_.set_per_packet_options(&per_packet_options);
+  SendPing();
+  QuicSentPacketManager* sent_packet_manager =
+      QuicConnectionPeer::GetSentPacketManager(&connection_);
+  EXPECT_EQ(writer_->last_ecn_sent(), ECN_ECT1);
+  EXPECT_EQ(
+      QuicSentPacketManagerPeer::GetEct1Sent(sent_packet_manager, INITIAL_DATA),
+      1);
+}
+
+TEST_P(QuicConnectionTest, CoalescedPacketSplitsEcn) {
+  if (!connection_.version().CanSendCoalescedPackets()) {
+    return;
+  }
+  SetQuicReloadableFlag(quic_send_ect1, true);
+  EXPECT_CALL(*send_algorithm_, SupportsECT1()).WillRepeatedly(Return(true));
+  TestPerPacketOptions per_packet_options;
+  per_packet_options.ecn_codepoint = ECN_ECT1;
+  connection_.set_per_packet_options(&per_packet_options);
+  // All these steps are necessary to send an INITIAL ping and save it to be
+  // coalesced, instead of just calling SendPing() and sending it immediately.
+  char buffer[1000];
+  creator_->set_encryption_level(ENCRYPTION_INITIAL);
+  QuicFrames frames;
+  QuicPingFrame ping;
+  frames.emplace_back(QuicFrame(ping));
+  SerializedPacket packet1 = QuicPacketCreatorPeer::SerializeAllFrames(
+      creator_, frames, buffer, sizeof(buffer));
+  connection_.SendOrQueuePacket(std::move(packet1));
+  creator_->set_encryption_level(ENCRYPTION_FORWARD_SECURE);
+  EXPECT_CALL(*send_algorithm_, SupportsECT0()).WillRepeatedly(Return(true));
+  // If not for the line below, these packets would coalesce.
+  per_packet_options.ecn_codepoint = ECN_ECT0;
+  EXPECT_EQ(writer_->packets_write_attempts(), 0);
+  SendPing();
+  EXPECT_EQ(writer_->packets_write_attempts(), 2);
+  EXPECT_EQ(writer_->last_ecn_sent(), ECN_ECT0);
+}
+
+TEST_P(QuicConnectionTest, BufferedPacketRetainsOldEcn) {
+  SetQuicReloadableFlag(quic_send_ect1, true);
+  EXPECT_CALL(*send_algorithm_, SupportsECT1()).WillRepeatedly(Return(true));
+  TestPerPacketOptions per_packet_options;
+  per_packet_options.ecn_codepoint = ECN_ECT1;
+  connection_.set_per_packet_options(&per_packet_options);
+  writer_->SetWriteBlocked();
+  EXPECT_CALL(visitor_, OnWriteBlocked()).Times(2);
+  SendPing();
+  EXPECT_CALL(*send_algorithm_, SupportsECT0()).WillRepeatedly(Return(true));
+  per_packet_options.ecn_codepoint = ECN_ECT0;
+  writer_->SetWritable();
+  connection_.OnCanWrite();
+  EXPECT_EQ(writer_->last_ecn_sent(), ECN_ECT1);
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace quic
diff --git a/quiche/quic/core/quic_packet_creator_test.cc b/quiche/quic/core/quic_packet_creator_test.cc
index ec8bcd7..b2fec7b 100644
--- a/quiche/quic/core/quic_packet_creator_test.cc
+++ b/quiche/quic/core/quic_packet_creator_test.cc
@@ -2276,9 +2276,9 @@
     SerializedPacket serialized = SerializeAllFrames(frames_);
     EXPECT_EQ(level, serialized.encryption_level);
     frames_.clear();
-    ASSERT_TRUE(coalesced.MaybeCoalescePacket(serialized, self_address,
-                                              peer_address, &allocator,
-                                              creator_.max_packet_length()));
+    ASSERT_TRUE(coalesced.MaybeCoalescePacket(
+        serialized, self_address, peer_address, &allocator,
+        creator_.max_packet_length(), ECN_NOT_ECT));
   }
   char buffer[kMaxOutgoingPacketSize];
   size_t coalesced_length = creator_.SerializeCoalescedPacket(
diff --git a/quiche/quic/test_tools/quic_sent_packet_manager_peer.cc b/quiche/quic/test_tools/quic_sent_packet_manager_peer.cc
index c895415..d6256fe 100644
--- a/quiche/quic/test_tools/quic_sent_packet_manager_peer.cc
+++ b/quiche/quic/test_tools/quic_sent_packet_manager_peer.cc
@@ -182,5 +182,17 @@
   return &(sent_packet_manager->peer_ack_ecn_counts_[space]);
 }
 
+// static
+QuicPacketCount QuicSentPacketManagerPeer::GetEct0Sent(
+    QuicSentPacketManager* sent_packet_manager, PacketNumberSpace space) {
+  return sent_packet_manager->ect0_packets_sent_[space];
+}
+
+// static
+QuicPacketCount QuicSentPacketManagerPeer::GetEct1Sent(
+    QuicSentPacketManager* sent_packet_manager, PacketNumberSpace space) {
+  return sent_packet_manager->ect1_packets_sent_[space];
+}
+
 }  // namespace test
 }  // namespace quic
diff --git a/quiche/quic/test_tools/quic_sent_packet_manager_peer.h b/quiche/quic/test_tools/quic_sent_packet_manager_peer.h
index e960619..c0ea673 100644
--- a/quiche/quic/test_tools/quic_sent_packet_manager_peer.h
+++ b/quiche/quic/test_tools/quic_sent_packet_manager_peer.h
@@ -88,6 +88,12 @@
 
   static QuicEcnCounts* GetPeerEcnCounts(
       QuicSentPacketManager* sent_packet_manager, PacketNumberSpace space);
+
+  static QuicPacketCount GetEct0Sent(QuicSentPacketManager* sent_packet_manager,
+                                     PacketNumberSpace space);
+
+  static QuicPacketCount GetEct1Sent(QuicSentPacketManager* sent_packet_manager,
+                                     PacketNumberSpace space);
 };
 
 }  // namespace test