Refactor: Extract "InitProxyResolver" to "ProxyScriptDecider".

net/proxy/proxy_service.cc

 // Copyright (c) 2011 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/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_util.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/init_proxy_resolver.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"
@@ skipping 269 matching lines @@
     return dict;
   }
 
  private:
   std::vector<std::string> proxy_list_;
   DISALLOW_COPY_AND_ASSIGN(BadProxyListNetLogParam);
 };
 
 }  // namespace
 
+// ProxyService::InitProxyResolver --------------------------------------------
+
+// This glues together two asynchronous steps:
+//   (1) ProxyScriptDecider -- try to fetch/validate a sequence of PAC scripts to
+//       figure out what we should configure against.
+//   (2) Feed the fetched PAC script into the ProxyResolver.
+//
+// TODO(eroman): This is something of a temporary shim while refactoring to keep
+// things similar. It will probably end up changing while solving bug 90581.
+
+class ProxyService::InitProxyResolver {
+ public:
+  InitProxyResolver(ProxyResolver* proxy_resolver,
+                    ProxyScriptFetcher* proxy_script_fetcher,
+                    DhcpProxyScriptFetcher* dhcp_proxy_script_fetcher,
+                    NetLog* net_log)
+      : decider_(proxy_script_fetcher, dhcp_proxy_script_fetcher, net_log),
+        effective_config_(NULL),
+        proxy_resolver_(proxy_resolver),
+        user_callback_(NULL),
+        ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(
+            this, &InitProxyResolver::OnIOCompletion)) {
+  }
+
+  ~InitProxyResolver() {
+    // Note that the destruction of ProxyScriptDecider will automatically cancel
+    // any outstanding work.
+    if (next_state_ == STATE_SET_PAC_SCRIPT_COMPLETE) {
+      proxy_resolver_->CancelSetPacScript();
+    }
+  }
+
+  int Init(const ProxyConfig& config,
+           base::TimeDelta wait_delay,
+           ProxyConfig* effective_config,
+           OldCompletionCallback* callback) {
+    config_ = config;
+    wait_delay_ = wait_delay;
+    effective_config_ = effective_config;
+    user_callback_ = callback;
+
+    next_state_ = STATE_DECIDE_PROXY_SCRIPT;
+    return DoLoop(OK);
+  }
+
+ private:
+  enum State {
+    STATE_NONE,
+    STATE_DECIDE_PROXY_SCRIPT,
+    STATE_DECIDE_PROXY_SCRIPT_COMPLETE,
+    STATE_SET_PAC_SCRIPT,
+    STATE_SET_PAC_SCRIPT_COMPLETE,
+  };
+
+  int DoLoop(int result) {
+    DCHECK_NE(next_state_, STATE_NONE);
+    int rv = result;
+    do {
+      State state = next_state_;
+      next_state_ = STATE_NONE;
+      switch (state) {
+        case STATE_DECIDE_PROXY_SCRIPT:
+          DCHECK_EQ(OK, rv);
+          rv = DoDecideProxyScript();
+          break;
+        case STATE_DECIDE_PROXY_SCRIPT_COMPLETE:
+          rv = DoDecideProxyScriptComplete(rv);
+          break;
+        case STATE_SET_PAC_SCRIPT:
+          DCHECK_EQ(OK, rv);
+          rv = DoSetPacScript();
+          break;
+        case STATE_SET_PAC_SCRIPT_COMPLETE:
+          rv = DoSetPacScriptComplete(rv);
+          break;
+        default:
+          NOTREACHED() << "bad state: " << state;
+          rv = ERR_UNEXPECTED;
+          break;
+      }
+    } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
+    return rv;
+  }
+
+  int DoDecideProxyScript() {
+    next_state_ = STATE_DECIDE_PROXY_SCRIPT_COMPLETE;
+
+    return decider_.Start(
+        config_, wait_delay_, proxy_resolver_->expects_pac_bytes(),
+        &io_callback_);
+  }
+
+  int DoDecideProxyScriptComplete(int result) {
+    if (result != OK)
+      return result;
+
+    *effective_config_ = decider_.effective_config();
+    next_state_ = STATE_SET_PAC_SCRIPT;
+    return OK;
+  }
+
+  int DoSetPacScript() {
+    DCHECK(decider_.script_data());
+    // TODO(eroman): Should log this latency to the NetLog.
+    next_state_ = STATE_SET_PAC_SCRIPT_COMPLETE;
+    return proxy_resolver_->SetPacScript(decider_.script_data(), &io_callback_);
+  }
+
+  int DoSetPacScriptComplete(int result) {
+    return result;
+  }
+
+  void OnIOCompletion(int result) {
+    DCHECK_NE(STATE_NONE, next_state_);
+    int rv = DoLoop(result);
+    if (rv != ERR_IO_PENDING)
+      DoCallback(rv);
+  }
+
+  void DoCallback(int result) {
+    DCHECK_NE(ERR_IO_PENDING, result);
+    user_callback_->Run(result);
+  }
+
+  ProxyConfig config_;
+  base::TimeDelta wait_delay_;
+  ProxyScriptDecider decider_;
+  ProxyConfig* effective_config_;
+  ProxyResolver* proxy_resolver_;
+  OldCompletionCallback* user_callback_;
+  OldCompletionCallbackImpl<InitProxyResolver> io_callback_;
+  State next_state_;
+
+  DISALLOW_COPY_AND_ASSIGN(InitProxyResolver);
+};
+
 // ProxyService::PacRequest ---------------------------------------------------
 
 class ProxyService::PacRequest
     : public base::RefCounted<ProxyService::PacRequest> {
  public:
   PacRequest(ProxyService* service,
              const GURL& url,
              ProxyInfo* results,
              OldCompletionCallback* user_callback,
              const BoundNetLog& net_log)
@@ skipping 853 matching lines @@
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net