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

net/http/http_stream_factory_impl_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/http/http_stream_factory_impl.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_log.h"
 #include "net/base/ssl_config_service_defaults.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_session_peer.h"
 #include "net/http/http_request_info.h"
+#include "net/http/http_stream.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
@@ skipping 19 matching lines @@
   virtual void OnPreconnectsCompleteInternal() {
     preconnect_done_ = true;
     if (waiting_for_preconnect_)
       MessageLoop::current()->Quit();
   }
 
   bool preconnect_done_;
   bool waiting_for_preconnect_;
 };
 
+class StreamRequestWaiter : public HttpStreamRequest::Delegate {
+ public:
+  StreamRequestWaiter()
+      : waiting_for_stream_(false),
+        stream_done_(false) {}
+
+  // HttpStreamRequest::Delegate
+
+  virtual void OnStreamReady(
+      const SSLConfig& used_ssl_config,
+      const ProxyInfo& used_proxy_info,
+      HttpStream* stream) OVERRIDE {
+    stream_done_ = true;
+    if (waiting_for_stream_)
+      MessageLoop::current()->Quit();
+    stream_.reset(stream);
+  }
+
+  virtual void OnStreamFailed(
+      int status,
+      const SSLConfig& used_ssl_config) OVERRIDE {}
+
+  virtual void OnCertificateError(
+      int status,
+      const SSLConfig& used_ssl_config,
+      const SSLInfo& ssl_info) OVERRIDE {}
+
+  virtual void OnNeedsProxyAuth(const HttpResponseInfo& proxy_response,
+                                const SSLConfig& used_ssl_config,
+                                const ProxyInfo& used_proxy_info,
+                                HttpAuthController* auth_controller) OVERRIDE {}
+
+  virtual void OnNeedsClientAuth(const SSLConfig& used_ssl_config,
+                                 SSLCertRequestInfo* cert_info) OVERRIDE {}
+
+  virtual void OnHttpsProxyTunnelResponse(const HttpResponseInfo& response_info,
+                                          const SSLConfig& used_ssl_config,
+                                          const ProxyInfo& used_proxy_info,
+                                          HttpStream* stream) OVERRIDE {}
+
+  void WaitForStream() {
+    while (!stream_done_) {
+      waiting_for_stream_ = true;
+      MessageLoop::current()->Run();
+      waiting_for_stream_ = false;
+    }
+  }
+
+ private:
+  bool waiting_for_stream_;
+  bool stream_done_;
+  scoped_ptr<HttpStream> stream_;
+
+  DISALLOW_COPY_AND_ASSIGN(StreamRequestWaiter);
+};
+
 struct SessionDependencies {
   // Custom proxy service dependency.
   explicit SessionDependencies(ProxyService* proxy_service)
       : host_resolver(new MockHostResolver),
         cert_verifier(new CertVerifier),
         proxy_service(proxy_service),
         ssl_config_service(new SSLConfigServiceDefaults),
         http_auth_handler_factory(
             HttpAuthHandlerFactory::CreateDefault(host_resolver.get())),
         net_log(NULL) {}
@@ skipping 240 matching lines @@
     PreconnectHelper(kTests[i], session);
     // We shouldn't be preconnecting if we have an existing session, which is
     // the case for https://www.google.com.
     if (kTests[i].ssl)
       EXPECT_EQ(-1, ssl_conn_pool->last_num_streams());
     else
       EXPECT_EQ(kTests[i].num_streams, transport_conn_pool->last_num_streams());
   }
 }
 
+TEST(HttpStreamFactoryTest, JobNotifiesProxy) {
+  const char* kProxyString = "PROXY bad:99; PROXY maybe:80; DIRECT";
+  SessionDependencies session_deps(
+      ProxyService::CreateFixedFromPacResult(kProxyString));
+
+  // First connection attempt fails
+  StaticSocketDataProvider socket_data1;
+  socket_data1.set_connect_data(MockConnect(true, ERR_ADDRESS_UNREACHABLE));
+  session_deps.socket_factory.AddSocketDataProvider(&socket_data1);
+
+  // Second connection attempt succeeds
+  StaticSocketDataProvider socket_data2;
+  socket_data2.set_connect_data(MockConnect(true, OK));
+  session_deps.socket_factory.AddSocketDataProvider(&socket_data2);
+
+  CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
+  EXPECT_TRUE(log.bound().IsLoggingAllEvents());
+
+  scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
+
+  // Now request a stream.  It should succeed using the second proxy in the
+  // list.
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("http://www.google.com");
+  request_info.load_flags = 0;
+
+  SSLConfig ssl_config;
+  StreamRequestWaiter waiter;
+  scoped_ptr<HttpStreamRequest> request(
+      session->http_stream_factory()->RequestStream(request_info, ssl_config,
+                                                    &waiter, log.bound()));
+  waiter.WaitForStream();
+
+  // The proxy that failed should now be known to the proxy_service as bad.
+  const ProxyRetryInfoMap& retry_info =
+      session->proxy_service()->proxy_retry_info();
+  EXPECT_EQ(1u, retry_info.size());
+  ProxyRetryInfoMap::const_iterator iter = retry_info.find("bad:99");
+  EXPECT_TRUE(iter != retry_info.end());
+}
+
 }  // namespace
 
 }  // namespace net