Allow chrome to handle 407 auth challenges to CONNECT requests

jingle/notifier/base/proxy_resolving_client_socket.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 "jingle/notifier/base/proxy_resolving_client_socket.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_network_session.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_manager.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace notifier {
 
+namespace {
+
+void HandleProxyTunnelAuth(const net::HttpResponseInfo& response_info,
+                           net::HttpAuthController* auth_controller,
+                           net::CompletionCallback callback) {
+  // Since we have no way to respond, simply invoke the callback and the
+  // request will fail.
+  callback.Run(net::OK);
+}
+
+}  // namespace
+
 ProxyResolvingClientSocket::ProxyResolvingClientSocket(
     net::ClientSocketFactory* socket_factory,
     const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
     const net::SSLConfig& ssl_config,
     const net::HostPortPair& dest_host_port_pair)
         : ALLOW_THIS_IN_INITIALIZER_LIST(proxy_resolve_callback_(
               base::Bind(&ProxyResolvingClientSocket::ProcessProxyResolveDone,
                          base::Unretained(this)))),
           ALLOW_THIS_IN_INITIALIZER_LIST(connect_callback_(
               base::Bind(&ProxyResolvingClientSocket::ProcessConnectDone,
@@ skipping 132 matching lines @@
       CloseTransportSocket();
       RunUserConnectCallback(status);
       return;
     }
   }
 
   transport_.reset(new net::ClientSocketHandle);
   // Now that we have resolved the proxy, we need to connect.
   status = net::InitSocketHandleForRawConnect(
       dest_host_port_pair_, network_session_.get(), proxy_info_, ssl_config_,
-      ssl_config_, bound_net_log_, transport_.get(), connect_callback_);
+      ssl_config_, bound_net_log_, transport_.get(),
+      base::Bind(&HandleProxyTunnelAuth), connect_callback_);
+
   if (status != net::ERR_IO_PENDING) {
     // Since this method is always called asynchronously. it is OK to call
     // ProcessConnectDone synchronously.
     ProcessConnectDone(status);
   }
 }
 
 void ProxyResolvingClientSocket::ProcessConnectDone(int status) {
   if (status != net::OK) {
     // If the connection fails, try another proxy.
@@ skipping 180 matching lines @@
   return base::TimeDelta::FromMicroseconds(-1);
 }
 
 void ProxyResolvingClientSocket::CloseTransportSocket() {
   if (transport_.get() && transport_->socket())
     transport_->socket()->Disconnect();
   transport_.reset();
 }
 
 }  // namespace notifier