net: Add a new target 'net_with_v8'.

net/proxy/proxy_service.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_service.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/proxy/dhcp_proxy_script_fetcher.h"
 #include "net/proxy/multi_threaded_proxy_resolver.h"
 #include "net/proxy/network_delegate_error_observer.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_resolver.h"
 #include "net/proxy/proxy_resolver_js_bindings.h"
-#include "net/proxy/proxy_resolver_v8.h"
 #include "net/proxy/proxy_script_decider.h"
 #include "net/proxy/proxy_script_fetcher.h"
 #include "net/proxy/sync_host_resolver_bridge.h"
 #include "net/url_request/url_request_context.h"
 
 #if defined(OS_WIN)
 #include "net/proxy/proxy_config_service_win.h"
 #include "net/proxy/proxy_resolver_winhttp.h"
 #elif defined(OS_MACOSX)
 #include "net/proxy/proxy_config_service_mac.h"
 #include "net/proxy/proxy_resolver_mac.h"
 #elif defined(OS_LINUX) && !defined(OS_CHROMEOS)
 #include "net/proxy/proxy_config_service_linux.h"
 #elif defined(OS_ANDROID)
 #include "net/proxy/proxy_config_service_android.h"
 #endif
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace net {
 
+const size_t kDefaultNumPacThreads = 4;
+
 namespace {
 
 const size_t kMaxNumNetLogEntries = 100;
-const size_t kDefaultNumPacThreads = 4;
 
 // When the IP address changes we don't immediately re-run proxy auto-config.
 // Instead, we  wait for |kDelayAfterNetworkChangesMs| before
 // attempting to re-valuate proxy auto-config.
 //
 // During this time window, any resolve requests sent to the ProxyService will
 // be queued. Once we have waited the required amount of them, the proxy
 // auto-config step will be run, and the queued requests resumed.
 //
 // The reason we play this game is that our signal for detecting network
@@ skipping 184 matching lines @@
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& pac_script,
       const CompletionCallback& callback) OVERRIDE {
     return OK;
   }
 
  private:
   const std::string pac_string_;
 };
 
-// This factory creates V8ProxyResolvers with appropriate javascript bindings.
-class ProxyResolverFactoryForV8 : public ProxyResolverFactory {
- public:
-  // |async_host_resolver|, |io_loop| and |net_log| must remain
-  // valid for the duration of our lifetime.
-  // |async_host_resolver| will only be operated on |io_loop|.
-  // TODO(willchan): remove io_loop and replace it with origin_loop.
-  ProxyResolverFactoryForV8(HostResolver* async_host_resolver,
-                            MessageLoop* io_loop,
-                            base::MessageLoopProxy* origin_loop,
-                            NetLog* net_log,
-                            NetworkDelegate* network_delegate)
-      : ProxyResolverFactory(true /*expects_pac_bytes*/),
-        async_host_resolver_(async_host_resolver),
-        io_loop_(io_loop),
-        origin_loop_(origin_loop),
-        net_log_(net_log),
-        network_delegate_(network_delegate) {
-  }
-
-  virtual ProxyResolver* CreateProxyResolver() OVERRIDE {
-    // Create a synchronous host resolver wrapper that operates
-    // |async_host_resolver_| on |io_loop_|.
-    SyncHostResolverBridge* sync_host_resolver =
-        new SyncHostResolverBridge(async_host_resolver_, io_loop_);
-
-    NetworkDelegateErrorObserver* error_observer =
-        new NetworkDelegateErrorObserver(
-            network_delegate_, origin_loop_.get());
-
-    // ProxyResolverJSBindings takes ownership of |error_observer| and
-    // |sync_host_resolver|.
-    ProxyResolverJSBindings* js_bindings =
-        ProxyResolverJSBindings::CreateDefault(
-            sync_host_resolver, net_log_, error_observer);
-
-    // ProxyResolverV8 takes ownership of |js_bindings|.
-    return new ProxyResolverV8(js_bindings);
-  }
-
- private:
-  HostResolver* const async_host_resolver_;
-  MessageLoop* io_loop_;
-  scoped_refptr<base::MessageLoopProxy> origin_loop_;
-  NetLog* net_log_;
-  NetworkDelegate* network_delegate_;
-};
-
 // Creates ProxyResolvers using a platform-specific implementation.
 class ProxyResolverFactoryForSystem : public ProxyResolverFactory {
  public:
   ProxyResolverFactoryForSystem()
       : ProxyResolverFactory(false /*expects_pac_bytes*/) {}
 
   virtual ProxyResolver* CreateProxyResolver() OVERRIDE {
     DCHECK(IsSupported());
 #if defined(OS_WIN)
     return new ProxyResolverWinHttp();
@@ skipping 593 matching lines @@
       next_config_id_(1),
       current_state_(STATE_NONE) ,
       net_log_(net_log),
       stall_proxy_auto_config_delay_(TimeDelta::FromMilliseconds(
           kDelayAfterNetworkChangesMs)) {
   NetworkChangeNotifier::AddIPAddressObserver(this);
   ResetConfigService(config_service);
 }
 
 // static
-ProxyService* ProxyService::CreateUsingV8ProxyResolver(
-    ProxyConfigService* proxy_config_service,
-    size_t num_pac_threads,
-    ProxyScriptFetcher* proxy_script_fetcher,
-    DhcpProxyScriptFetcher* dhcp_proxy_script_fetcher,
-    HostResolver* host_resolver,
-    NetLog* net_log,
-    NetworkDelegate* network_delegate) {
-  DCHECK(proxy_config_service);
-  DCHECK(proxy_script_fetcher);
-  DCHECK(dhcp_proxy_script_fetcher);
-  DCHECK(host_resolver);
-
-  if (num_pac_threads == 0)
-    num_pac_threads = kDefaultNumPacThreads;
-
-  ProxyResolverFactory* sync_resolver_factory =
-      new ProxyResolverFactoryForV8(
-          host_resolver,
-          MessageLoop::current(),
-          base::MessageLoopProxy::current(),
-          net_log,
-          network_delegate);
-
-  ProxyResolver* proxy_resolver =
-      new MultiThreadedProxyResolver(sync_resolver_factory, num_pac_threads);
-
-  ProxyService* proxy_service =
-      new ProxyService(proxy_config_service, proxy_resolver, net_log);
-
-  // Configure fetchers to use for PAC script downloads and auto-detect.
-  proxy_service->SetProxyScriptFetchers(proxy_script_fetcher,
-                                        dhcp_proxy_script_fetcher);
-
-  return proxy_service;
-}
-
-// static
 ProxyService* ProxyService::CreateUsingSystemProxyResolver(
     ProxyConfigService* proxy_config_service,
     size_t num_pac_threads,
     NetLog* net_log) {
   DCHECK(proxy_config_service);
 
   if (!ProxyResolverFactoryForSystem::IsSupported()) {
     LOG(WARNING) << "PAC support disabled because there is no "
                     "system implementation";
     return CreateWithoutProxyResolver(proxy_config_service, net_log);
@@ skipping 660 matching lines @@
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net