Move data reduction proxy logic out of chrome and android webview network delegate

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 25 matching lines @@
 #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_protocol.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"
@@ skipping 521 matching lines @@
       new LoggingNetworkChangeObserver(net_log_));
 
   // Setup the HistogramWatcher to run on the IO thread.
   net::NetworkChangeNotifier::InitHistogramWatcher();
 
 #if defined(ENABLE_EXTENSIONS)
   globals_->extension_event_router_forwarder =
       extension_event_router_forwarder_;
 #endif
 
-  ChromeNetworkDelegate* network_delegate =
+  scoped_ptr<ChromeNetworkDelegate> chrome_network_delegate(
       new ChromeNetworkDelegate(extension_event_router_forwarder(),
-                                &system_enable_referrers_);
+                                &system_enable_referrers_));
 
   if (command_line.HasSwitch(switches::kEnableClientHints))
-    network_delegate->SetEnableClientHints();
+    chrome_network_delegate->SetEnableClientHints();
 
 #if defined(ENABLE_EXTENSIONS)
   if (command_line.HasSwitch(switches::kDisableExtensionsHttpThrottling))
-    network_delegate->NeverThrottleRequests();
+    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_->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()));
@@ skipping 28 matching lines @@
       scoped_ptr<net::CTLogVerifier> external_log_verifier(
           net::CTLogVerifier::Create(ct_public_key_data, log_description));
       CHECK(external_log_verifier) << "Unable to parse CT public key.";
       VLOG(1) << "Adding log with description " << log_description;
       ct_verifier->AddLog(external_log_verifier.Pass());
     }
   }
 
   globals_->ssl_config_service = GetSSLConfigService();
 
-  SetupDataReductionProxy(network_delegate);
-
   globals_->http_auth_handler_factory.reset(CreateDefaultAuthHandlerFactory(
       globals_->host_resolver.get()));
   globals_->http_server_properties.reset(new net::HttpServerPropertiesImpl());
   // For the ProxyScriptFetcher, we use a direct ProxyService.
   globals_->proxy_script_fetcher_proxy_service.reset(
       net::ProxyService::CreateDirectWithNetLog(net_log_));
   // In-memory cookie store.
   globals_->system_cookie_store =
         content::CreateCookieStore(content::CookieStoreConfig());
   // In-memory channel ID store.
@@ skipping 469 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(
-    ChromeNetworkDelegate* network_delegate) {
+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;
   }
   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()));
-  // This is the same as in ProfileImplIOData except that we do not collect
-  // usage stats.
-  network_delegate->set_data_reduction_proxy_params(
-      globals_->data_reduction_proxy_params.get());
-  network_delegate->set_data_reduction_proxy_auth_request_handler(
-      globals_->data_reduction_proxy_auth_request_handler.get());
-  network_delegate->set_on_resolve_proxy_handler(
-      base::Bind(data_reduction_proxy::OnResolveProxyHandler));
 }
 
 // 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);
@@ skipping 233 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;
 }