Move the chromium specific QUIC end-to-end tests from net/quic/core

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 19 matching lines @@
 #include "net/http/transport_security_state.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_server.h"
+#include "net/tools/quic/quic_simple_server.h"
 #include "net/tools/quic/test_tools/quic_in_memory_cache_peer.h"
-#include "net/tools/quic/test_tools/server_thread.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;
 using test::QuicInMemoryCachePeer;
-using test::ServerThread;
 
 namespace test {
 
 namespace {
 
 const char kResponseBody[] = "some arbitrary response body";
 
 // Factory for creating HttpTransactions, used by TestTransactionConsumer.
 class TestTransactionFactory : public HttpTransactionFactory {
  public:
@@ skipping 90 matching lines @@
     return resolver;
   }
 
   void SetUp() override {
     QuicInMemoryCachePeer::ResetForTests();
     StartServer();
 
     // Use a mapped host resolver so that request for test.example.com (port 80)
     // reach the server running on localhost.
     std::string map_rule = "MAP test.example.com test.example.com:" +
-                           base::IntToString(server_thread_->GetPort());
+                           base::IntToString(server_->server_address().port());
     EXPECT_TRUE(host_resolver_.AddRuleFromString(map_rule));
 
     // To simplify the test, and avoid the race with the HTTP request, we force
     // QUIC for these requests.
     params_.origins_to_force_quic_on.insert(
         HostPortPair::FromString("test.example.com:443"));
 
     transaction_factory_.reset(new TestTransactionFactory(params_));
   }
 
-  void TearDown() override {
-    StopServer();
-    QuicInMemoryCachePeer::ResetForTests();
-  }
+  void TearDown() override { QuicInMemoryCachePeer::ResetForTests(); }
 
   // 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_enabled = true;
-    QuicServer* server =
-        new QuicServer(CryptoTestUtils::ProofSourceForTesting(), server_config_,
-                       server_config_options_, AllSupportedVersions());
-    server_thread_.reset(new ServerThread(server, server_address_,
-                                          strike_register_no_startup_period_));
-    server_thread_->Initialize();
-    server_address_ =
-        IPEndPoint(server_address_.address(), server_thread_->GetPort());
-    server_thread_->Start();
+    server_.reset(new QuicSimpleServer(CryptoTestUtils::ProofSourceForTesting(),
+                                       server_config_, server_config_options_,
+                                       AllSupportedVersions()));
+    server_->Listen(server_address_);
+    server_address_ = server_->server_address();
+    server_->StartReading();
     server_started_ = true;
   }
 
-  // Stops the QUIC server.
-  void StopServer() {
-    if (!server_started_) {
-      return;
-    }
-    if (server_thread_.get()) {
-      server_thread_->Quit();
-      server_thread_->Join();
-    }
-  }
-
   // 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) {
     QuicInMemoryCache::GetInstance()->AddSimpleResponse(
         "test.example.com", path, response_code, body);
   }
 
@@ skipping 41 matching lines @@
   CTPolicyEnforcer ct_policy_enforcer_;
   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<ServerThread> server_thread_;
+  std::unique_ptr<QuicSimpleServer> server_;
   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 100 matching lines @@
   base::RunLoop().Run();
 
   for (size_t i = 0; i < num_requests; ++i) {
     CheckResponse(*consumers[i], "HTTP/1.1 200", kResponseBody);
   }
   base::STLDeleteElements(&consumers);
 }
 
 }  // namespace test
 }  // namespace net