Use common code to set HttpNetworkSession::Param pointers.

net/url_request/url_request_context_builder.cc

 // Copyright (c) 2012 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/url_request/url_request_context_builder.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_delegate_impl.h"
 #include "net/base/sdch_manager.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/dns/host_resolver.h"
 #include "net/ftp/ftp_network_layer.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
-#include "net/http/http_network_session.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/http_server_properties_manager.h"
 #include "net/http/transport_security_persister.h"
 #include "net/http/transport_security_state.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 #include "net/url_request/data_protocol_handler.h"
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request_backoff_manager.h"
@@ skipping 168 matching lines @@
       ftp_enabled_(false),
 #endif
       http_cache_enabled_(true),
       throttling_enabled_(false),
       backoff_enabled_(false),
       sdch_enabled_(false) {
 }
 
 URLRequestContextBuilder::~URLRequestContextBuilder() {}
 
+// static

[mmenke, 2015/08/18 18:30:32]

nit:  Remove static (No longer in Google style guide)

[wjmaclean, 2015/08/18 18:55:37]

Done.

+void URLRequestContextBuilder::SetHttpNetworkSessionComponents(
+    const URLRequestContext* context,
+    HttpNetworkSession::Params* params) {
+  params->host_resolver = context->host_resolver();
+  params->cert_verifier = context->cert_verifier();
+  params->transport_security_state = context->transport_security_state();
+  params->cert_transparency_verifier = context->cert_transparency_verifier();
+  params->proxy_service = context->proxy_service();
+  params->ssl_config_service = context->ssl_config_service();
+  params->http_auth_handler_factory = context->http_auth_handler_factory();
+  params->network_delegate = context->network_delegate();
+  params->http_server_properties = context->http_server_properties();
+  params->net_log = context->net_log();
+  params->channel_id_service = context->channel_id_service();
+}
+
 void URLRequestContextBuilder::EnableHttpCache(const HttpCacheParams& params) {
   http_cache_enabled_ = true;
   http_cache_params_ = params;
 }
 
 void URLRequestContextBuilder::DisableHttpCache() {
   http_cache_enabled_ = false;
   http_cache_params_ = HttpCacheParams();
 }
 
@@ skipping 119 matching lines @@
 
   storage->set_cert_verifier(CertVerifier::CreateDefault());
 
   if (throttling_enabled_)
     storage->set_throttler_manager(new URLRequestThrottlerManager());
 
   if (backoff_enabled_)
     storage->set_backoff_manager(new URLRequestBackoffManager());
 
   HttpNetworkSession::Params network_session_params;
-  network_session_params.host_resolver = context->host_resolver();
-  network_session_params.cert_verifier = context->cert_verifier();
-  network_session_params.transport_security_state =
-      context->transport_security_state();
-  network_session_params.proxy_service = context->proxy_service();
-  network_session_params.ssl_config_service =
-      context->ssl_config_service();
-  network_session_params.http_auth_handler_factory =
-      context->http_auth_handler_factory();
-  network_session_params.network_delegate = network_delegate;
-  network_session_params.http_server_properties =
-      context->http_server_properties();
-  network_session_params.net_log = context->net_log();
+  SetHttpNetworkSessionComponents(context, &network_session_params);
 
   network_session_params.ignore_certificate_errors =
       http_network_session_params_.ignore_certificate_errors;
   network_session_params.host_mapping_rules =
       http_network_session_params_.host_mapping_rules;
   network_session_params.testing_fixed_http_port =
       http_network_session_params_.testing_fixed_http_port;
   network_session_params.testing_fixed_https_port =
       http_network_session_params_.testing_fixed_https_port;
   network_session_params.use_alternate_protocols =
     http_network_session_params_.use_alternate_protocols;
   network_session_params.trusted_spdy_proxy =
       http_network_session_params_.trusted_spdy_proxy;
   network_session_params.next_protos = http_network_session_params_.next_protos;
   network_session_params.enable_quic = http_network_session_params_.enable_quic;
   network_session_params.enable_insecure_quic =
       http_network_session_params_.enable_insecure_quic;
   network_session_params.quic_connection_options =
       http_network_session_params_.quic_connection_options;
 
   HttpTransactionFactory* http_transaction_factory = NULL;
   if (http_cache_enabled_) {
-    network_session_params.channel_id_service =
-        context->channel_id_service();
     HttpCache::BackendFactory* http_cache_backend = NULL;
     if (http_cache_params_.type == HttpCacheParams::DISK) {
       http_cache_backend = new HttpCache::DefaultBackend(
           DISK_CACHE, CACHE_BACKEND_DEFAULT, http_cache_params_.path,
           http_cache_params_.max_size, context->GetFileTaskRunner());
     } else {
       http_cache_backend =
           HttpCache::DefaultBackend::InMemory(http_cache_params_.max_size);
     }
 
@@ skipping 39 matching lines @@
     }
     url_request_interceptors_.weak_clear();
   }
   storage->set_job_factory(top_job_factory.release());
   // TODO(willchan): Support sdch.
 
   return context;
 }
 
 }  // namespace net