Allow chrome to handle 407 auth challenges to CONNECT requests

net/http/http_proxy_client_socket_pool_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_proxy_client_socket_pool.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 113 matching lines @@
     return scoped_refptr<HttpProxySocketParams>(
         new HttpProxySocketParams(
             GetTcpParams(),
             GetSslParams(),
             GURL(tunnel ? "https://www.google.com/" : "http://www.google.com"),
             "",
             HostPortPair("www.google.com", tunnel ? 443 : 80),
             session_->http_auth_cache(),
             session_->http_auth_handler_factory(),
             session_->spdy_session_pool(),
-            tunnel));
+            tunnel,
+            base::Bind(&HttpProxyClientSocketPoolTest::OnNeedsProxyAuthCallback,
+                       base::Unretained(this))));
   }
 
   scoped_refptr<HttpProxySocketParams> GetTunnelParams() {
     return GetParams(true);
   }
 
   scoped_refptr<HttpProxySocketParams> GetNoTunnelParams() {
     return GetParams(false);
   }
 
@@ skipping 39 matching lines @@
     params.host_resolver = &host_resolver_;
     params.cert_verifier = &cert_verifier_;
     params.proxy_service = proxy_service_.get();
     params.client_socket_factory = &socket_factory_;
     params.ssl_config_service = ssl_config_service_;
     params.http_auth_handler_factory = http_auth_handler_factory_.get();
     params.http_server_properties = &http_server_properties_;
     return new HttpNetworkSession(params);
   }
 
+  void OnNeedsProxyAuthCallback(const HttpResponseInfo& response_info,
+                                HttpAuthController* auth_controller,
+                                CompletionCallback cb) {
+    // Don't add any auth, just run the callback

[vandebo (ex-Chrome), 2012/01/20 20:49:29]

Do you expect this to ever be run?  If not, a NOT_REACHED would be more
appropriate. 

[Ryan Hamilton, 2012/01/20 21:51:35]

Yes, it is actually used in the NeedAuth test.

+    cb.Run(OK);
+  }
+
+
  private:
   SSLConfig ssl_config_;
 
   scoped_refptr<TransportSocketParams> ignored_transport_socket_params_;
   scoped_refptr<SSLSocketParams> ignored_ssl_socket_params_;
   ClientSocketPoolHistograms tcp_histograms_;
   DeterministicMockClientSocketFactory socket_factory_;
   MockTransportClientSocketPool transport_socket_pool_;
   ClientSocketPoolHistograms ssl_histograms_;
   MockHostResolver host_resolver_;
@@ skipping 47 matching lines @@
     MockRead(true, 2, "Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead(true, 3, "Content-Length: 10\r\n\r\n"),
     MockRead(true, 4, "0123456789"),
   };
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyConnect(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> rst(ConstructSpdyRstStream(1, spdy::CANCEL));
   MockWrite spdy_writes[] = {
     CreateMockWrite(*req, 0, true),
     CreateMockWrite(*rst, 2, true),
   };
+  static const char* const kAuthChallenge[] = {
+    "status", "407 Proxy Authentication Required",
+    "version", "HTTP/1.1",
+    "proxy-authenticate", "Basic realm=\"MyRealm1\"",
+  };
   scoped_ptr<spdy::SpdyFrame> resp(
-      ConstructSpdySynReplyError(
-          "407 Proxy Authentication Required", NULL, 0, 1));
+    ConstructSpdyControlFrame(NULL,
+                              0,
+                              false,
+                              1,
+                              LOWEST,
+                              spdy::SYN_REPLY,
+                              spdy::CONTROL_FLAG_NONE,
+                              kAuthChallenge,
+                              arraysize(kAuthChallenge)));
   MockRead spdy_reads[] = {
     CreateMockWrite(*resp, 1, true),
     MockRead(true, 0, 3)
   };
 
   Initialize(false, reads, arraysize(reads), writes, arraysize(writes),
              spdy_reads, arraysize(spdy_reads), spdy_writes,
              arraysize(spdy_writes));
 
   data_->StopAfter(4);
   int rv = handle_.Init("a", GetTunnelParams(), LOW, callback_.callback(),
                         &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
-  data_->RunFor(4);
+  data_->RunFor(GetParam() == SPDY ? 2 : 4);
   rv = callback_.WaitForResult();
+  EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, rv);
+  EXPECT_TRUE(handle_.is_initialized());
+  ASSERT_TRUE(handle_.socket());
   if (GetParam() != SPDY) {
-    EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, rv);
-    EXPECT_TRUE(handle_.is_initialized());
-    ASSERT_TRUE(handle_.socket());
     HttpProxyClientSocket* tunnel_socket =
             static_cast<HttpProxyClientSocket*>(handle_.socket());
     EXPECT_FALSE(tunnel_socket->IsConnected());
     EXPECT_FALSE(tunnel_socket->using_spdy());
-  } else {
-    // Proxy auth is not really implemented for SPDY yet
-    EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
-    EXPECT_FALSE(handle_.is_initialized());
-    EXPECT_FALSE(handle_.socket());
   }
 }
 
 TEST_P(HttpProxyClientSocketPoolTest, HaveAuth) {
   // It's pretty much impossible to make the SPDY case behave synchronously
   // so we skip this test for SPDY
   if (GetParam() == SPDY)
     return;
   MockWrite writes[] = {
     MockWrite(false, 0,
@@ skipping 216 matching lines @@
     // HTTPS or SPDY Proxy CONNECT responses are trustworthy
     EXPECT_EQ(ERR_HTTPS_PROXY_TUNNEL_RESPONSE, rv);
     EXPECT_TRUE(handle_.is_initialized());
     EXPECT_TRUE(handle_.socket());
   }
 }
 
 // It would be nice to also test the timeouts in HttpProxyClientSocketPool.
 
 }  // namespace net