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

components/gcm_driver/gcm_client_impl.cc

 // Copyright 2014 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 "components/gcm_driver/gcm_client_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/default_clock.h"
 #include "google_apis/gcm/base/encryptor.h"
 #include "google_apis/gcm/base/mcs_message.h"
 #include "google_apis/gcm/base/mcs_util.h"
 #include "google_apis/gcm/engine/checkin_request.h"
 #include "google_apis/gcm/engine/connection_factory_impl.h"
 #include "google_apis/gcm/engine/gcm_store_impl.h"
 #include "google_apis/gcm/monitoring/gcm_stats_recorder.h"
 #include "google_apis/gcm/protocol/checkin.pb.h"
 #include "google_apis/gcm/protocol/mcs.pb.h"
 #include "net/http/http_network_session.h"
+#include "net/http/http_transaction_factory.h"
 #include "net/url_request/url_request_context.h"
 #include "url/gurl.h"
 
 namespace gcm {
 
 namespace {
 
 // Backoff policy. Shared across reconnection logic and checkin/(un)registration
 // retries.
 // Note: In order to ensure a minimum of 20 seconds between server errors (for
@@ skipping 192 matching lines @@
       new MCSClient(version,
                     clock,
                     connection_factory,
                     gcm_store,
                     recorder));
 }
 
 scoped_ptr<ConnectionFactory> GCMInternalsBuilder::BuildConnectionFactory(
       const std::vector<GURL>& endpoints,
       const net::BackoffEntry::Policy& backoff_policy,
-      scoped_refptr<net::HttpNetworkSession> network_session,
+      const scoped_refptr<net::HttpNetworkSession>& http_network_session,
+      const scoped_refptr<net::HttpNetworkSession>& gcm_network_session,
       net::NetLog* net_log,
       GCMStatsRecorder* recorder) {
   return make_scoped_ptr<ConnectionFactory>(
       new ConnectionFactoryImpl(endpoints,
                                 backoff_policy,
-                                network_session,
+                                http_network_session,
+                                gcm_network_session,
                                 net_log,
                                 recorder));
 }
 
 GCMClientImpl::GCMClientImpl(scoped_ptr<GCMInternalsBuilder> internals_builder)
     : internals_builder_(internals_builder.Pass()),
       state_(UNINITIALIZED),
       delegate_(NULL),
       clock_(internals_builder_->BuildClock()),
       url_request_context_getter_(NULL),
@@ skipping 15 matching lines @@
         url_request_context_getter,
     scoped_ptr<Encryptor> encryptor,
     GCMClient::Delegate* delegate) {
   DCHECK_EQ(UNINITIALIZED, state_);
   DCHECK(url_request_context_getter);
   DCHECK(delegate);
 
   url_request_context_getter_ = url_request_context_getter;
   const net::HttpNetworkSession::Params* network_session_params =
       url_request_context_getter_->GetURLRequestContext()->
           GetNetworkSessionParams();

[mmenke, 2014/07/17 18:34:06]

Oh...You're already using the main proxy service, and modifying its bad proxy
list.  I hadn't realized that.  Hrm...still think this is the better approach,
though.

   DCHECK(network_session_params);
   network_session_ = new net::HttpNetworkSession(*network_session_params);
 
   chrome_build_info_ = chrome_build_info;
 
   gcm_store_.reset(
       new GCMStoreImpl(path, blocking_task_runner, encryptor.Pass()));
 
   delegate_ = delegate;
 
@@ skipping 38 matching lines @@
 }
 
 void GCMClientImpl::InitializeMCSClient(
     scoped_ptr<GCMStore::LoadResult> result) {
   std::vector<GURL> endpoints;
   endpoints.push_back(gservices_settings_.GetMCSMainEndpoint());
   endpoints.push_back(gservices_settings_.GetMCSFallbackEndpoint());
   connection_factory_ = internals_builder_->BuildConnectionFactory(
       endpoints,
       kDefaultBackoffPolicy,
+      url_request_context_getter_->GetURLRequestContext()
+          ->http_transaction_factory()
+          ->GetSession(),
       network_session_,
       net_log_.net_log(),
       &recorder_);
   connection_factory_->SetConnectionListener(this);
   mcs_client_ = internals_builder_->BuildMCSClient(
       chrome_build_info_.version,
       clock_.get(),
       connection_factory_.get(),
       gcm_store_.get(),
       &recorder_).Pass();
@@ skipping 532 matching lines @@
 
   recorder_.RecordIncomingSendError(
       data_message_stanza.category(),
       data_message_stanza.to(),
       data_message_stanza.id());
   delegate_->OnMessageSendError(data_message_stanza.category(),
                                 send_error_details);
 }
 
 }  // namespace gcm