Added alternative configuration for the data reduction proxy

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 77 matching lines @@
 #if !defined(USE_OPENSSL)
 #include "net/cert/ct_log_verifier.h"
 #include "net/cert/multi_log_ct_verifier.h"
 #endif
 
 #if defined(USE_NSS) || defined(OS_IOS)
 #include "net/ocsp/nss_ocsp.h"
 #endif
 
 #if defined(OS_ANDROID) || defined(OS_IOS)
+#include "components/data_reduction_proxy/browser/data_reduction_proxy_params.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_settings.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/net/cert_verify_proc_chromeos.h"
 #endif
 
 using content::BrowserThread;
 
 #if defined(OS_ANDROID) || defined(OS_IOS)
+using data_reduction_proxy::DataReductionProxyParams;
 using data_reduction_proxy::DataReductionProxySettings;
 #endif
 
 class SafeBrowsingURLRequestContext;
 
 // The IOThread object must outlive any tasks posted to the IO thread before the
 // Quit task, so base::Bind() calls are not refcounted.
 
 namespace {
 
@@ skipping 469 matching lines @@
     }
   }
 #else
   if (command_line.HasSwitch(switches::kCertificateTransparencyLog)) {
     LOG(DFATAL) << "Certificate Transparency is not yet supported in Chrome "
                    "builds using OpenSSL.";
   }
 #endif
   globals_->ssl_config_service = GetSSLConfigService();
 #if defined(OS_ANDROID) || defined(OS_IOS)
-  if (DataReductionProxySettings::IsIncludedInFieldTrialOrFlags()) {
-    spdyproxy_auth_origins_ =
-        DataReductionProxySettings::GetDataReductionProxies();
-  }
+#if defined(SPDY_PROXY_AUTH_ORIGIN)
+  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;
+  globals_->data_reduction_proxy_params.reset(
+      new DataReductionProxyParams(drp_flags));
+#endif  // defined(SPDY_PROXY_AUTH_ORIGIN)
 #endif  // defined(OS_ANDROID) || defined(OS_IOS)
   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());
@@ skipping 282 matching lines @@
                                       auth_filter_delegate));
   std::vector<std::string> supported_schemes;
   base::SplitString(auth_schemes_, ',', &supported_schemes);
 
   scoped_ptr<net::HttpAuthHandlerRegistryFactory> registry_factory(
       net::HttpAuthHandlerRegistryFactory::Create(
           supported_schemes, globals_->url_security_manager.get(),
           resolver, gssapi_library_name_, negotiate_disable_cname_lookup_,
           negotiate_enable_port_));
 
-  if (!spdyproxy_auth_origins_.empty()) {
-    registry_factory->RegisterSchemeFactory(
-        "spdyproxy",
-        new data_reduction_proxy::HttpAuthHandlerDataReductionProxy::Factory(
-            spdyproxy_auth_origins_));
+  if (globals_->data_reduction_proxy_params.get()) {
+    std::vector<GURL> data_reduction_proxies =
+        globals_->data_reduction_proxy_params->GetAllowedProxies();
+    if (!data_reduction_proxies.empty()) {
+      registry_factory->RegisterSchemeFactory(
+          "spdyproxy",
+          new data_reduction_proxy::HttpAuthHandlerDataReductionProxy::Factory(
+              data_reduction_proxies));
+    }
   }
 
   return registry_factory.release();
 }
 
 void IOThread::ClearHostCache() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   net::HostCache* host_cache = globals_->host_resolver->GetHostCache();
   if (host_cache)
@@ skipping 281 matching lines @@
   std::string version_flag =
       command_line.GetSwitchValueASCII(switches::kQuicVersion);
   for (size_t i = 0; i < supported_versions.size(); ++i) {
     net::QuicVersion version = supported_versions[i];
     if (net::QuicVersionToString(version) == version_flag) {
       return version;
     }
   }
   return net::QUIC_VERSION_UNSUPPORTED;
 }