Moved data reduction proxy initialization logic to ProfileImplIOData

chrome/browser/profiles/profile_impl_io_data.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/profiles/profile_impl_io_data.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
@@ skipping 32 matching lines @@
 #include "net/base/cache_type.h"
 #include "net/base/sdch_dictionary_fetcher.h"
 #include "net/base/sdch_manager.h"
 #include "net/ftp/ftp_network_layer.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_server_properties_manager.h"
 #include "net/ssl/server_bound_cert_service.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "webkit/browser/quota/special_storage_policy.h"
 
+#if defined(SPDY_PROXY_AUTH_ORIGIN)
+#include "components/data_reduction_proxy/browser/data_reduction_proxy_auth_request_handler.h"
+#include "components/data_reduction_proxy/browser/data_reduction_proxy_protocol.h"
+#include "components/data_reduction_proxy/browser/data_reduction_proxy_usage_stats.h"
+#include "components/data_reduction_proxy/common/data_reduction_proxy_pref_names.h"
+#endif  // defined(SPDY_PROXY_AUTH_ORIGIN)
+
 namespace {
 
 net::BackendType ChooseCacheBackendType() {
 #if defined(OS_ANDROID)
   return net::CACHE_BACKEND_SIMPLE;
 #else
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kUseSimpleCacheBackend)) {
     const std::string opt_value =
         command_line.GetSwitchValueASCII(switches::kUseSimpleCacheBackend);
     if (LowerCaseEqualsASCII(opt_value, "off"))
       return net::CACHE_BACKEND_BLOCKFILE;
     if (opt_value == "" || LowerCaseEqualsASCII(opt_value, "on"))
       return net::CACHE_BACKEND_SIMPLE;
   }
   const std::string experiment_name =
       base::FieldTrialList::FindFullName("SimpleCacheTrial");
   if (experiment_name == "ExperimentYes" ||
       experiment_name == "ExperimentYes2") {
     return net::CACHE_BACKEND_SIMPLE;
   }
   return net::CACHE_BACKEND_BLOCKFILE;
 #endif
 }
 
 }  // namespace
 
 using content::BrowserThread;
+#if defined(SPDY_PROXY_AUTH_ORIGIN)
+using data_reduction_proxy::DataReductionProxyParams;
+#endif  // defined(OS_ANDROID) || defined(OS_IOS)
 
 ProfileImplIOData::Handle::Handle(Profile* profile)
     : io_data_(new ProfileImplIOData),
       profile_(profile),
       initialized_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(profile);
 }
 
 ProfileImplIOData::Handle::~Handle() {
@@ skipping 22 matching lines @@
       int cache_max_size,
       const base::FilePath& media_cache_path,
       int media_cache_max_size,
       const base::FilePath& extensions_cookie_path,
       const base::FilePath& profile_path,
       const base::FilePath& infinite_cache_path,
       chrome_browser_net::Predictor* predictor,
       content::CookieStoreConfig::SessionCookieMode session_cookie_mode,
       quota::SpecialStoragePolicy* special_storage_policy,
       scoped_ptr<domain_reliability::DomainReliabilityMonitor>
-          domain_reliability_monitor) {
+          domain_reliability_monitor,
+      const base::Callback<void(bool)>& data_reduction_proxy_unavailable) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!io_data_->lazy_params_);
   DCHECK(predictor);
 
   LazyParams* lazy_params = new LazyParams();
 
   lazy_params->cookie_path = cookie_path;
   lazy_params->server_bound_cert_path = server_bound_cert_path;
   lazy_params->cache_path = cache_path;
   lazy_params->cache_max_size = cache_max_size;
   lazy_params->media_cache_path = media_cache_path;
   lazy_params->media_cache_max_size = media_cache_max_size;
   lazy_params->extensions_cookie_path = extensions_cookie_path;
   lazy_params->infinite_cache_path = infinite_cache_path;
   lazy_params->session_cookie_mode = session_cookie_mode;
   lazy_params->special_storage_policy = special_storage_policy;
 
   io_data_->lazy_params_.reset(lazy_params);
 
   // Keep track of profile path and cache sizes separately so we can use them
   // on demand when creating storage isolated URLRequestContextGetters.
   io_data_->profile_path_ = profile_path;
   io_data_->app_cache_max_size_ = cache_max_size;
   io_data_->app_media_cache_max_size_ = media_cache_max_size;
 
   io_data_->predictor_.reset(predictor);
   io_data_->domain_reliability_monitor_ = domain_reliability_monitor.Pass();
 
   io_data_->InitializeMetricsEnabledStateOnUIThread();
+
+#if defined(SPDY_PROXY_AUTH_ORIGIN)
+  io_data_->data_reduction_proxy_unavailable_callback_ =
+      data_reduction_proxy_unavailable;
+#endif  // defined(SPDY_PROXY_AUTH_ORIGIN)
 }
 
 content::ResourceContext*
     ProfileImplIOData::Handle::GetResourceContext() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   LazyInitialize();
   return GetResourceContextNoInit();
 }
 
 content::ResourceContext*
@@ skipping 158 matching lines @@
   io_data_->session_startup_pref()->Init(
       prefs::kRestoreOnStartup, pref_service);
   io_data_->session_startup_pref()->MoveToThread(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
 #if defined(FULL_SAFE_BROWSING) || defined(MOBILE_SAFE_BROWSING)
   io_data_->safe_browsing_enabled()->Init(prefs::kSafeBrowsingEnabled,
       pref_service);
   io_data_->safe_browsing_enabled()->MoveToThread(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
 #endif
-#if defined(OS_ANDROID) || defined(OS_IOS)
+#if defined(SPDY_PROXY_AUTH_ORIGIN)
   io_data_->data_reduction_proxy_enabled()->Init(
       data_reduction_proxy::prefs::kDataReductionProxyEnabled, pref_service);
   io_data_->data_reduction_proxy_enabled()->MoveToThread(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
-#endif
+#endif  // defined(SPDY_PROXY_AUTH_ORIGIN)
   io_data_->InitializeOnUIThread(profile_);
 }
 
 ProfileImplIOData::LazyParams::LazyParams()
     : cache_max_size(0),
       media_cache_max_size(0),
       session_cookie_mode(
           content::CookieStoreConfig::EPHEMERAL_SESSION_COOKIES) {}
 
 ProfileImplIOData::LazyParams::~LazyParams() {}
@@ skipping 17 matching lines @@
 
 void ProfileImplIOData::InitializeInternal(
     ProfileParams* profile_params,
     content::ProtocolHandlerMap* protocol_handlers,
     content::URLRequestInterceptorScopedVector request_interceptors) const {
   ChromeURLRequestContext* main_context = main_request_context();
 
   IOThread* const io_thread = profile_params->io_thread;
   IOThread::Globals* const io_thread_globals = io_thread->globals();
 
+#if defined(SPDY_PROXY_AUTH_ORIGIN)
+  // TODO(bengr): Extract parameters from DataReductionProxySettings.
+  int drp_flags = DataReductionProxyParams::kFallbackAllowed;
+  if (DataReductionProxyParams::IsIncludedInFieldTrial())
+    drp_flags |= DataReductionProxyParams::kAllowed;
+  if (DataReductionProxyParams::IsIncludedInAlternativeFieldTrial())
+    drp_flags |= DataReductionProxyParams::kAlternativeAllowed;
+  if (DataReductionProxyParams::IsIncludedInPromoFieldTrial())
+    drp_flags |= DataReductionProxyParams::kPromoAllowed;
+  data_reduction_proxy_params_.reset(
+      new DataReductionProxyParams(drp_flags));
+  data_reduction_proxy_auth_request_handler_.reset(
+      new data_reduction_proxy::DataReductionProxyAuthRequestHandler(
+          data_reduction_proxy_params_.get()));
+  data_reduction_proxy_usage_stats_.reset(
+      new data_reduction_proxy::DataReductionProxyUsageStats(
+          data_reduction_proxy_params_.get(),
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)));
+  data_reduction_proxy_usage_stats_->set_unavailable_callback(
+      data_reduction_proxy_unavailable_callback_);
+
+
+  network_delegate()->set_data_reduction_proxy_params(
+      data_reduction_proxy_params_.get());
+  network_delegate()->set_data_reduction_proxy_usage_stats(
+      data_reduction_proxy_usage_stats_.get());
+  network_delegate()->set_data_reduction_proxy_auth_request_handler(
+      data_reduction_proxy_auth_request_handler_.get());
+  network_delegate()->set_on_resolve_proxy_handler(
+      base::Bind(data_reduction_proxy::OnResolveProxyHandler));
+#endif  // defined(SPDY_PROXY_AUTH_ORIGIN)
+
   network_delegate()->set_predictor(predictor_.get());
 
   // Initialize context members.
 
   ApplyProfileParamsToContext(main_context);
 
   if (http_server_properties_manager_)
     http_server_properties_manager_->InitializeOnNetworkThread();
 
   main_context->set_transport_security_state(transport_security_state());
@@ skipping 367 matching lines @@
     const base::Closure& completion) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(initialized());
 
   DCHECK(transport_security_state());
   // Completes synchronously.
   transport_security_state()->DeleteAllDynamicDataSince(time);
   DCHECK(http_server_properties_manager_);
   http_server_properties_manager_->Clear(completion);
 }