Allow ProxyService to share URLRequestContext with everything else.

net/proxy/proxy_script_decider.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_decider.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 74 matching lines @@
     DhcpProxyScriptFetcher* dhcp_proxy_script_fetcher,
     NetLog* net_log)
     : proxy_script_fetcher_(proxy_script_fetcher),
       dhcp_proxy_script_fetcher_(dhcp_proxy_script_fetcher),
       current_pac_source_index_(0u),
       pac_mandatory_(false),
       next_state_(STATE_NONE),
       net_log_(NetLogWithSource::Make(net_log,
                                       NetLogSourceType::PROXY_SCRIPT_DECIDER)),
       fetch_pac_bytes_(false),
-      quick_check_enabled_(true),
-      host_resolver_(nullptr) {
-  if (proxy_script_fetcher &&
-      proxy_script_fetcher->GetRequestContext() &&
-      proxy_script_fetcher->GetRequestContext()->host_resolver()) {
-    host_resolver_ = proxy_script_fetcher->GetRequestContext()->host_resolver();
-  }
-}
+      quick_check_enabled_(true) {}
 
 ProxyScriptDecider::~ProxyScriptDecider() {
   if (next_state_ != STATE_NONE)
     Cancel();
 }
 
 int ProxyScriptDecider::Start(
     const ProxyConfig& config, const base::TimeDelta wait_delay,
     bool fetch_pac_bytes, const CompletionCallback& callback) {
   DCHECK_EQ(STATE_NONE, next_state_);
@@ skipping 19 matching lines @@
 
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
   else
     DidComplete();
 
   return rv;
 }
 
+void ProxyScriptDecider::OnShutdown() {
+  // Don't do anything if idle.
+  if (next_state_ == STATE_NONE)
+    return;
+
+  CompletionCallback callback = std::move(callback_);
+
+  // Just cancel any pending work.
+  Cancel();
+
+  if (callback)
+    callback.Run(ERR_CONTEXT_SHUT_DOWN);
+}
+
 const ProxyConfig& ProxyScriptDecider::effective_config() const {
   DCHECK_EQ(STATE_NONE, next_state_);
   return effective_config_;
 }
 
 const scoped_refptr<ProxyResolverScriptData>&
 ProxyScriptDecider::script_data() const {
   DCHECK_EQ(STATE_NONE, next_state_);
   return script_data_;
 }
@@ skipping 96 matching lines @@
   }
   if (quick_check_enabled_ && current_pac_source().type == PacSource::WPAD_DNS)
     next_state_ = STATE_QUICK_CHECK;
   else
     next_state_ = GetStartState();
   return OK;
 }
 
 int ProxyScriptDecider::DoQuickCheck() {
   DCHECK(quick_check_enabled_);
-  if (host_resolver_ == nullptr) {
+  if (!proxy_script_fetcher_ || !proxy_script_fetcher_->GetRequestContext() ||
+      !proxy_script_fetcher_->GetRequestContext()->host_resolver()) {
     // If we have no resolver, skip QuickCheck altogether.
     next_state_ = GetStartState();
     return OK;
   }
 
   quick_check_start_time_ = base::Time::Now();
   std::string host = current_pac_source().url.host();
   HostResolver::RequestInfo reqinfo(HostPortPair(host, 80));
   reqinfo.set_host_resolver_flags(HOST_RESOLVER_SYSTEM_ONLY);
   CompletionCallback callback = base::Bind(
       &ProxyScriptDecider::OnIOCompletion,
       base::Unretained(this));
 
   next_state_ = STATE_QUICK_CHECK_COMPLETE;
   quick_check_timer_.Start(FROM_HERE,
                            base::TimeDelta::FromMilliseconds(
                               kQuickCheckDelayMs),
                            base::Bind(callback, ERR_NAME_NOT_RESOLVED));
 
+  HostResolver* host_resolver =
+      proxy_script_fetcher_->GetRequestContext()->host_resolver();
+
   // We use HIGHEST here because proxy decision blocks doing any other requests.
-  return host_resolver_->Resolve(reqinfo, HIGHEST, &wpad_addresses_, callback,
-                                 &request_, net_log_);
+  return host_resolver->Resolve(reqinfo, HIGHEST, &wpad_addresses_, callback,
+                                &request_, net_log_);
 }
 
 int ProxyScriptDecider::DoQuickCheckComplete(int result) {
   DCHECK(quick_check_enabled_);
   base::TimeDelta delta = base::Time::Now() - quick_check_start_time_;
   if (result == OK)
     UMA_HISTOGRAM_TIMES("Net.WpadQuickCheckSuccess", delta);
   else
     UMA_HISTOGRAM_TIMES("Net.WpadQuickCheckFailure", delta);
   request_.reset();
@@ skipping 167 matching lines @@
 void ProxyScriptDecider::DidComplete() {
   net_log_.EndEvent(NetLogEventType::PROXY_SCRIPT_DECIDER);
 }
 
 void ProxyScriptDecider::Cancel() {
   DCHECK_NE(STATE_NONE, next_state_);
 
   net_log_.AddEvent(NetLogEventType::CANCELLED);
 
   switch (next_state_) {
+    case STATE_QUICK_CHECK_COMPLETE:
+      request_.reset();
+      break;
     case STATE_WAIT_COMPLETE:
       wait_timer_.Stop();
       break;
     case STATE_FETCH_PAC_SCRIPT_COMPLETE:
       proxy_script_fetcher_->Cancel();
       break;
     default:
       break;
   }
 
+  next_state_ = STATE_NONE;
+
   // This is safe to call in any state.
   if (dhcp_proxy_script_fetcher_)
     dhcp_proxy_script_fetcher_->Cancel();
 
+  DCHECK(!request_);
+
   DidComplete();
 }
 
 }  // namespace net