Make Quic client more memory efficient. Protected by --quic_headers_stream_release_sequencer_buffer.

net/tools/quic/end_to_end_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 #include <sys/epoll.h>
 
 #include <list>
 #include <memory>
 #include <string>
@@ skipping 2594 matching lines @@
   AddRequestAndResponseWithServerPush("example.com", "/push_example", kBody,
                                       push_urls, kNumResources, 0);
 
   client_->client()->set_response_listener(
       std::unique_ptr<QuicClientBase::ResponseListener>(
           new TestResponseListener));
 
   DVLOG(1) << "send request for /push_example";
   EXPECT_EQ(kBody, client_->SendSynchronousRequest(
                        "https://example.com/push_example"));
+  QuicHeadersStream* headers_stream =
+      QuicSpdySessionPeer::GetHeadersStream(client_->client()->session());
+  QuicStreamSequencer* sequencer =
+      ReliableQuicStreamPeer::sequencer(headers_stream);
+  // Headers stream's sequencer buffer shouldn't be released because server push
+  // hasn't finished yet.
+  EXPECT_TRUE(QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(sequencer));
+
   for (const string& url : push_urls) {
     DVLOG(1) << "send request for pushed stream on url " << url;
     string expected_body = "This is server push response body for " + url;
     string response_body = client_->SendSynchronousRequest(url);
     DVLOG(1) << "response body " << response_body;
     EXPECT_EQ(expected_body, response_body);
   }
+  EXPECT_NE(FLAGS_quic_headers_stream_release_sequencer_buffer &&
+                FLAGS_quic_reduce_sequencer_buffer_memory_life_time,
+            QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(sequencer));
 }
 
 TEST_P(EndToEndTestServerPush, ServerPushUnderLimit) {
   // Tests that sending a request which has 4 push resources will trigger server
   // to push those 4 resources and client can handle pushed resources and match
   // them with requests later.
   ASSERT_TRUE(Initialize());
 
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
@@ skipping 269 matching lines @@
   client_->client()->WaitForCryptoHandshakeConfirmed();
   SetPacketLossPercentage(1);
   client_->SendRequest("/huge_response");
   client_->WaitForResponse();
   // TODO(fayang): Fix this test to work with stateless rejects.
   if (!BothSidesSupportStatelessRejects()) {
     VerifyCleanConnection(true);
   }
 }
 
+TEST_P(EndToEndTest, ReleaseHeadersStreamBufferWhenIdle) {
+  // Tests that when client side has no active request and no waiting
+  // PUSH_PROMISE, its headers stream's sequencer buffer should be released.
+  ASSERT_TRUE(Initialize());
+  client_->SendSynchronousRequest("/foo");
+  QuicHeadersStream* headers_stream =
+      QuicSpdySessionPeer::GetHeadersStream(client_->client()->session());
+  QuicStreamSequencer* sequencer =
+      ReliableQuicStreamPeer::sequencer(headers_stream);
+  EXPECT_NE(FLAGS_quic_headers_stream_release_sequencer_buffer &&
+                FLAGS_quic_reduce_sequencer_buffer_memory_life_time,
+            QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(sequencer));
+}
+
 class EndToEndBufferedPacketsTest : public EndToEndTest {
  public:
   EndToEndBufferedPacketsTest() : EndToEndTest() {
     FLAGS_quic_buffer_packet_till_chlo = true;
   }
 
   void CreateClientWithWriter() override {
     LOG(ERROR) << "create client with reorder_writer_ ";
     reorder_writer_ = new PacketReorderingWriter();
     client_.reset(EndToEndTest::CreateQuicClient(reorder_writer_));
@@ skipping 37 matching lines @@
   client_->WaitForResponse();
   EXPECT_EQ(kBarResponseBody, client_->response_body());
   QuicConnectionStats client_stats =
       client_->client()->session()->connection()->GetStats();
   EXPECT_EQ(0u, client_stats.packets_lost);
   EXPECT_EQ(1, client_->client()->GetNumSentClientHellos());
 }
 }  // namespace
 }  // namespace test
 }  // namespace net