Fast-fail WPAD detection.

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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
+#include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/dhcp_proxy_script_fetcher.h"
 #include "net/proxy/dhcp_proxy_script_fetcher_factory.h"
 #include "net/proxy/proxy_script_fetcher.h"
 
 namespace net {
 
@@ skipping 52 matching lines @@
     DhcpProxyScriptFetcher* dhcp_proxy_script_fetcher,
     NetLog* net_log)
     : resolver_(NULL),
       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_(BoundNetLog::Make(
           net_log, NetLog::SOURCE_PROXY_SCRIPT_DECIDER)),
-      fetch_pac_bytes_(false) {
+      fetch_pac_bytes_(false),
+      host_resolver_(HostResolver::CreateDefaultResolver(net_log)),
+      quick_check_delay_(base::TimeDelta::FromMilliseconds(1000)) {
 }
 
 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_);
   DCHECK(!callback.is_null());
   DCHECK(config.HasAutomaticSettings());
 
   net_log_.BeginEvent(NetLog::TYPE_PROXY_SCRIPT_DECIDER);
 
   fetch_pac_bytes_ = fetch_pac_bytes;
 
   // Save the |wait_delay| as a non-negative value.
   wait_delay_ = wait_delay;
   if (wait_delay_ < base::TimeDelta())
     wait_delay_ = base::TimeDelta();
 
   pac_mandatory_ = config.pac_mandatory();
 
   pac_sources_ = BuildPacSourcesFallbackList(config);
   DCHECK(!pac_sources_.empty());
 
-  next_state_ = STATE_WAIT;
+  next_state_ = STATE_QUICK_CHECK;
 
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
   else
     DidComplete();
 
   return rv;
 }
 
@@ skipping 34 matching lines @@
   }
 }
 
 int ProxyScriptDecider::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_QUICK_CHECK:
+        rv = DoQuickCheck();
+        break;
       case STATE_WAIT:
         DCHECK_EQ(OK, rv);
         rv = DoWait();
         break;
       case STATE_WAIT_COMPLETE:
         rv = DoWaitComplete(rv);
         break;
       case STATE_FETCH_PAC_SCRIPT:
         DCHECK_EQ(OK, rv);
         rv = DoFetchPacScript();
         break;
       case STATE_FETCH_PAC_SCRIPT_COMPLETE:
         rv = DoFetchPacScriptComplete(rv);
         break;
       case STATE_VERIFY_PAC_SCRIPT:
         DCHECK_EQ(OK, rv);
         rv = DoVerifyPacScript();
         break;
       case STATE_VERIFY_PAC_SCRIPT_COMPLETE:
         rv = DoVerifyPacScriptComplete(rv);
         break;
+      case STATE_FAILED:
+        break;
       default:
         NOTREACHED() << "bad state";
         rv = ERR_UNEXPECTED;
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
   return rv;
 }
 
 void ProxyScriptDecider::DoCallback(int result) {
   DCHECK_NE(ERR_IO_PENDING, result);
   DCHECK(!callback_.is_null());
   callback_.Run(result);
 }
 
+int ProxyScriptDecider::DoQuickCheck() {
+
+  HostResolver::RequestInfo reqinfo(HostPortPair("wpad", 80));
+
+  quick_check_started_ = base::Time::Now();
+  int rv = host_resolver_->Resolve(reqinfo, HIGHEST,  // we block startup...
+                                   &wpad_addrs_,
+                                   base::Bind(
+                                      &ProxyScriptDecider::OnQuickCheckComplete,
+                                      base::Unretained(this)),
+                                   &wpad_req_,
+                                   net_log_);
+
+  if (rv == OK) {
+    // already in cache or something and valid, we're golden
+    next_state_ = STATE_WAIT;
+    return OK;
+  } else if (rv != ERR_IO_PENDING) {
+    // already in cache and invalid, bail now

[szym, 2013/08/21 19:11:21]

We don't actually cache negative results in HostResolverImpl. A synchronous
failure can only happen due to incorrect request (not a well-formed domain name
or IP address) or HostResolverImpl's internal request queue overflowing. So, I'd
probably CHECK here.

+    next_state_ = STATE_FAILED;
+    return rv;
+  }
+
+  quick_check_timer_.Start(FROM_HERE, quick_check_delay_, this,
+                           &ProxyScriptDecider::OnQuickCheckTimerFired);
+
+  next_state_ = STATE_QUICK_CHECK;
+  return ERR_IO_PENDING;
+}
+
+void ProxyScriptDecider::OnQuickCheckTimerFired() {
+  host_resolver_->CancelRequest(wpad_req_);
+  next_state_ = STATE_FAILED;

[szym, 2013/08/21 19:11:21]

You'll probably want to UMA this as well. Putting it in the same histogram would
work. This way you'd be able to completely replace OnQuickCheckTimerFired with
OnQuickCheckComplete(ERR_NAME_NOT_RESOLVED).

+  OnIOCompletion(ERR_NAME_NOT_RESOLVED);
+}
+
+void ProxyScriptDecider::OnQuickCheckComplete(int result) {
+  base::Time quick_check_ended = base::Time::Now();
+  base::TimeDelta delta = quick_check_ended - quick_check_started_;
+  UMA_HISTOGRAM_TIMES("Net.WpadQuickCheck", delta);
+  quick_check_timer_.Stop();
+  if (result == OK)
+    next_state_ = STATE_WAIT;
+  else
+    next_state_ = STATE_FAILED;
+  OnIOCompletion(result);
+}
+
 int ProxyScriptDecider::DoWait() {
   next_state_ = STATE_WAIT_COMPLETE;
 
   // If no waiting is required, continue on to the next state.
   if (wait_delay_.ToInternalValue() == 0)
     return OK;
 
   // Otherwise wait the specified amount of time.
   wait_timer_.Start(FROM_HERE, wait_delay_, this,
                     &ProxyScriptDecider::OnWaitTimerFired);
@@ skipping 191 matching lines @@
   }
 
   // This is safe to call in any state.
   if (dhcp_proxy_script_fetcher_)
     dhcp_proxy_script_fetcher_->Cancel();
 
   DidComplete();
 }
 
 }  // namespace net