Landing Recent QUIC changes until Fri Nov 18 23:21:04 2016 +0000

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 <cstdint>
 #include <list>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "net/base/ip_address.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/core/crypto/aes_128_gcm_12_encrypter.h"
 #include "net/quic/core/crypto/null_encrypter.h"
 #include "net/quic/core/quic_client_session_base.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_framer.h"
 #include "net/quic/core/quic_packet_creator.h"
-#include "net/quic/core/quic_protocol.h"
+#include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_server_id.h"
 #include "net/quic/core/quic_session.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/platform/api/quic_socket_address.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/quic_config_peer.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_flow_controller_peer.h"
 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
 #include "net/quic/test_tools/quic_session_peer.h"
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_stream_peer.h"
 #include "net/quic/test_tools/quic_stream_sequencer_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/test/gtest_util.h"
 #include "net/tools/epoll_server/epoll_server.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
-#include "net/tools/quic/quic_in_memory_cache.h"
+#include "net/tools/quic/quic_http_response_cache.h"
 #include "net/tools/quic/quic_packet_writer_wrapper.h"
 #include "net/tools/quic/quic_server.h"
 #include "net/tools/quic/quic_simple_server_stream.h"
 #include "net/tools/quic/quic_socket_utils.h"
 #include "net/tools/quic/quic_spdy_client_stream.h"
 #include "net/tools/quic/test_tools/packet_dropping_test_writer.h"
 #include "net/tools/quic/test_tools/packet_reordering_writer.h"
 #include "net/tools/quic/test_tools/quic_client_peer.h"
 #include "net/tools/quic/test_tools/quic_dispatcher_peer.h"
 #include "net/tools/quic/test_tools/quic_server_peer.h"
@@ skipping 364 matching lines @@
                               << "case. Otherwise, your test will leak memory.";
     StopServer();
   }
 
   void StartServer() {
     FLAGS_quic_use_cheap_stateless_rejects =
         GetParam().use_cheap_stateless_reject;
 
     auto test_server = new QuicTestServer(
         CryptoTestUtils::ProofSourceForTesting(), server_config_,
-        server_supported_versions_, &in_memory_cache_);
+        server_supported_versions_, &response_cache_);
     server_thread_.reset(new ServerThread(test_server, server_address_));
     if (chlo_multiplier_ != 0) {
       server_thread_->server()->SetChloMultiplier(chlo_multiplier_);
     }
     server_thread_->Initialize();
     server_address_ =
         QuicSocketAddress(server_address_.host(), server_thread_->GetPort());
     QuicDispatcher* dispatcher =
         QuicServerPeer::GetDispatcher(server_thread_->server());
     QuicDispatcherPeer::UseWriter(dispatcher, server_writer_);
@@ skipping 16 matching lines @@
   void StopServer() {
     if (!server_started_)
       return;
     if (server_thread_.get()) {
       server_thread_->Quit();
       server_thread_->Join();
     }
   }
 
   void AddToCache(StringPiece path, int response_code, StringPiece body) {
-    in_memory_cache_.AddSimpleResponse(server_hostname_, path, response_code,
-                                       body);
+    response_cache_.AddSimpleResponse(server_hostname_, path, response_code,
+                                      body);
   }
 
   void SetPacketLossPercentage(int32_t loss) {
     // TODO(rtenneti): enable when we can do random packet loss tests in
     // chrome's tree.
     if (loss != 0 && loss != 100)
       return;
     client_writer_->set_fake_packet_loss_percentage(loss);
     server_writer_->set_fake_packet_loss_percentage(loss);
   }
@@ skipping 69 matching lines @@
 
   // Must be called before Initialize to have effect.
   void SetSpdyStreamFactory(QuicTestServer::StreamFactory* factory) {
     stream_factory_ = factory;
   }
 
   QuicFlagSaver flags_;  // Save/restore all QUIC flag values.
   bool initialized_;
   QuicSocketAddress server_address_;
   string server_hostname_;
-  QuicInMemoryCache in_memory_cache_;
+  QuicHttpResponseCache response_cache_;
   std::unique_ptr<ServerThread> server_thread_;
   std::unique_ptr<QuicTestClient> client_;
   PacketDroppingTestWriter* client_writer_;
   PacketDroppingTestWriter* server_writer_;
   bool server_started_;
   QuicConfig client_config_;
   QuicConfig server_config_;
   QuicVersionVector client_supported_versions_;
   QuicVersionVector server_supported_versions_;
   QuicVersion negotiated_version_;
   size_t chlo_multiplier_;
   QuicTestServer::StreamFactory* stream_factory_;
   bool support_server_push_;
   bool force_hol_blocking_;
 };
 
 // Run all end to end tests with all supported versions.
 INSTANTIATE_TEST_CASE_P(EndToEndTests,
                         EndToEndTest,
                         ::testing::ValuesIn(GetTestParams()));
 
 TEST_P(EndToEndTest, HandshakeSuccessful) {
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
   QuicCryptoStream* crypto_stream =
       QuicSessionPeer::GetCryptoStream(client_->client()->session());
   QuicStreamSequencer* sequencer = QuicStreamPeer::sequencer(crypto_stream);
   EXPECT_NE(FLAGS_quic_release_crypto_stream_buffer,
             QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(sequencer));
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
   QuicSession* server_session = dispatcher->session_map().begin()->second.get();
   crypto_stream = QuicSessionPeer::GetCryptoStream(server_session);
@@ skipping 127 matching lines @@
   // triggering an error response.
   client_->SendCustomSynchronousRequest(headers, "");
   EXPECT_EQ(QuicSimpleServerStream::kErrorResponseBody,
             client_->response_body());
   EXPECT_EQ("500", client_->response_headers()->find(":status")->second);
 }
 
 TEST_P(EndToEndTest, LargePostNoPacketLoss) {
   ASSERT_TRUE(Initialize());
 
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   // 1 MB body.
-  string body;
-  GenerateBody(&body, 1024 * 1024);
+  string body(1024 * 1024, 'a');
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
 
   EXPECT_EQ(kFooResponseBody,
             client_->SendCustomSynchronousRequest(headers, body));
   // TODO(ianswett): There should not be packet loss in this test, but on some
   // platforms the receive buffer overflows.
   VerifyCleanConnection(true);
 }
 
 TEST_P(EndToEndTest, LargePostNoPacketLoss1sRTT) {
   ASSERT_TRUE(Initialize());
   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(1000));
 
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   // 100 KB body.
-  string body;
-  GenerateBody(&body, 100 * 1024);
+  string body(100 * 1024, 'a');
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
 
   EXPECT_EQ(kFooResponseBody,
             client_->SendCustomSynchronousRequest(headers, body));
   VerifyCleanConnection(false);
 }
 
 TEST_P(EndToEndTest, LargePostWithPacketLoss) {
   if (!BothSidesSupportStatelessRejects()) {
     // Connect with lower fake packet loss than we'd like to test.
     // Until b/10126687 is fixed, losing handshake packets is pretty
     // brutal.
     // TODO(jokulik): Until we support redundant SREJ packets, don't
     // drop handshake packets for stateless rejects.
     SetPacketLossPercentage(5);
   }
   ASSERT_TRUE(Initialize());
 
   // Wait for the server SHLO before upping the packet loss.
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
   SetPacketLossPercentage(30);
 
   // 10 KB body.
-  string body;
-  GenerateBody(&body, 1024 * 10);
+  string body(1024 * 10, 'a');
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
 
   EXPECT_EQ(kFooResponseBody,
             client_->SendCustomSynchronousRequest(headers, body));
   VerifyCleanConnection(true);
 }
 
 TEST_P(EndToEndTest, LargePostWithPacketLossAndBlockedSocket) {
   if (!BothSidesSupportStatelessRejects()) {
     // Connect with lower fake packet loss than we'd like to test.  Until
     // b/10126687 is fixed, losing handshake packets is pretty brutal.
     // TODO(jokulik): Until we support redundant SREJ packets, don't
     // drop handshake packets for stateless rejects.
     SetPacketLossPercentage(5);
   }
   ASSERT_TRUE(Initialize());
 
   // Wait for the server SHLO before upping the packet loss.
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
   SetPacketLossPercentage(10);
   client_writer_->set_fake_blocked_socket_percentage(10);
 
   // 10 KB body.
-  string body;
-  GenerateBody(&body, 1024 * 10);
+  string body(1024 * 10, 'a');
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
 
   EXPECT_EQ(kFooResponseBody,
             client_->SendCustomSynchronousRequest(headers, body));
 }
 
 TEST_P(EndToEndTest, LargePostNoPacketLossWithDelayAndReordering) {
   ASSERT_TRUE(Initialize());
 
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
   // Both of these must be called when the writer is not actively used.
   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
   SetReorderPercentage(30);
 
   // 1 MB body.
-  string body;
-  GenerateBody(&body, 1024 * 1024);
+  string body(1024 * 1024, 'a');
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
 
   EXPECT_EQ(kFooResponseBody,
             client_->SendCustomSynchronousRequest(headers, body));
 }
 
 TEST_P(EndToEndTest, LargePostZeroRTTFailure) {
   // Send a request and then disconnect. This prepares the client to attempt
   // a 0-RTT handshake for the next request.
   ASSERT_TRUE(Initialize());
 
-  string body;
-  GenerateBody(&body, 20480);
+  string body(20480, 'a');
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
 
   EXPECT_EQ(kFooResponseBody,
             client_->SendCustomSynchronousRequest(headers, body));
   // In the non-stateless case, the same session is used for both
   // hellos, so the number of hellos sent on that session is 2.  In
@@ skipping 89 matching lines @@
   EXPECT_EQ(2, client_->client()->GetNumSentClientHellos());
 
   VerifyCleanConnection(false);
 }
 
 TEST_P(EndToEndTest, LargePostSynchronousRequest) {
   // Send a request and then disconnect. This prepares the client to attempt
   // a 0-RTT handshake for the next request.
   ASSERT_TRUE(Initialize());
 
-  string body;
-  GenerateBody(&body, 20480);
+  string body(20480, 'a');
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
 
   EXPECT_EQ(kFooResponseBody,
             client_->SendCustomSynchronousRequest(headers, body));
   // In the non-stateless case, the same session is used for both
   // hellos, so the number of hellos sent on that session is 2.  In
@@ skipping 51 matching lines @@
 
 TEST_P(EndToEndTest, SetInitialReceivedConnectionOptions) {
   QuicTagVector initial_received_options;
   initial_received_options.push_back(kTBBR);
   initial_received_options.push_back(kIW10);
   initial_received_options.push_back(kPRST);
   EXPECT_TRUE(server_config_.SetInitialReceivedConnectionOptions(
       initial_received_options));
 
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
   EXPECT_FALSE(server_config_.SetInitialReceivedConnectionOptions(
       initial_received_options));
 
   // Verify that server's configuration is correct.
   server_thread_->Pause();
   EXPECT_TRUE(server_config_.HasReceivedConnectionOptions());
   EXPECT_TRUE(
       ContainsQuicTag(server_config_.ReceivedConnectionOptions(), kTBBR));
   EXPECT_TRUE(
       ContainsQuicTag(server_config_.ReceivedConnectionOptions(), kIW10));
   EXPECT_TRUE(
       ContainsQuicTag(server_config_.ReceivedConnectionOptions(), kPRST));
 }
 
 TEST_P(EndToEndTest, LargePostSmallBandwidthLargeBuffer) {
   ASSERT_TRUE(Initialize());
   SetPacketSendDelay(QuicTime::Delta::FromMicroseconds(1));
   // 256KB per second with a 256KB buffer from server to client.  Wireless
   // clients commonly have larger buffers, but our max CWND is 200.
   server_writer_->set_max_bandwidth_and_buffer_size(
       QuicBandwidth::FromBytesPerSecond(256 * 1024), 256 * 1024);
 
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   // 1 MB body.
-  string body;
-  GenerateBody(&body, 1024 * 1024);
+  string body(1024 * 1024, 'a');
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
 
   EXPECT_EQ(kFooResponseBody,
             client_->SendCustomSynchronousRequest(headers, body));
   // This connection may drop packets, because the buffer is smaller than the
   // max CWND.
   VerifyCleanConnection(true);
 }
 
 TEST_P(EndToEndTest, DoNotSetResumeWriteAlarmIfConnectionFlowControlBlocked) {
   // Regression test for b/14677858.
   // Test that the resume write alarm is not set in QuicConnection::OnCanWrite
   // if currently connection level flow control blocked. If set, this results in
   // an infinite loop in the EpollServer, as the alarm fires and is immediately
   // rescheduled.
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   // Ensure both stream and connection level are flow control blocked by setting
   // the send window offset to 0.
   const uint64_t flow_control_window =
       server_config_.GetInitialStreamFlowControlWindowToSend();
   QuicSpdyClientStream* stream = client_->GetOrCreateStream();
   QuicSession* session = client_->client()->session();
   QuicFlowControllerPeer::SetSendWindowOffset(stream->flow_controller(), 0);
   QuicFlowControllerPeer::SetSendWindowOffset(session->flow_controller(), 0);
   EXPECT_TRUE(stream->flow_controller()->IsBlocked());
@@ skipping 14 matching lines @@
   // connection is still flow control blocked.
   session->connection()->OnCanWrite();
 
   QuicAlarm* resume_writes_alarm =
       QuicConnectionPeer::GetResumeWritesAlarm(session->connection());
   EXPECT_FALSE(resume_writes_alarm->IsSet());
 }
 
 TEST_P(EndToEndTest, InvalidStream) {
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
-  string body;
-  GenerateBody(&body, kMaxPacketSize);
+  string body(kMaxPacketSize, 'a');
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
 
   // Force the client to write with a stream ID belonging to a nonexistent
   // server-side stream.
   QuicSessionPeer::SetNextOutgoingStreamId(client_->client()->session(), 2);
 
   client_->SendCustomSynchronousRequest(headers, body);
   EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
   EXPECT_EQ(QUIC_INVALID_STREAM_ID, client_->connection_error());
 }
 
 // Test that if the the server will close the connection if the client attempts
 // to send a request with overly large headers.
 TEST_P(EndToEndTest, LargeHeaders) {
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
-  string body;
-  GenerateBody(&body, kMaxPacketSize);
+  string body(kMaxPacketSize, 'a');
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
   headers["key1"] = string(15 * 1024, 'a');
   headers["key2"] = string(15 * 1024, 'a');
   headers["key3"] = string(15 * 1024, 'a');
 
   client_->SendCustomSynchronousRequest(headers, body);
   if (FLAGS_quic_limit_uncompressed_headers) {
     EXPECT_EQ(QUIC_HEADERS_TOO_LARGE, client_->stream_error());
   } else {
     EXPECT_EQ(QUIC_STREAM_NO_ERROR, client_->stream_error());
     EXPECT_EQ(kFooResponseBody, client_->response_body());
     EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
   }
   EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
 }
 
 TEST_P(EndToEndTest, EarlyResponseWithQuicStreamNoError) {
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
-  string large_body;
-  GenerateBody(&large_body, 1024 * 1024);
+  string large_body(1024 * 1024, 'a');
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
   // Insert an invalid content_length field in request to trigger an early
   // response from server.
   headers["content-length"] = "-3";
 
   client_->SendCustomSynchronousRequest(headers, large_body);
@@ skipping 32 matching lines @@
   Initialize();
   while (client_->client()->connected()) {
     client_->client()->WaitForEvents();
   }
 }
 
 TEST_P(EndToEndTest, NegotiateMaxOpenStreams) {
   // Negotiate 1 max open stream.
   client_config_.SetMaxStreamsPerConnection(1, 1);
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   if (negotiated_version_ > QUIC_VERSION_34) {
     // Newer versions use max incoming dynamic streams.
     return;
   }
 
   // Make the client misbehave after negotiation.
   const int kServerMaxStreams = kMaxStreamsMinimumIncrement + 1;
   QuicSessionPeer::SetMaxOpenOutgoingStreams(client_->client()->session(),
                                              kServerMaxStreams + 1);
@@ skipping 17 matching lines @@
   EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
 }
 
 TEST_P(EndToEndTest, MaxIncomingDynamicStreamsLimitRespected) {
   // Set a limit on maximum number of incoming dynamic streams.
   // Make sure the limit is respected.
   const uint32_t kServerMaxIncomingDynamicStreams = 1;
   server_config_.SetMaxIncomingDynamicStreamsToSend(
       kServerMaxIncomingDynamicStreams);
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   if (negotiated_version_ <= QUIC_VERSION_34) {
     // Earlier versions negotiated max open streams.
     return;
   }
 
   // Make the client misbehave after negotiation.
   const int kServerMaxStreams =
       kMaxStreamsMinimumIncrement + kServerMaxIncomingDynamicStreams;
   QuicSessionPeer::SetMaxOpenOutgoingStreams(client_->client()->session(),
@@ skipping 20 matching lines @@
 
 TEST_P(EndToEndTest, SetIndependentMaxIncomingDynamicStreamsLimits) {
   // Each endpoint can set max incoming dynamic streams independently.
   const uint32_t kClientMaxIncomingDynamicStreams = 2;
   const uint32_t kServerMaxIncomingDynamicStreams = 1;
   client_config_.SetMaxIncomingDynamicStreamsToSend(
       kClientMaxIncomingDynamicStreams);
   server_config_.SetMaxIncomingDynamicStreamsToSend(
       kServerMaxIncomingDynamicStreams);
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   if (negotiated_version_ <= QUIC_VERSION_34) {
     // Earlier versions negotiated max open streams.
     return;
   }
 
   // The client has received the server's limit and vice versa.
   EXPECT_EQ(kServerMaxIncomingDynamicStreams,
             client_->client()->session()->max_open_outgoing_streams());
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
   QuicSession* server_session = dispatcher->session_map().begin()->second.get();
   EXPECT_EQ(kClientMaxIncomingDynamicStreams,
             server_session->max_open_outgoing_streams());
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, NegotiateCongestionControl) {
   FLAGS_quic_allow_new_bbr = true;
   // Disable this flag because if connection uses multipath sent packet manager,
   // static_cast here does not work.
   FLAGS_quic_enable_multipath = false;
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   CongestionControlType expected_congestion_control_type = kReno;
   switch (GetParam().congestion_control_tag) {
     case kRENO:
       expected_congestion_control_type = kReno;
       break;
     case kTBBR:
       expected_congestion_control_type = kBBR;
       break;
     case kQBIC:
@@ skipping 13 matching lines @@
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, LimitMaxOpenStreams) {
   // Server limits the number of max streams to 2.
   server_config_.SetMaxStreamsPerConnection(2, 2);
   // Client tries to negotiate for 10.
   client_config_.SetMaxStreamsPerConnection(10, 5);
 
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
   if (negotiated_version_ > QUIC_VERSION_34) {
     // No negotiated max streams beyond version 34.
     return;
   }
   QuicConfig* client_negotiated_config = client_->client()->session()->config();
   EXPECT_EQ(2u, client_negotiated_config->MaxStreamsPerConnection());
 }
 
 TEST_P(EndToEndTest, ClientSuggestsRTT) {
   // Client suggests initial RTT, verify it is used.
   const uint32_t kInitialRTT = 20000;
   client_config_.SetInitialRoundTripTimeUsToSend(kInitialRTT);
 
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
   // Pause the server so we can access the server's internals without races.
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
   ASSERT_EQ(1u, dispatcher->session_map().size());
   const QuicSentPacketManagerInterface& client_sent_packet_manager =
       client_->client()->session()->connection()->sent_packet_manager();
   const QuicSentPacketManagerInterface* server_sent_packet_manager =
       GetSentPacketManagerFromFirstServerSession();
 
   EXPECT_EQ(kInitialRTT,
             client_sent_packet_manager.GetRttStats()->initial_rtt_us());
   EXPECT_EQ(kInitialRTT,
             server_sent_packet_manager->GetRttStats()->initial_rtt_us());
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, MaxInitialRTT) {
   // Client tries to suggest twice the server's max initial rtt and the server
   // uses the max.
   client_config_.SetInitialRoundTripTimeUsToSend(2 *
                                                  kMaxInitialRoundTripTimeUs);
 
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
   // Pause the server so we can access the server's internals without races.
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
   ASSERT_EQ(1u, dispatcher->session_map().size());
   QuicSession* session = dispatcher->session_map().begin()->second.get();
   const QuicSentPacketManagerInterface& client_sent_packet_manager =
       client_->client()->session()->connection()->sent_packet_manager();
 
   // Now that acks have been exchanged, the RTT estimate has decreased on the
   // server and is not infinite on the client.
   EXPECT_FALSE(
       client_sent_packet_manager.GetRttStats()->smoothed_rtt().IsInfinite());
   const RttStats& server_rtt_stats =
       *session->connection()->sent_packet_manager().GetRttStats();
   EXPECT_EQ(static_cast<int64_t>(kMaxInitialRoundTripTimeUs),
             server_rtt_stats.initial_rtt_us());
   EXPECT_GE(static_cast<int64_t>(kMaxInitialRoundTripTimeUs),
             server_rtt_stats.smoothed_rtt().ToMicroseconds());
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, MinInitialRTT) {
   // Client tries to suggest 0 and the server uses the default.
   client_config_.SetInitialRoundTripTimeUsToSend(0);
 
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
   // Pause the server so we can access the server's internals without races.
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
   ASSERT_EQ(1u, dispatcher->session_map().size());
   QuicSession* session = dispatcher->session_map().begin()->second.get();
   const QuicSentPacketManagerInterface& client_sent_packet_manager =
       client_->client()->session()->connection()->sent_packet_manager();
@@ skipping 63 matching lines @@
 
 TEST_P(EndToEndTest, MaxStreamsUberTest) {
   if (!BothSidesSupportStatelessRejects()) {
     // Connect with lower fake packet loss than we'd like to test.  Until
     // b/10126687 is fixed, losing handshake packets is pretty brutal.
     // TODO(jokulik): Until we support redundant SREJ packets, don't
     // drop handshake packets for stateless rejects.
     SetPacketLossPercentage(1);
   }
   ASSERT_TRUE(Initialize());
-  string large_body;
-  GenerateBody(&large_body, 10240);
+  string large_body(10240, 'a');
   int max_streams = 100;
 
   AddToCache("/large_response", 200, large_body);
 
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
   SetPacketLossPercentage(10);
 
   for (int i = 0; i < max_streams; ++i) {
     EXPECT_LT(0, client_->SendRequest("/large_response"));
   }
 
   // WaitForEvents waits 50ms and returns true if there are outstanding
   // requests.
   while (client_->client()->WaitForEvents() == true) {
   }
 }
 
 TEST_P(EndToEndTest, StreamCancelErrorTest) {
   ASSERT_TRUE(Initialize());
-  string small_body;
-  GenerateBody(&small_body, 256);
+  string small_body(256, 'a');
 
   AddToCache("/small_response", 200, small_body);
 
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   QuicSession* session = client_->client()->session();
   // Lose the request.
   SetPacketLossPercentage(100);
   EXPECT_LT(0, client_->SendRequest("/small_response"));
   client_->client()->WaitForEvents();
   // Transmit the cancel, and ensure the connection is torn down properly.
   SetPacketLossPercentage(0);
   QuicStreamId stream_id = kClientDataStreamId1;
   session->SendRstStream(stream_id, QUIC_STREAM_CANCELLED, 0);
@@ skipping 107 matching lines @@
   set_client_initial_session_flow_control_receive_window(kClientSessionIFCW);
 
   uint32_t kServerStreamIFCW = 32 * 1024;
   uint32_t kServerSessionIFCW = 48 * 1024;
   set_server_initial_stream_flow_control_receive_window(kServerStreamIFCW);
   set_server_initial_session_flow_control_receive_window(kServerSessionIFCW);
 
   ASSERT_TRUE(Initialize());
 
   // Values are exchanged during crypto handshake, so wait for that to finish.
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
   // Open a data stream to make sure the stream level flow control is updated.
   QuicSpdyClientStream* stream = client_->GetOrCreateStream();
   stream->WriteOrBufferBody("hello", false, nullptr);
 
   // Client should have the right values for server's receive window.
   EXPECT_EQ(kServerStreamIFCW,
             client_->client()
                 ->session()
@@ skipping 32 matching lines @@
   set_client_initial_stream_flow_control_receive_window(kStreamIFCW);
   set_client_initial_session_flow_control_receive_window(kSessionIFCW);
   set_server_initial_stream_flow_control_receive_window(kStreamIFCW);
   set_server_initial_session_flow_control_receive_window(kSessionIFCW);
 
   ASSERT_TRUE(Initialize());
 
   // Wait for crypto handshake to finish. This should have contributed to the
   // crypto stream flow control window, but not affected the session flow
   // control window.
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
   QuicCryptoStream* crypto_stream =
       QuicSessionPeer::GetCryptoStream(client_->client()->session());
   EXPECT_LT(
       QuicFlowControllerPeer::SendWindowSize(crypto_stream->flow_controller()),
       kStreamIFCW);
   EXPECT_EQ(kSessionIFCW, QuicFlowControllerPeer::SendWindowSize(
                               client_->client()->session()->flow_controller()));
 
@@ skipping 22 matching lines @@
   EXPECT_EQ(kSessionIFCW, QuicFlowControllerPeer::ReceiveWindowSize(
                               server_connection_flow_controller));
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, FlowControlsSynced) {
   set_smaller_flow_control_receive_window();
 
   ASSERT_TRUE(Initialize());
 
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
   server_thread_->Pause();
   QuicSpdySession* const client_session = client_->client()->session();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
   auto server_session = static_cast<QuicSpdySession*>(
       dispatcher->session_map().begin()->second.get());
 
   ExpectFlowControlsSynced(client_session->flow_controller(),
@@ skipping 79 matching lines @@
   // interested in has been ACKed. This tests end-to-end ACK notification, and
   // demonstrates that retransmissions do not break this functionality.
   if (!BothSidesSupportStatelessRejects()) {
     // TODO(jokulik): Until we support redundant SREJ packets, don't
     // drop handshake packets for stateless rejects.
     SetPacketLossPercentage(5);
   }
   ASSERT_TRUE(Initialize());
 
   // Wait for the server SHLO before upping the packet loss.
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
   SetPacketLossPercentage(30);
   client_writer_->set_fake_blocked_socket_percentage(10);
 
   // Create a POST request and send the headers only.
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
 
@@ skipping 51 matching lines @@
   EXPECT_EQ("", client_->SendSynchronousRequest("/foo"));
   EXPECT_TRUE(client_->response_headers()->empty());
   EXPECT_EQ(QUIC_PUBLIC_RESET, client_->connection_error());
 }
 
 // Send a public reset from the server for a different connection ID.
 // It should be ignored.
 TEST_P(EndToEndTest, ServerSendPublicResetWithDifferentConnectionId) {
   ASSERT_TRUE(Initialize());
 
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   // Send the public reset.
   QuicConnectionId incorrect_connection_id =
       client_->client()->session()->connection()->connection_id() + 1;
   QuicPublicResetPacket header;
   header.public_header.connection_id = incorrect_connection_id;
   header.public_header.reset_flag = true;
   header.public_header.version_flag = false;
   header.rejected_packet_number = 10101;
   QuicFramer framer(server_supported_versions_, QuicTime::Zero(),
@@ skipping 44 matching lines @@
   // The connection should be unaffected.
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
 }
 
 // Send a version negotiation packet from the server for a different
 // connection ID.  It should be ignored.
 TEST_P(EndToEndTest, ServerSendVersionNegotiationWithDifferentConnectionId) {
   ASSERT_TRUE(Initialize());
 
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   // Send the version negotiation packet.
   QuicConnectionId incorrect_connection_id =
       client_->client()->session()->connection()->connection_id() + 1;
   std::unique_ptr<QuicEncryptedPacket> packet(
       QuicFramer::BuildVersionNegotiationPacket(incorrect_connection_id,
                                                 server_supported_versions_));
   testing::NiceMock<MockQuicConnectionDebugVisitor> visitor;
   client_->client()->session()->connection()->set_debug_visitor(&visitor);
   EXPECT_CALL(visitor, OnIncorrectConnectionId(incorrect_connection_id))
@@ skipping 121 matching lines @@
   // The connection should not be terminated.
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
 }
 
 // A test stream that gives |response_body_| as an error response body.
 class ServerStreamWithErrorResponseBody : public QuicSimpleServerStream {
  public:
   ServerStreamWithErrorResponseBody(QuicStreamId id,
                                     QuicSpdySession* session,
-                                    QuicInMemoryCache* in_memory_cache,
+                                    QuicHttpResponseCache* response_cache,
                                     string response_body)
-      : QuicSimpleServerStream(id, session, in_memory_cache),
+      : QuicSimpleServerStream(id, session, response_cache),
         response_body_(std::move(response_body)) {}
 
   ~ServerStreamWithErrorResponseBody() override {}
 
  protected:
   void SendErrorResponse() override {
     DVLOG(1) << "Sending error response for stream " << id();
     SpdyHeaderBlock headers;
     headers[":status"] = "500";
     headers["content-length"] = base::UintToString(response_body_.size());
     // This method must call CloseReadSide to cause the test case, StopReading
     // is not sufficient.
     QuicStreamPeer::CloseReadSide(this);
     SendHeadersAndBody(std::move(headers), response_body_);
   }
 
   string response_body_;
 };
 
 class StreamWithErrorFactory : public QuicTestServer::StreamFactory {
  public:
   explicit StreamWithErrorFactory(string response_body)
       : response_body_(std::move(response_body)) {}
 
   ~StreamWithErrorFactory() override {}
 
   QuicSimpleServerStream* CreateStream(
       QuicStreamId id,
       QuicSpdySession* session,
-      QuicInMemoryCache* in_memory_cache) override {
-    return new ServerStreamWithErrorResponseBody(id, session, in_memory_cache,
+      QuicHttpResponseCache* response_cache) override {
+    return new ServerStreamWithErrorResponseBody(id, session, response_cache,
                                                  response_body_);
   }
 
  private:
   string response_body_;
 };
 
 // A test server stream that drops all received body.
 class ServerStreamThatDropsBody : public QuicSimpleServerStream {
  public:
   ServerStreamThatDropsBody(QuicStreamId id,
                             QuicSpdySession* session,
-                            QuicInMemoryCache* in_memory_cache)
-      : QuicSimpleServerStream(id, session, in_memory_cache) {}
+                            QuicHttpResponseCache* response_cache)
+      : QuicSimpleServerStream(id, session, response_cache) {}
 
   ~ServerStreamThatDropsBody() override {}
 
  protected:
   void OnDataAvailable() override {
     while (HasBytesToRead()) {
       struct iovec iov;
       if (GetReadableRegions(&iov, 1) == 0) {
         // No more data to read.
         break;
@@ skipping 21 matching lines @@
 
 class ServerStreamThatDropsBodyFactory : public QuicTestServer::StreamFactory {
  public:
   ServerStreamThatDropsBodyFactory() {}
 
   ~ServerStreamThatDropsBodyFactory() override{};
 
   QuicSimpleServerStream* CreateStream(
       QuicStreamId id,
       QuicSpdySession* session,
-      QuicInMemoryCache* in_memory_cache) override {
-    return new ServerStreamThatDropsBody(id, session, in_memory_cache);
+      QuicHttpResponseCache* response_cache) override {
+    return new ServerStreamThatDropsBody(id, session, response_cache);
   }
 };
 
 // A test server stream that sends response with body size greater than 4GB.
 class ServerStreamThatSendsHugeResponse : public QuicSimpleServerStream {
  public:
   ServerStreamThatSendsHugeResponse(QuicStreamId id,
                                     QuicSpdySession* session,
-                                    QuicInMemoryCache* in_memory_cache,
+                                    QuicHttpResponseCache* response_cache,
                                     int64_t body_bytes)
-      : QuicSimpleServerStream(id, session, in_memory_cache),
+      : QuicSimpleServerStream(id, session, response_cache),
         body_bytes_(body_bytes) {}
 
   ~ServerStreamThatSendsHugeResponse() override {}
 
  protected:
   void SendResponse() override {
-    QuicInMemoryCache::Response response;
-    string body;
-    GenerateBody(&body, body_bytes_);
+    QuicHttpResponseCache::Response response;
+    string body(body_bytes_, 'a');
     response.set_body(body);
     SendHeadersAndBodyAndTrailers(response.headers().Clone(), response.body(),
                                   response.trailers().Clone());
   }
 
  private:
   // Use a explicit int64_t rather than size_t to simulate a 64-bit server
   // talking to a 32-bit client.
   int64_t body_bytes_;
 };
 
 class ServerStreamThatSendsHugeResponseFactory
     : public QuicTestServer::StreamFactory {
  public:
   explicit ServerStreamThatSendsHugeResponseFactory(int64_t body_bytes)
       : body_bytes_(body_bytes) {}
 
   ~ServerStreamThatSendsHugeResponseFactory() override{};
 
   QuicSimpleServerStream* CreateStream(
       QuicStreamId id,
       QuicSpdySession* session,
-      QuicInMemoryCache* in_memory_cache) override {
-    return new ServerStreamThatSendsHugeResponse(id, session, in_memory_cache,
+      QuicHttpResponseCache* response_cache) override {
+    return new ServerStreamThatSendsHugeResponse(id, session, response_cache,
                                                  body_bytes_);
   }
 
   int64_t body_bytes_;
 };
 
 // A test client stream that drops all received body.
 class ClientStreamThatDropsBody : public QuicSpdyClientStream {
  public:
   ClientStreamThatDropsBody(QuicStreamId id, QuicClientSession* session)
@@ skipping 83 matching lines @@
   set_smaller_flow_control_receive_window();
 
   // Verify that an incoming FIN is recorded in a stream object even if the read
   // side has been closed.  This prevents an entry from being made in
   // locally_close_streams_highest_offset_ (which will never be deleted).
   // To set up the test condition, the server must do the following in order:
   // start sending the response and call CloseReadSide
   // receive the FIN of the request
   // send the FIN of the response
 
-  string response_body;
   // The response body must be larger than the flow control window so the server
   // must receive a window update from the client before it can finish sending
   // it.
   uint32_t response_body_size =
       2 * client_config_.GetInitialStreamFlowControlWindowToSend();
-  GenerateBody(&response_body, response_body_size);
+  string response_body(response_body_size, 'a');
 
   StreamWithErrorFactory stream_factory(response_body);
   SetSpdyStreamFactory(&stream_factory);
 
   ASSERT_TRUE(Initialize());
 
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   // A POST that gets an early error response, after the headers are received
   // and before the body is received, due to invalid content-length.
   // Set an invalid content-length, so the request will receive an early 500
   // response.
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/garbage";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
   headers["content-length"] = "-1";
 
   // The body must be large enough that the FIN will be in a different packet
   // than the end of the headers, but short enough to not require a flow control
   // update.  This allows headers processing to trigger the error response
   // before the request FIN is processed but receive the request FIN before the
   // response is sent completely.
   const uint32_t kRequestBodySize = kMaxPacketSize + 10;
-  string request_body;
-  GenerateBody(&request_body, kRequestBodySize);
+  string request_body(kRequestBodySize, 'a');
 
   // Send the request.
   client_->SendMessage(headers, request_body);
   client_->WaitForResponse();
   EXPECT_EQ("500", client_->response_headers()->find(":status")->second);
 
   // Pause the server so we can access the server's internals without races.
   server_thread_->Pause();
 
   QuicDispatcher* dispatcher =
@@ skipping 14 matching lines @@
 
 TEST_P(EndToEndTest, LargePostEarlyResponse) {
   const uint32_t kWindowSize = 65536;
   set_client_initial_stream_flow_control_receive_window(kWindowSize);
   set_client_initial_session_flow_control_receive_window(kWindowSize);
   set_server_initial_stream_flow_control_receive_window(kWindowSize);
   set_server_initial_session_flow_control_receive_window(kWindowSize);
 
   ASSERT_TRUE(Initialize());
 
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   // POST to a URL that gets an early error response, after the headers are
   // received and before the body is received.
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
   headers["content-length"] = "-1";
 
   // Tell the client to not close the stream if it receives an early response.
   client_->set_allow_bidirectional_data(true);
   // Send the headers.
   client_->SendMessage(headers, "", /*fin=*/false);
 
   // Receive the response and let the server close writing.
   client_->WaitForInitialResponse();
   EXPECT_EQ("500", client_->response_headers()->find(":status")->second);
 
   // Receive the reset stream from server on early response.
   QuicStream* stream =
       client_->client()->session()->GetOrCreateStream(kClientDataStreamId1);
   // The stream is reset by server's reset stream.
   EXPECT_EQ(stream, nullptr);
 }
 
 TEST_P(EndToEndTest, Trailers) {
   // Test sending and receiving HTTP/2 Trailers (trailing HEADERS frames).
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   // Set reordering to ensure that Trailers arriving before body is ok.
   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
   SetReorderPercentage(30);
 
   // Add a response with headers, body, and trailers.
   const string kBody = "body content";
 
   SpdyHeaderBlock headers;
   headers[":status"] = "200";
   headers[":version"] = "HTTP/1.1";
   headers["content-length"] = IntToString(kBody.size());
 
   SpdyHeaderBlock trailers;
   trailers["some-trailing-header"] = "trailing-header-value";
 
-  in_memory_cache_.AddResponse(server_hostname_, "/trailer_url",
-                               std::move(headers), kBody, trailers.Clone());
+  response_cache_.AddResponse(server_hostname_, "/trailer_url",
+                              std::move(headers), kBody, trailers.Clone());
 
   EXPECT_EQ(kBody, client_->SendSynchronousRequest("/trailer_url"));
   EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
   EXPECT_EQ(trailers, client_->response_trailers());
 }
 
 class EndToEndTestServerPush : public EndToEndTest {
  protected:
   const size_t kNumMaxStreams = 10;
 
@@ skipping 14 matching lines @@
                                            string path,
                                            string response_body,
                                            string* push_urls,
                                            const size_t num_resources,
                                            const size_t resource_size) {
     bool use_large_response = resource_size != 0;
     string large_resource;
     if (use_large_response) {
       // Generate a response common body larger than flow control window for
       // push response.
-      GenerateBody(&large_resource, resource_size);
+      large_resource = string(resource_size, 'a');
     }
-    std::list<QuicInMemoryCache::ServerPushInfo> push_resources;
+    std::list<QuicHttpResponseCache::ServerPushInfo> push_resources;
     for (size_t i = 0; i < num_resources; ++i) {
       string url = push_urls[i];
       GURL resource_url(url);
       string body = use_large_response
                         ? large_resource
                         : "This is server push response body for " + url;
       SpdyHeaderBlock response_headers;
       response_headers[":version"] = "HTTP/1.1";
       response_headers[":status"] = "200";
       response_headers["content-length"] = IntToString(body.size());
-      push_resources.push_back(QuicInMemoryCache::ServerPushInfo(
+      push_resources.push_back(QuicHttpResponseCache::ServerPushInfo(
           resource_url, std::move(response_headers), kV3LowestPriority, body));
     }
 
-    in_memory_cache_.AddSimpleResponseWithServerPushResources(
+    response_cache_.AddSimpleResponseWithServerPushResources(
         host, path, 200, response_body, push_resources);
   }
 };
 
 // Run all server push end to end tests with all supported versions.
 INSTANTIATE_TEST_CASE_P(EndToEndTestsServerPush,
                         EndToEndTestServerPush,
                         ::testing::ValuesIn(GetTestParams()));
 
 TEST_P(EndToEndTestServerPush, ServerPush) {
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   // Set reordering to ensure that body arriving before PUSH_PROMISE is ok.
   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
   SetReorderPercentage(30);
 
   // Add a response with headers, body, and push resources.
   const string kBody = "body content";
   size_t kNumResources = 4;
   string push_urls[] = {"https://example.com/font.woff",
                         "https://example.com/script.js",
@@ skipping 26 matching lines @@
   EXPECT_NE(FLAGS_quic_headers_stream_release_sequencer_buffer,
             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();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   // Set reordering to ensure that body arriving before PUSH_PROMISE is ok.
   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
   SetReorderPercentage(30);
 
   // Add a response with headers, body, and push resources.
   const string kBody = "body content";
   size_t const kNumResources = 4;
   string push_urls[] = {
       "https://example.com/font.woff", "https://example.com/script.js",
@@ skipping 26 matching lines @@
   EXPECT_EQ(1u, client_->num_requests());
   EXPECT_EQ(1u + kNumResources, client_->num_responses());
 }
 
 TEST_P(EndToEndTestServerPush, ServerPushOverLimitNonBlocking) {
   // Tests that when streams are not blocked by flow control or congestion
   // control, pushing even more resources than max number of open outgoing
   // streams should still work because all response streams get closed
   // immediately after pushing resources.
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   // Set reordering to ensure that body arriving before PUSH_PROMISE is ok.
   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
   SetReorderPercentage(30);
 
   // Add a response with headers, body, and push resources.
   const string kBody = "body content";
 
   // One more resource than max number of outgoing stream of this session.
   const size_t kNumResources = 1 + kNumMaxStreams;  // 11.
@@ skipping 37 matching lines @@
   size_t kFlowControlWnd = 20 * 1024;  // 20KB.
   // Response body is larger than 1 flow controlblock window.
   size_t kBodySize = kFlowControlWnd * 2;
   set_client_initial_stream_flow_control_receive_window(kFlowControlWnd);
   // Make sure conntection level flow control window is large enough not to
   // block data being sent out though they will be blocked by stream level one.
   set_client_initial_session_flow_control_receive_window(
       kBodySize * kNumMaxStreams + 1024);
 
   ASSERT_TRUE(Initialize());
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
   // Set reordering to ensure that body arriving before PUSH_PROMISE is ok.
   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
   SetReorderPercentage(30);
 
   // Add a response with headers, body, and push resources.
   const string kBody = "body content";
 
   const size_t kNumResources = kNumMaxStreams + 1;
   string push_urls[11];
@@ skipping 92 matching lines @@
   // This test tests a huge post with introduced packet loss from client to
   // server and body size greater than 4GB, making sure QUIC code does not break
   // for 32-bit builds.
   ServerStreamThatDropsBodyFactory stream_factory;
   SetSpdyStreamFactory(&stream_factory);
   ASSERT_TRUE(Initialize());
   // Set client's epoll server's time out to 0 to make this test be finished
   // within a short time.
   client_->epoll_server()->set_timeout_in_us(0);
 
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
   SetPacketLossPercentage(1);
   // To avoid storing the whole request body in memory, use a loop to repeatedly
   // send body size of kSizeBytes until the whole request body size is reached.
   const int kSizeBytes = 128 * 1024;
   // Request body size is 4G plus one more kSizeBytes.
   int64_t request_body_size_bytes = pow(2, 32) + kSizeBytes;
   ASSERT_LT(INT64_C(4294967296), request_body_size_bytes);
-  string body;
-  GenerateBody(&body, kSizeBytes);
+  string body(kSizeBytes, 'a');
 
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
   headers["content-length"] = IntToString(request_body_size_bytes);
 
   client_->SendMessage(headers, "", /*fin=*/false);
 
@@ skipping 28 matching lines @@
   client_.reset(client);
   static EpollEvent event(EPOLLOUT, false);
   client_writer_->Initialize(
       QuicConnectionPeer::GetHelper(client_->client()->session()->connection()),
       QuicConnectionPeer::GetAlarmFactory(
           client_->client()->session()->connection()),
       new ClientDelegate(client_->client()));
   initialized_ = true;
   ASSERT_TRUE(client_->client()->connected());
 
-  client_->client()->WaitForCryptoHandshakeConfirmed();
+  EXPECT_TRUE(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) {
@@ skipping 55 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