Leverage profile's http network session's HttpAuthCache to support proxy auth.

google_apis/gcm/engine/connection_factory_impl.cc

 // Copyright (c) 2013 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 "google_apis/gcm/engine/connection_factory_impl.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "google_apis/gcm/engine/connection_handler_impl.h"
@@ skipping 27 matching lines @@
   return !login_time.is_null() &&
       now_ticks - login_time <=
           base::TimeDelta::FromSeconds(kConnectionResetWindowSecs);
 }
 
 }  // namespace
 
 ConnectionFactoryImpl::ConnectionFactoryImpl(
     const std::vector<GURL>& mcs_endpoints,
     const net::BackoffEntry::Policy& backoff_policy,
-    scoped_refptr<net::HttpNetworkSession> network_session,
+    const scoped_refptr<net::HttpNetworkSession>& gcm_network_session,
+    const scoped_refptr<net::HttpNetworkSession>& http_network_session,
     net::NetLog* net_log,
     GCMStatsRecorder* recorder)
   : mcs_endpoints_(mcs_endpoints),
     next_endpoint_(0),
     last_successful_endpoint_(0),
     backoff_policy_(backoff_policy),
-    network_session_(network_session),
+    gcm_network_session_(gcm_network_session),
+    http_network_session_(http_network_session),
     bound_net_log_(
         net::BoundNetLog::Make(net_log, net::NetLog::SOURCE_SOCKET)),
     pac_request_(NULL),
     connecting_(false),
     waiting_for_backoff_(false),
     waiting_for_network_online_(false),
     logging_in_(false),
     recorder_(recorder),
     listener_(NULL),
     weak_ptr_factory_(this) {
   DCHECK_GE(mcs_endpoints_.size(), 1U);
+  DCHECK(!http_network_session_.get() ||
+         (gcm_network_session_.get() != http_network_session_.get()));
 }
 
 ConnectionFactoryImpl::~ConnectionFactoryImpl() {
   CloseSocket();
   net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
   if (pac_request_) {
-    network_session_->proxy_service()->CancelPacRequest(pac_request_);
+    gcm_network_session_->proxy_service()->CancelPacRequest(pac_request_);
     pac_request_ = NULL;
   }
 }
 
 void ConnectionFactoryImpl::Initialize(
     const BuildLoginRequestCallback& request_builder,
     const ConnectionHandler::ProtoReceivedCallback& read_callback,
     const ConnectionHandler::ProtoSentCallback& write_callback) {
   DCHECK(!connection_handler_);
 
@@ skipping 189 matching lines @@
 void ConnectionFactoryImpl::ConnectImpl() {
   DCHECK(!IsEndpointReachable());
   DCHECK(!socket_handle_.socket());
 
   if (waiting_for_network_online_)
     return;
 
   connecting_ = true;
   GURL current_endpoint = GetCurrentEndpoint();
   recorder_->RecordConnectionInitiated(current_endpoint.host());
-  int status = network_session_->proxy_service()->ResolveProxy(
+  RebuildNetworkSessionAuthCache();
+  int status = gcm_network_session_->proxy_service()->ResolveProxy(
       current_endpoint,
       net::LOAD_NORMAL,
       &proxy_info_,
       base::Bind(&ConnectionFactoryImpl::OnProxyResolveDone,
                  weak_ptr_factory_.GetWeakPtr()),
       &pac_request_,
       NULL,
       bound_net_log_);
   if (status != net::ERR_IO_PENDING)
     OnProxyResolveDone(status);
@@ skipping 124 matching lines @@
 
   if (status != net::OK) {
     // Failed to resolve proxy. Retry later.
     OnConnectDone(status);
     return;
   }
 
   DVLOG(1) << "Resolved proxy with PAC:" << proxy_info_.ToPacString();
 
   net::SSLConfig ssl_config;
-  network_session_->ssl_config_service()->GetSSLConfig(&ssl_config);
+  gcm_network_session_->ssl_config_service()->GetSSLConfig(&ssl_config);
   status = net::InitSocketHandleForTlsConnect(
       net::HostPortPair::FromURL(GetCurrentEndpoint()),
-      network_session_.get(),
+      gcm_network_session_.get(),
       proxy_info_,
       ssl_config,
       ssl_config,
       net::PRIVACY_MODE_DISABLED,
       bound_net_log_,
       &socket_handle_,
       base::Bind(&ConnectionFactoryImpl::OnConnectDone,
                  weak_ptr_factory_.GetWeakPtr()));
   if (status != net::ERR_IO_PENDING)
     OnConnectDone(status);
@@ skipping 45 matching lines @@
       // Note that if the host resolving was done by the SOCKS5 proxy, we can't
       // differentiate between a proxy-side "host not found" versus a proxy-side
       // "address unreachable" error, and will report both of these failures as
       // ERR_ADDRESS_UNREACHABLE.
       return net::ERR_ADDRESS_UNREACHABLE;
     default:
       return error;
   }
 
   net::SSLConfig ssl_config;
-  network_session_->ssl_config_service()->GetSSLConfig(&ssl_config);
+  gcm_network_session_->ssl_config_service()->GetSSLConfig(&ssl_config);
   if (proxy_info_.is_https() && ssl_config.send_client_cert) {
-    network_session_->ssl_client_auth_cache()->Remove(
+    gcm_network_session_->ssl_client_auth_cache()->Remove(
         proxy_info_.proxy_server().host_port_pair());
   }
 
-  int status = network_session_->proxy_service()->ReconsiderProxyAfterError(
+  int status = gcm_network_session_->proxy_service()->ReconsiderProxyAfterError(
       GetCurrentEndpoint(), net::LOAD_NORMAL, error, &proxy_info_,
       base::Bind(&ConnectionFactoryImpl::OnProxyResolveDone,
                  weak_ptr_factory_.GetWeakPtr()),
       &pac_request_,
       NULL,
       bound_net_log_);
   if (status == net::OK || status == net::ERR_IO_PENDING) {
     CloseSocket();
   } else {
     // If ReconsiderProxyAfterError() failed synchronously, it means
     // there was nothing left to fall-back to, so fail the transaction
     // with the last connection error we got.
     status = error;
   }
 
   // If there is new proxy info, post OnProxyResolveDone to retry it. Otherwise,
   // if there was an error falling back, fail synchronously.
   if (status == net::OK) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ConnectionFactoryImpl::OnProxyResolveDone,
                    weak_ptr_factory_.GetWeakPtr(), status));
     status = net::ERR_IO_PENDING;
   }
   return status;
 }
 
 void ConnectionFactoryImpl::ReportSuccessfulProxyConnection() {
-  if (network_session_ && network_session_->proxy_service())
-    network_session_->proxy_service()->ReportSuccess(proxy_info_);
+  if (gcm_network_session_ && gcm_network_session_->proxy_service())
+    gcm_network_session_->proxy_service()->ReportSuccess(proxy_info_);
 }
 
 void ConnectionFactoryImpl::CloseSocket() {
   // The connection handler needs to be reset, else it'll attempt to keep using
   // the destroyed socket.
   if (connection_handler_)
     connection_handler_->Reset();
 
   if (socket_handle_.socket() && socket_handle_.socket()->IsConnected())
     socket_handle_.socket()->Disconnect();
   socket_handle_.Reset();
 }
 
+void ConnectionFactoryImpl::RebuildNetworkSessionAuthCache() {
+  if (!http_network_session_ || !http_network_session_->http_auth_cache())
+    return;
+
+  gcm_network_session_->http_auth_cache()->UpdateAllFrom(
+      *http_network_session_->http_auth_cache());
+}
+
 }  // namespace gcm