Only mark a proxy as bad if we have confirmation that another proxy succeeded for the same request.

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"
@@ skipping 246 matching lines @@
     dict->Set("new_config", new_config_.ToValue());
     return dict;
   }
 
  private:
   const ProxyConfig old_config_;
   const ProxyConfig new_config_;
   DISALLOW_COPY_AND_ASSIGN(ProxyConfigChangedNetLogParam);
 };
 
+class BadProxyListNetLogParam : public NetLog::EventParameters {
+ public:
+  BadProxyListNetLogParam(const ProxyRetryInfoMap& retry_info) {
+    proxy_list_.reserve(retry_info.size());
+    for (ProxyRetryInfoMap::const_iterator iter = retry_info.begin();
+         iter != retry_info.end(); ++iter) {
+      proxy_list_.push_back(iter->first);
+    }
+  }
+
+  virtual Value* ToValue() const OVERRIDE {
+    DictionaryValue* dict = new DictionaryValue();
+    ListValue* list = new ListValue();
+    for (std::vector<std::string>::const_iterator iter = proxy_list_.begin();
+         iter != proxy_list_.end(); ++iter)
+      list->Append(Value::CreateStringValue(*iter));
+    dict->Set("bad_proxy_list", list);
+    return dict;
+  }
+
+ private:
+  std::vector<std::string> proxy_list_;
+  DISALLOW_COPY_AND_ASSIGN(BadProxyListNetLogParam);
+};
+
 }  // namespace
 
 // ProxyService::PacRequest ---------------------------------------------------
 
 class ProxyService::PacRequest
     : public base::RefCounted<ProxyService::PacRequest> {
  public:
   PacRequest(ProxyService* service,
              const GURL& url,
              ProxyInfo* results,
@@ skipping 431 matching lines @@
 
   if (re_resolve) {
     // If we have a new config or the config was never tried, we delete the
     // list of bad proxies and we try again.
     proxy_retry_info_.clear();
     return ResolveProxy(url, result, callback, pac_request, net_log);
   }
 
   // We don't have new proxy settings to try, try to fallback to the next proxy
   // in the list.
-  bool did_fallback = result->Fallback(&proxy_retry_info_);
+  bool did_fallback = result->Fallback(net_log);
 
   // Return synchronous failure if there is nothing left to fall-back to.
   // TODO(eroman): This is a yucky API, clean it up.
   return did_fallback ? OK : ERR_FAILED;
 }
 
+void ProxyService::ReportSuccess(const ProxyInfo& result) {
+  DCHECK(CalledOnValidThread());
+
+  const ProxyRetryInfoMap& new_retry_info = result.proxy_retry_info();
+  if (new_retry_info.empty())
+    return;
+
+  for (ProxyRetryInfoMap::const_iterator iter = new_retry_info.begin();
+       iter != new_retry_info.end(); ++iter) {
+    ProxyRetryInfoMap::iterator existing = proxy_retry_info_.find(iter->first);
+    if (existing == proxy_retry_info_.end())
+      proxy_retry_info_[iter->first] = iter->second;
+    else if (existing->second.bad_until < iter->second.bad_until)
+      existing->second.bad_until = iter->second.bad_until;
+  }
+  if (net_log_) {
+    net_log_->AddEntry(NetLog::TYPE_BAD_PROXY_LIST_REPORTED,
+                       base::TimeTicks::Now(),
+                       NetLog::Source(),
+                       NetLog::PHASE_NONE,
+                       make_scoped_refptr(
+                           new BadProxyListNetLogParam(new_retry_info)));
+  }
+}
+
 void ProxyService::CancelPacRequest(PacRequest* req) {
   DCHECK(CalledOnValidThread());
   DCHECK(req);
   req->Cancel();
   RemovePendingRequest(req);
 }
 
 bool ProxyService::ContainsPendingRequest(PacRequest* req) {
   PendingRequests::iterator it = std::find(
       pending_requests_.begin(), pending_requests_.end(), req);
@@ skipping 286 matching lines @@
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net