Enable QUIC for proxies based on Finch config and command line switch.

components/data_reduction_proxy/core/common/data_reduction_proxy_params.cc

 // Copyright 2014 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 "components/data_reduction_proxy/core/common/data_reduction_proxy_params.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 12 matching lines @@
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "url/url_constants.h"
 
 using base::FieldTrialList;
 
 namespace {
 
 const char kEnabled[] = "Enabled";
-const char kDefaultOrigin[] = "https://proxy.googlezip.net:443";
+const char kDefaultSpdyOrigin[] = "https://proxy.googlezip.net:443";
+const char kDefaultQuicOrigin[] = "quic://proxy.googlezip.net:443";
 const char kDevOrigin[] = "https://proxy-dev.googlezip.net:443";
 const char kDevFallbackOrigin[] = "proxy-dev.googlezip.net:80";
 const char kDefaultFallbackOrigin[] = "compress.googlezip.net:80";
 // This is for a proxy that supports HTTP CONNECT to tunnel SSL traffic.
 // The proxy listens on port 443, but uses the HTTP protocol to set up
 // the tunnel, not HTTPS.
 const char kDefaultSslOrigin[] = "ssl.googlezip.net:443";
 const char kDefaultAltOrigin[] = "ssl.googlezip.net:80";
 const char kDefaultAltFallbackOrigin[] = "ssl.googlezip.net:80";
 const char kDefaultProbeUrl[] = "http://check.googlezip.net/connect";
 const char kDefaultWarmupUrl[] = "http://www.gstatic.com/generate_204";
 
 const char kAndroidOneIdentifier[] = "sprout";
+
+const char kQuicFieldTrial[] = "DataReductionProxyUseQuic";
 }  // namespace
 
 namespace data_reduction_proxy {
 
 // static
 bool DataReductionProxyParams::IsIncludedInAlternativeFieldTrial() {
   const std::string group_name = base::FieldTrialList::FindFullName(
       "DataCompressionProxyAlternativeConfiguration");
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           data_reduction_proxy::switches::kEnableDataReductionProxyAlt)) {
@@ skipping 56 matching lines @@
     return true;
   }
   return false;
 }
 
 // static
 bool DataReductionProxyParams::CanProxyURLScheme(const GURL& url) {
   return url.SchemeIs(url::kHttpScheme);
 }
 
+// static
+bool DataReductionProxyParams::IsIncludedInQuicFieldTrial() {
+  return FieldTrialList::FindFullName(kQuicFieldTrial) == kEnabled;
+}
+
+// static
+std::string DataReductionProxyParams::GetQuicFieldTrialName() {
+  return kQuicFieldTrial;
+}
+
+void DataReductionProxyParams::EnableQuic(bool enable) {
+  quic_enabled_ = enable;
+  DCHECK(!quic_enabled_ || IsIncludedInQuicFieldTrial());
+  if (override_quic_origin_.empty() && quic_enabled_)
+    origin_ = net::ProxyServer::FromURI(kDefaultQuicOrigin,
+                                        net::ProxyServer::SCHEME_HTTP);
+}
+
 DataReductionProxyTypeInfo::DataReductionProxyTypeInfo()
     : proxy_servers(),
       is_fallback(false),
       is_alternative(false),
       is_ssl(false) {
 }
 
 DataReductionProxyTypeInfo::~DataReductionProxyTypeInfo(){
 }
 
 DataReductionProxyParams::DataReductionProxyParams(int flags)
     : allowed_((flags & kAllowed) == kAllowed),
       fallback_allowed_((flags & kFallbackAllowed) == kFallbackAllowed),
       alt_allowed_((flags & kAlternativeAllowed) == kAlternativeAllowed),
       alt_fallback_allowed_(
           (flags & kAlternativeFallbackAllowed) == kAlternativeFallbackAllowed),
       promo_allowed_((flags & kPromoAllowed) == kPromoAllowed),
       holdback_((flags & kHoldback) == kHoldback),
+      quic_enabled_(false),
       configured_on_command_line_(false) {
   bool result = Init(
       allowed_, fallback_allowed_, alt_allowed_, alt_fallback_allowed_);
   DCHECK(result);
 }
 
 scoped_ptr<DataReductionProxyParams> DataReductionProxyParams::Clone() {
   return scoped_ptr<DataReductionProxyParams>(
       new DataReductionProxyParams(*this));
 }
 
 DataReductionProxyParams::DataReductionProxyParams(
     const DataReductionProxyParams& other)
     : origin_(other.origin_),
       fallback_origin_(other.fallback_origin_),
       ssl_origin_(other.ssl_origin_),
       alt_origin_(other.alt_origin_),
       alt_fallback_origin_(other.alt_fallback_origin_),
       probe_url_(other.probe_url_),
       warmup_url_(other.warmup_url_),
       allowed_(other.allowed_),
       fallback_allowed_(other.fallback_allowed_),
       alt_allowed_(other.alt_allowed_),
       alt_fallback_allowed_(other.alt_fallback_allowed_),
       promo_allowed_(other.promo_allowed_),
       holdback_(other.holdback_),
+      quic_enabled_(other.quic_enabled_),
+      override_quic_origin_(other.override_quic_origin_),
       configured_on_command_line_(other.configured_on_command_line_) {
 }
 
 DataReductionProxyParams::~DataReductionProxyParams() {
 }
 
 DataReductionProxyParams::DataReductionProxyList
 DataReductionProxyParams::GetAllowedProxies() const {
   DataReductionProxyList list;
   if (allowed_) {
@@ skipping 12 matching lines @@
 
 DataReductionProxyParams::DataReductionProxyParams(int flags,
                                                    bool should_call_init)
     : allowed_((flags & kAllowed) == kAllowed),
       fallback_allowed_((flags & kFallbackAllowed) == kFallbackAllowed),
       alt_allowed_((flags & kAlternativeAllowed) == kAlternativeAllowed),
       alt_fallback_allowed_(
           (flags & kAlternativeFallbackAllowed) == kAlternativeFallbackAllowed),
       promo_allowed_((flags & kPromoAllowed) == kPromoAllowed),
       holdback_((flags & kHoldback) == kHoldback),
+      quic_enabled_(false),
       configured_on_command_line_(false) {
   if (should_call_init) {
     bool result = Init(
         allowed_, fallback_allowed_, alt_allowed_, alt_fallback_allowed_);
     DCHECK(result);
   }
 }
 
 bool DataReductionProxyParams::Init(bool allowed,
                                     bool fallback_allowed,
@@ skipping 98 matching lines @@
 
   std::string probe_url = command_line.GetSwitchValueASCII(
       switches::kDataReductionProxyProbeURL);
   std::string warmup_url = command_line.GetSwitchValueASCII(
       switches::kDataReductionProxyWarmupURL);
 
   // Set from preprocessor constants those params that are not specified on the
   // command line.
   if (origin.empty())
     origin = GetDefaultDevOrigin();
+  override_quic_origin_ = origin;
   if (origin.empty())
     origin = GetDefaultOrigin();
   if (fallback_origin.empty())
     fallback_origin = GetDefaultDevFallbackOrigin();
   if (fallback_origin.empty())
     fallback_origin = GetDefaultFallbackOrigin();
   if (ssl_origin.empty())
     ssl_origin = GetDefaultSSLOrigin();
   if (alt_origin.empty())
     alt_origin = GetDefaultAltOrigin();
@@ skipping 208 matching lines @@
   }
 
   if (retry_delay)
      *retry_delay = found->second.current_delay;
 
   return true;
 }
 
 // TODO(kundaji): Remove tests for macro definitions.
 std::string DataReductionProxyParams::GetDefaultOrigin() const {
-  return kDefaultOrigin;
+  return quic_enabled_ ?
+      kDefaultQuicOrigin : kDefaultSpdyOrigin;
 }
 
 std::string DataReductionProxyParams::GetDefaultFallbackOrigin() const {
   return kDefaultFallbackOrigin;
 }
 
 std::string DataReductionProxyParams::GetDefaultSSLOrigin() const {
   return kDefaultSslOrigin;
 }
 
 std::string DataReductionProxyParams::GetDefaultAltOrigin() const {
   return kDefaultAltOrigin;
 }
 
 std::string DataReductionProxyParams::GetDefaultAltFallbackOrigin() const {
   return kDefaultAltFallbackOrigin;
 }
 
 std::string DataReductionProxyParams::GetDefaultProbeURL() const {
   return kDefaultProbeUrl;
 }
 
 std::string DataReductionProxyParams::GetDefaultWarmupURL() const {
   return kDefaultWarmupUrl;
 }
 
 }  // namespace data_reduction_proxy