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

net/quic/chromium/quic_end_to_end_unittest.cc

 // Copyright 2013 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 <memory>
 #include <ostream>
 #include <utility>
 #include <vector>
 
 #include "base/compiler_specific.h"
@@ skipping 18 matching lines @@
 #include "net/http/transport_security_state.h"
 #include "net/log/net_log_with_source.h"
 #include "net/proxy/proxy_service.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/gtest_util.h"
 #include "net/test/test_data_directory.h"
-#include "net/tools/quic/quic_in_memory_cache.h"
+#include "net/tools/quic/quic_http_response_cache.h"
 #include "net/tools/quic/quic_simple_server.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using base::StringPiece;
 
 namespace net {
 
 using test::IsOk;
@@ skipping 122 matching lines @@
   // Starts the QUIC server listening on a random port.
   void StartServer() {
     server_address_ = IPEndPoint(IPAddress(127, 0, 0, 1), 0);
     server_config_.SetInitialStreamFlowControlWindowToSend(
         kInitialStreamFlowControlWindowForTest);
     server_config_.SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
     server_config_options_.token_binding_params = QuicTagVector{kTB10, kP256};
     server_.reset(new QuicSimpleServer(
         CryptoTestUtils::ProofSourceForTesting(), server_config_,
-        server_config_options_, AllSupportedVersions(), &in_memory_cache_));
+        server_config_options_, AllSupportedVersions(), &response_cache_));
     server_->Listen(server_address_);
     server_address_ = server_->server_address();
     server_->StartReading();
     server_started_ = true;
   }
 
   // Adds an entry to the cache used by the QUIC server to serve
   // responses.
   void AddToCache(StringPiece path,
                   int response_code,
                   StringPiece response_detail,
                   StringPiece body) {
-    in_memory_cache_.AddSimpleResponse("test.example.com", path, response_code,
-                                       body);
+    response_cache_.AddSimpleResponse("test.example.com", path, response_code,
+                                      body);
   }
 
   // Populates |request_body_| with |length_| ASCII bytes.
   void GenerateBody(size_t length) {
     request_body_.clear();
     request_body_.reserve(length);
     for (size_t i = 0; i < length; ++i) {
       request_body_.append(1, static_cast<char>(32 + i % (126 - 32)));
     }
   }
@@ skipping 34 matching lines @@
   scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_;
   std::unique_ptr<ProxyService> proxy_service_;
   std::unique_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
   HttpServerPropertiesImpl http_server_properties_;
   HttpNetworkSession::Params params_;
   std::unique_ptr<TestTransactionFactory> transaction_factory_;
   HttpRequestInfo request_;
   std::string request_body_;
   std::unique_ptr<UploadDataStream> upload_data_stream_;
   std::unique_ptr<QuicSimpleServer> server_;
-  QuicInMemoryCache in_memory_cache_;
+  QuicHttpResponseCache response_cache_;
   IPEndPoint server_address_;
   std::string server_hostname_;
   QuicConfig server_config_;
   QuicCryptoServerConfig::ConfigOptions server_config_options_;
   bool server_started_;
   bool strike_register_no_startup_period_;
 };
 
 INSTANTIATE_TEST_CASE_P(Tests,
                         QuicEndToEndTest,
@@ skipping 97 matching lines @@
 
   // Will terminate when the last consumer completes.
   base::RunLoop().Run();
 
   for (const auto& consumer : consumers)
     CheckResponse(*consumer.get(), "HTTP/1.1 200", kResponseBody);
 }
 
 }  // namespace test
 }  // namespace net