Revert "Revert of Allow use of Mojo/V8 ProxyResolvers with URLRequestContextBuilder. (patchset #10 …

net/proxy/proxy_service_mojo_unittest.cc

 // Copyright 2015 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_service_mojo.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
-#include "base/memory/singleton.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
 #include "net/base/network_delegate_impl.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_with_source.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "net/proxy/dhcp_proxy_script_fetcher.h"
 #include "net/proxy/mock_proxy_script_fetcher.h"
 #include "net/proxy/mojo_proxy_resolver_factory.h"
-#include "net/proxy/mojo_proxy_resolver_factory_impl.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_service.h"
+#include "net/proxy/test_mojo_proxy_resolver_factory.h"
 #include "net/test/event_waiter.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using net::test::IsOk;
 
 namespace net {
 
@@ skipping 76 matching lines @@
               AddressList* addresses,
               const CompletionCallback& callback,
               std::unique_ptr<Request>* out_req,
               const NetLogWithSource& net_log) override {
     net_log.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_JOB);
     return MockHostResolver::Resolve(info, priority, addresses, callback,
                                      out_req, net_log);
   }
 };
 
-class InProcessMojoProxyResolverFactory : public MojoProxyResolverFactory {
- public:
-  static InProcessMojoProxyResolverFactory* GetInstance() {
-    return base::Singleton<InProcessMojoProxyResolverFactory>::get();
-  }
-
-  // Overridden from MojoProxyResolverFactory:
-  std::unique_ptr<base::ScopedClosureRunner> CreateResolver(
-      const std::string& pac_script,
-      mojo::InterfaceRequest<interfaces::ProxyResolver> req,
-      interfaces::ProxyResolverFactoryRequestClientPtr client) override {
-    factory_->CreateResolver(pac_script, std::move(req), std::move(client));
-    return nullptr;
-  }
-
- private:
-  InProcessMojoProxyResolverFactory() {
-    mojo::MakeStrongBinding(base::MakeUnique<MojoProxyResolverFactoryImpl>(),
-                            mojo::MakeRequest(&factory_));
-  }
-  ~InProcessMojoProxyResolverFactory() override = default;
-  friend struct base::DefaultSingletonTraits<InProcessMojoProxyResolverFactory>;
-
-  interfaces::ProxyResolverFactoryPtr factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(InProcessMojoProxyResolverFactory);
-};
-
 }  // namespace
 
 class ProxyServiceMojoTest : public testing::Test,
                              public MojoProxyResolverFactory {
  protected:
   void SetUp() override {
     mock_host_resolver_.rules()->AddRule("example.com", "1.2.3.4");
 
     fetcher_ = new MockProxyScriptFetcher;
     proxy_service_ = CreateProxyServiceUsingMojoFactory(
         this, base::MakeUnique<ProxyConfigServiceFixed>(
                   ProxyConfig::CreateFromCustomPacURL(GURL(kPacUrl))),
         fetcher_, base::MakeUnique<DoNothingDhcpProxyScriptFetcher>(),
         &mock_host_resolver_, &net_log_, &network_delegate_);
   }
 
   std::unique_ptr<base::ScopedClosureRunner> CreateResolver(
       const std::string& pac_script,
       mojo::InterfaceRequest<interfaces::ProxyResolver> req,
       interfaces::ProxyResolverFactoryRequestClientPtr client) override {
-    InProcessMojoProxyResolverFactory::GetInstance()->CreateResolver(
+    TestMojoProxyResolverFactory::GetInstance()->CreateResolver(
         pac_script, std::move(req), std::move(client));
     return base::MakeUnique<base::ScopedClosureRunner>(
         on_delete_closure_.closure());
   }
 
   TestNetworkDelegate network_delegate_;
   LoggingMockHostResolver mock_host_resolver_;
   MockProxyScriptFetcher* fetcher_;  // Owned by |proxy_service_|.
   TestNetLog net_log_;
   TestClosure on_delete_closure_;
@@ skipping 102 matching lines @@
   EXPECT_THAT(callback.WaitForResult(), IsOk());
   EXPECT_EQ("DIRECT", info.ToPacString());
   EXPECT_EQ(0u, mock_host_resolver_.num_resolve());
 
   TestNetLogEntry::List entries;
   net_log_.GetEntries(&entries);
   CheckCapturedNetLogEntries(entries);
 }
 
 }  // namespace net