Revert of Allow use of Mojo/V8 ProxyResolvers with URLRequestContextBuilder.

net/proxy/proxy_script_fetcher_impl_unittest.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 "net/proxy/proxy_script_fetcher_impl.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 21 matching lines @@
 #include "net/http/http_cache.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/http/transport_security_state.h"
 #include "net/net_features.h"
 #include "net/socket/client_socket_pool_manager.h"
 #include "net/socket/transport_client_socket_pool.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
-#include "net/test/embedded_test_server/simple_connection_listener.h"
+#include "net/test/embedded_test_server/embedded_test_server_connection_listener.h"
 #include "net/test/gtest_util.h"
 #include "net/url_request/url_request_context_storage.h"
 #include "net/url_request/url_request_file_job.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 #if !BUILDFLAG(DISABLE_FILE_SUPPORT)
@@ skipping 14 matching lines @@
 namespace {
 
 const base::FilePath::CharType kDocRoot[] =
     FILE_PATH_LITERAL("net/data/proxy_script_fetcher_unittest");
 
 struct FetchResult {
   int code;
   base::string16 text;
 };
 
+// Waits for the specified number of connection attempts to be seen.
+class WaitForConnectionsListener
+    : public test_server::EmbeddedTestServerConnectionListener {
+ public:
+  explicit WaitForConnectionsListener(int expected_num_connections)
+      : expected_num_connections_(expected_num_connections),
+        task_runner_(base::SequencedTaskRunnerHandle::Get()) {}
+
+  void AcceptedSocket(const StreamSocket& socket) override {
+    ++seen_connections_;
+    EXPECT_LE(seen_connections_, expected_num_connections_);
+    if (expected_num_connections_ == seen_connections_)
+      task_runner_->PostTask(FROM_HERE, run_loop_.QuitClosure());
+  }
+
+  void ReadFromSocket(const StreamSocket& socket, int rv) override {}
+
+  void Wait() { run_loop_.Run(); }
+
+ private:
+  int seen_connections_ = 0;
+  int expected_num_connections_;
+
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
+
+  base::RunLoop run_loop_;
+
+  DISALLOW_COPY_AND_ASSIGN(WaitForConnectionsListener);
+};
+
 // A non-mock URL request which can access http:// and file:// urls, in the case
 // the tests were built with file support.
 class RequestContext : public URLRequestContext {
  public:
   RequestContext() : storage_(this) {
     ProxyConfig no_proxy;
     storage_.set_host_resolver(
         std::unique_ptr<HostResolver>(new MockHostResolver));
     storage_.set_cert_verifier(base::WrapUnique(new MockCertVerifier));
     storage_.set_transport_security_state(
@@ skipping 419 matching lines @@
 }
 
 // Makes sure that a request gets through when the socket pool is full, so
 // ProxyScriptFetcherImpl can use the same URLRequestContext as everything else.
 TEST_F(ProxyScriptFetcherImplTest, Priority) {
   // Enough requests to exceed the per-pool limit, which is also enough to
   // exceed the per-group limit.
   int num_requests = 10 + ClientSocketPoolManager::max_sockets_per_pool(
                               HttpNetworkSession::NORMAL_SOCKET_POOL);
 
-  net::test_server::SimpleConnectionListener connection_listener(
-      num_requests, net::test_server::SimpleConnectionListener::
-                        FAIL_ON_ADDITIONAL_CONNECTIONS);
+  WaitForConnectionsListener connection_listener(num_requests);
   test_server_.SetConnectionListener(&connection_listener);
   ASSERT_TRUE(test_server_.Start());
 
   std::vector<std::unique_ptr<ProxyScriptFetcherImpl>> pac_fetchers;
 
   TestCompletionCallback callback;
   base::string16 text;
   for (int i = 0; i < num_requests; i++) {
     std::unique_ptr<ProxyScriptFetcherImpl> pac_fetcher =
         base::MakeUnique<ProxyScriptFetcherImpl>(&context_);
     GURL url(test_server_.GetURL("/hung"));
     // Fine to use the same string and callback for all of these, as they should
     // all hang.
     int result = pac_fetcher->Fetch(url, &text, callback.callback());
     EXPECT_THAT(result, IsError(ERR_IO_PENDING));
     pac_fetchers.push_back(std::move(pac_fetcher));
   }
 
-  connection_listener.WaitForConnections();
+  connection_listener.Wait();
   // None of the callbacks should have been invoked - all jobs should still be
   // hung.
   EXPECT_FALSE(callback.have_result());
 
   // Need to shut down the server before |connection_listener| is destroyed.
   EXPECT_TRUE(test_server_.ShutdownAndWaitUntilComplete());
 }
 
 TEST_F(ProxyScriptFetcherImplTest, OnShutdown) {
   ASSERT_TRUE(test_server_.Start());
@@ skipping 30 matching lines @@
   TestCompletionCallback callback;
   int result = pac_fetcher.Fetch(test_server_.GetURL("/hung"), &text,
                                  callback.callback());
   EXPECT_THAT(result, IsError(ERR_CONTEXT_SHUT_DOWN));
   EXPECT_EQ(0u, context_.url_requests().size());
 }
 
 }  // namespace
 
 }  // namespace net