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

net/proxy/proxy_service_unittest.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 <vector>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 523 matching lines @@
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // Fake an error on the proxy.
   TestCompletionCallback callback2;
   rv = service.ReconsiderProxyAfterError(url, &info, &callback2, NULL,
                                          BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   // The second proxy should be specified.
   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
+  // Report back that the second proxy worked.  This will globally mark the
+  // first proxy as bad.
+  service.ReportSuccess(info);
 
   TestCompletionCallback callback3;
   rv = service.ResolveProxy(url, &info, &callback3, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ASSERT_EQ(1u, resolver->pending_requests().size());
   EXPECT_EQ(url, resolver->pending_requests()[0]->url());
 
   // Set the result in proxy resolver -- the second result is already known
   // to be bad, so we will not try to use it initially.
@@ skipping 23 matching lines @@
 
   // Fake another error, the last proxy is gone, the list should now be empty,
   // so there is nothing left to try.
   TestCompletionCallback callback6;
   rv = service.ReconsiderProxyAfterError(url, &info, &callback6, NULL,
                                          BoundNetLog());
   EXPECT_EQ(ERR_FAILED, rv);
   EXPECT_FALSE(info.is_direct());
   EXPECT_TRUE(info.is_empty());
 
+  // Look up proxies again
+  TestCompletionCallback callback7;
+  rv = service.ResolveProxy(url, &info, &callback7, NULL, BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  ASSERT_EQ(1u, resolver->pending_requests().size());
+  EXPECT_EQ(url, resolver->pending_requests()[0]->url());
+
+  // This time, the first 3 results have been found to be bad, but only the
+  // first proxy has been confirmed ...
+  resolver->pending_requests()[0]->results()->UseNamedProxy(
+      "foopy1:8080;foopy3:7070;foopy2:9090;foopy4:9091");
+  resolver->pending_requests()[0]->CompleteNow(OK);
+
+  // ... therefore, we should see the second proxy first.
+  EXPECT_EQ(OK, callback7.WaitForResult());
+  EXPECT_FALSE(info.is_direct());
+  EXPECT_EQ("foopy3:7070", info.proxy_server().ToURI());
+
   // TODO(nsylvain): Test that the proxy can be retried after the delay.
 }
 
 // This test is similar to ProxyFallback, but this time we have an explicit
 // fallback choice to DIRECT.
 TEST(ProxyServiceTest, ProxyFallbackToDirect) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver* resolver = new MockAsyncProxyResolver;
@@ skipping 1273 matching lines @@
   log.GetEntries(&entries);
 
   EXPECT_TRUE(LogContainsEntryWithType(entries, 0,
                                        NetLog::TYPE_PROXY_CONFIG_CHANGED));
   ASSERT_EQ(13u, entries.size());
   for (size_t i = 1; i < entries.size(); ++i)
     EXPECT_NE(NetLog::TYPE_PROXY_CONFIG_CHANGED, entries[i].type);
 }
 
 }  // namespace net