Wrapped data reduction proxy initialization into its own class

chrome/browser/io_thread.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 "chrome/browser/io_thread.h"
 
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 17 matching lines @@
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/net/async_dns_field_trial.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/net/chrome_network_delegate.h"
 #include "chrome/browser/net/connect_interceptor.h"
 #include "chrome/browser/net/dns_probe_service.h"
 #include "chrome/browser/net/pref_proxy_config_tracker.h"
 #include "chrome/browser/net/proxy_service_factory.h"
-#include "chrome/browser/net/spdyproxy/data_reduction_proxy_chrome_settings.h"
-#include "chrome/browser/net/spdyproxy/data_reduction_proxy_chrome_settings_factory.h"
 #include "chrome/common/chrome_content_client.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
-#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_auth_request_handler.h"
-#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_delegate.h"
-#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_network_delegate.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_prefs.h"
-#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_settings.h"
-#include "components/data_reduction_proxy/core/common/data_reduction_proxy_params.h"
 #include "components/policy/core/common/policy_service.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/cookie_store_factory.h"
 #include "net/base/host_mapping_rules.h"
 #include "net/base/net_util.h"
 #include "net/cert/cert_policy_enforcer.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cert/cert_verify_proc.h"
 #include "net/cert/ct_known_logs.h"
@@ skipping 534 matching lines @@
                                 &system_enable_referrers_));
 
   if (command_line.HasSwitch(switches::kEnableClientHints))
     chrome_network_delegate->SetEnableClientHints();
 
 #if defined(ENABLE_EXTENSIONS)
   if (command_line.HasSwitch(switches::kDisableExtensionsHttpThrottling))
     chrome_network_delegate->NeverThrottleRequests();
 #endif
 
-  SetupDataReductionProxy();
-
-  // This is the same as in ProfileImplIOData except that it does not collect
-  // usage stats.
-  data_reduction_proxy::DataReductionProxyNetworkDelegate* network_delegate =
-      new data_reduction_proxy::DataReductionProxyNetworkDelegate(
-          chrome_network_delegate.Pass(),
-          globals_->data_reduction_proxy_params.get(),
-          globals_->data_reduction_proxy_auth_request_handler.get(),
-          data_reduction_proxy::DataReductionProxyNetworkDelegate::
-              ProxyConfigGetter());
-
-  globals_->system_network_delegate.reset(network_delegate);
+  globals_->system_network_delegate = chrome_network_delegate.Pass();

[mmenke, 2015/01/16 19:03:20]

So we're completely removing DRP support from the system network delegate? 
Should have a comment about this in the CL description.

[bengr, 2015/01/17 00:20:47]

Done.

   globals_->host_resolver = CreateGlobalHostResolver(net_log_);
   UpdateDnsClientEnabled();
 #if defined(OS_CHROMEOS)
   // Creates a CertVerifyProc that doesn't allow any profile-provided certs.
   globals_->cert_verifier.reset(new net::MultiThreadedCertVerifier(
       new chromeos::CertVerifyProcChromeOS()));
 #else
   globals_->cert_verifier.reset(new net::MultiThreadedCertVerifier(
       net::CertVerifyProc::CreateDefault()));
 #endif
@@ skipping 437 matching lines @@
   globals.quic_max_packet_length.CopyToIfSet(&params->quic_max_packet_length);
   globals.quic_user_agent_id.CopyToIfSet(&params->quic_user_agent_id);
   globals.quic_supported_versions.CopyToIfSet(
       &params->quic_supported_versions);
   params->quic_connection_options = globals.quic_connection_options;
 
   globals.origin_to_force_quic_on.CopyToIfSet(
       &params->origin_to_force_quic_on);
   params->enable_user_alternate_protocol_ports =
       globals.enable_user_alternate_protocol_ports;
-  params->proxy_delegate = globals.data_reduction_proxy_delegate.get();
 }
 
 base::TimeTicks IOThread::creation_time() const {
   return creation_time_;
 }
 
 net::SSLConfigService* IOThread::GetSSLConfigService() {
   return ssl_config_service_manager_->Get();
 }
 
@@ skipping 33 matching lines @@
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   globals_->system_proxy_service.reset(
       ProxyServiceFactory::CreateProxyService(
           net_log_,
           globals_->proxy_script_fetcher_context.get(),
           globals_->system_network_delegate.get(),
           system_proxy_config_service_.release(),
           command_line,
           quick_check_enabled_.GetValue()));
-  DCHECK(globals_->data_reduction_proxy_params);
 
   net::HttpNetworkSession::Params system_params;
   InitializeNetworkSessionParams(&system_params);
   system_params.net_log = net_log_;
   system_params.proxy_service = globals_->system_proxy_service.get();
 
   globals_->system_http_transaction_factory.reset(
       new net::HttpNetworkLayer(
           new net::HttpNetworkSession(system_params)));
   globals_->system_url_request_job_factory.reset(
@@ skipping 17 matching lines @@
   std::string group =
       base::FieldTrialList::FindFullName(kQuicFieldTrialName);
   VariationParameters params;
   if (!variations::GetVariationParams(kQuicFieldTrialName, &params)) {
     params.clear();
   }
 
   ConfigureQuicGlobals(command_line, group, params, globals_);
 }
 
-void IOThread::SetupDataReductionProxy() {
-  // TODO(kundaji): Move flags initialization to DataReductionProxyParams and
-  // merge with flag initialization in
-  // data_reduction_proxy_chrome_settings_factory.cc.
-  int flags = data_reduction_proxy::DataReductionProxyParams::kAllowed |
-      data_reduction_proxy::DataReductionProxyParams::kFallbackAllowed |
-      data_reduction_proxy::DataReductionProxyParams::kAlternativeAllowed;
-  if (data_reduction_proxy::DataReductionProxyParams::
-      IsIncludedInPromoFieldTrial()) {
-    flags |= data_reduction_proxy::DataReductionProxyParams::kPromoAllowed;
-  }
-  if (data_reduction_proxy::DataReductionProxyParams::
-      IsIncludedInHoldbackFieldTrial()) {
-    flags |= data_reduction_proxy::DataReductionProxyParams::kHoldback;
-  }
-#if defined(OS_ANDROID)
-  if (data_reduction_proxy::DataReductionProxyParams::
-          IsIncludedInAndroidOnePromoFieldTrial(
-              base::android::BuildInfo::GetInstance()->android_build_fp())) {
-    flags |= data_reduction_proxy::DataReductionProxyParams::kPromoAllowed;
-  }
-#endif
-  globals_->data_reduction_proxy_params.reset(
-      new data_reduction_proxy::DataReductionProxyParams(flags));
-  globals_->data_reduction_proxy_auth_request_handler.reset(
-      new data_reduction_proxy::DataReductionProxyAuthRequestHandler(
-          DataReductionProxyChromeSettings::GetClient(),
-          globals_->data_reduction_proxy_params.get(),
-          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)));
-  globals_->data_reduction_proxy_delegate.reset(
-      new data_reduction_proxy::DataReductionProxyDelegate(
-          globals_->data_reduction_proxy_auth_request_handler.get(),
-          globals_->data_reduction_proxy_params.get()));
-}
-
 // static
 void IOThread::ConfigureQuicGlobals(
     const base::CommandLine& command_line,
     base::StringPiece quic_trial_group,
     const VariationParameters& quic_trial_params,
     IOThread::Globals* globals) {
   bool enable_quic = ShouldEnableQuic(command_line, quic_trial_group);
   globals->enable_quic.set(enable_quic);
   if (enable_quic) {
     globals->quic_always_require_handshake_confirmation.set(
@@ skipping 242 matching lines @@
   net::QuicVersionVector supported_versions = net::QuicSupportedVersions();
   for (size_t i = 0; i < supported_versions.size(); ++i) {
     net::QuicVersion version = supported_versions[i];
     if (net::QuicVersionToString(version) == quic_version) {
       return version;
     }
   }
 
   return net::QUIC_VERSION_UNSUPPORTED;
 }