Deprecate --gfe2_reloadable_flag_quic_avoid_leak_writer_buffer.

PiperOrigin-RevId: 322151857
Change-Id: Ie85db746d5ff06ca3b7ad53d2b83620d148af1c8

quic/core/quic_connection_test.cc

diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index e637ad2..060a971 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -473,12 +473,8 @@
   QuicPacketBuffer GetNextWriteLocation(
       const QuicIpAddress& /*self_address*/,
       const QuicSocketAddress& /*peer_address*/) override {
-    if (GetQuicReloadableFlag(quic_avoid_leak_writer_buffer)) {
-      return {AllocPacketBuffer(),
-              [this](const char* p) { FreePacketBuffer(p); }};
-    }
-    // Do not use writer buffer for serializing packets.
-    return {nullptr, nullptr};
+    return {AllocPacketBuffer(),
+            [this](const char* p) { FreePacketBuffer(p); }};
   }
 
   WriteResult Flush() override {

quic/core/quic_packet_creator.cc

diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index 131ef5e..a0f189c 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -469,14 +469,6 @@
   QUIC_CACHELINE_ALIGNED char stack_buffer[kMaxOutgoingPacketSize];
   QuicOwnedPacketBuffer external_buffer(delegate_->GetPacketBuffer());
 
-  if (!avoid_leak_writer_buffer_ && external_buffer.release_buffer != nullptr) {
-    // This is not a flag count because it is incremented when flag is false.
-    QUIC_CODE_COUNT(quic_avoid_leak_writer_buffer_flag_false_noop_1);
-
-    // Setting it to nullptr to keep the behavior unchanged when flag is false.
-    external_buffer.release_buffer = nullptr;
-  }
-
   if (external_buffer.buffer == nullptr) {
     external_buffer.buffer = stack_buffer;
     external_buffer.release_buffer = nullptr;
@@ -510,12 +502,9 @@
   packet_.encrypted_buffer = nullptr;
   packet_.encrypted_length = 0;
   packet_.fate = SEND_TO_WRITER;
-  if (avoid_leak_writer_buffer_) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_avoid_leak_writer_buffer, 2, 3);
-    QUIC_BUG_IF(packet_.release_encrypted_buffer != nullptr)
-        << "packet_.release_encrypted_buffer should be empty";
-    packet_.release_encrypted_buffer = nullptr;
-  }
+  QUIC_BUG_IF(packet_.release_encrypted_buffer != nullptr)
+      << "packet_.release_encrypted_buffer should be empty";
+  packet_.release_encrypted_buffer = nullptr;
   DCHECK(packet_.retransmittable_frames.empty());
   DCHECK(packet_.nonretransmittable_frames.empty());
   packet_.largest_acked.Clear();
@@ -594,14 +583,6 @@
   QUIC_CACHELINE_ALIGNED char stack_buffer[kMaxOutgoingPacketSize];
   QuicOwnedPacketBuffer packet_buffer(delegate_->GetPacketBuffer());
 
-  if (!avoid_leak_writer_buffer_ && packet_buffer.release_buffer != nullptr) {
-    // This is not a flag count because it is incremented when flag is false.
-    QUIC_CODE_COUNT(quic_avoid_leak_writer_buffer_flag_false_noop_2);
-
-    // Setting it to nullptr to keep the behavior unchanged when flag is false.
-    packet_buffer.release_buffer = nullptr;
-  }
-
   if (packet_buffer.buffer == nullptr) {
     packet_buffer.buffer = stack_buffer;
     packet_buffer.release_buffer = nullptr;
@@ -692,15 +673,10 @@
   packet_size_ = 0;
   packet_.encrypted_buffer = encrypted_buffer;
   packet_.encrypted_length = encrypted_length;
-  if (avoid_leak_writer_buffer_) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_avoid_leak_writer_buffer, 3, 3);
-    packet_buffer.buffer = nullptr;
-    packet_.release_encrypted_buffer = std::move(packet_buffer).release_buffer;
-  } else {
-    // If flag --quic_avoid_leak_writer_buffer is false, the release function
-    // should be empty.
-    DCHECK(packet_buffer.release_buffer == nullptr);
-  }
+
+  packet_buffer.buffer = nullptr;
+  packet_.release_encrypted_buffer = std::move(packet_buffer).release_buffer;
+
   packet_.retransmittable_frames.push_back(QuicFrame(frame));
   OnSerializedPacket();
 }
@@ -850,16 +826,9 @@
   queued_frames_.clear();
   packet_.encrypted_buffer = encrypted_buffer.buffer;
   packet_.encrypted_length = encrypted_length;
-  if (avoid_leak_writer_buffer_) {
-    QUIC_RELOADABLE_FLAG_COUNT_N(quic_avoid_leak_writer_buffer, 1, 3);
-    encrypted_buffer.buffer = nullptr;
-    packet_.release_encrypted_buffer =
-        std::move(encrypted_buffer).release_buffer;
-  } else {
-    // If flag --quic_avoid_leak_writer_buffer is false, the release function
-    // should be empty.
-    DCHECK(encrypted_buffer.release_buffer == nullptr);
-  }
+
+  encrypted_buffer.buffer = nullptr;
+  packet_.release_encrypted_buffer = std::move(encrypted_buffer).release_buffer;
 }
 
 std::unique_ptr<QuicEncryptedPacket>

quic/core/quic_packet_creator.h

diff --git a/quic/core/quic_packet_creator.h b/quic/core/quic_packet_creator.h
index 976f4f6..7f3aa51 100644
--- a/quic/core/quic_packet_creator.h
+++ b/quic/core/quic_packet_creator.h
@@ -639,9 +639,6 @@
   // negotiates this during the handshake.
   QuicByteCount max_datagram_frame_size_;
 
-  const bool avoid_leak_writer_buffer_ =
-      GetQuicReloadableFlag(quic_avoid_leak_writer_buffer);
-
   // When true, this will override the padding generation code to disable it.
   // TODO(fayang): remove this when deprecating
   // quic_determine_serialized_packet_fate_early.

quic/core/quic_packet_creator_test.cc

diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index 65377ef..4361ed9 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -1723,9 +1723,6 @@
         EXPECT_EQ(external_buffer.buffer, serialized_packet.encrypted_buffer);
       }));
   creator_.FlushCurrentPacket();
-  if (!GetQuicReloadableFlag(quic_avoid_leak_writer_buffer)) {
-    delete[] buffer;
-  }
 }
 
 // Test for error found in