Disable fallback support for alternative data reduction proxy

components/data_reduction_proxy/browser/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/browser/data_reduction_proxy_params.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 67 matching lines @@
 
 bool DataReductionProxyParams::IsIncludedInHoldbackFieldTrial() {
   return FieldTrialList::FindFullName(
       "DataCompressionProxyHoldback") == kEnabled;
 }
 
 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),
       configured_on_command_line_(false) {
-  bool result = Init(allowed_, fallback_allowed_, alt_allowed_);
+  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_),
       configured_on_command_line_(other.configured_on_command_line_) {
 }
 
 DataReductionProxyParams::~DataReductionProxyParams() {
 }
 
 DataReductionProxyParams::DataReductionProxyList
 DataReductionProxyParams::GetAllowedProxies() const {
   DataReductionProxyList list;
   if (allowed_) {
     list.push_back(origin_);
   }
   if (allowed_ && fallback_allowed_)
     list.push_back(fallback_origin_);
   if (alt_allowed_) {
     list.push_back(alt_origin_);
     list.push_back(ssl_origin_);
   }
-  if (alt_allowed_ && fallback_allowed_)
+  if (alt_allowed_ && alt_fallback_allowed_)
     list.push_back(alt_fallback_origin_);
   return list;
 }
 
 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),
       configured_on_command_line_(false) {
   if (should_call_init) {
-    bool result = Init(allowed_, fallback_allowed_, alt_allowed_);
+    bool result = Init(
+        allowed_, fallback_allowed_, alt_allowed_, alt_fallback_allowed_);
     DCHECK(result);
   }
 }
 
-bool DataReductionProxyParams::Init(
-    bool allowed, bool fallback_allowed, bool alt_allowed) {
+bool DataReductionProxyParams::Init(bool allowed,
+                                    bool fallback_allowed,
+                                    bool alt_allowed,
+                                    bool alt_fallback_allowed) {
   InitWithoutChecks();
   // Verify that all necessary params are set.
   if (allowed) {
     if (!origin_.is_valid()) {
       DVLOG(1) << "Invalid data reduction proxy origin: " << origin_.spec();
       return false;
     }
   }
 
   if (allowed && fallback_allowed) {
@@ skipping 13 matching lines @@
     if (!alt_origin_.is_valid()) {
       DVLOG(1) << "Invalid alternative origin:" << alt_origin_.spec();
       return false;
     }
     if (!ssl_origin_.is_valid()) {
       DVLOG(1) << "Invalid ssl origin: " << ssl_origin_.spec();
       return false;
     }
   }
 
-  if (alt_allowed && fallback_allowed) {
+  if (alt_allowed && alt_fallback_allowed) {
     if (!alt_fallback_origin_.is_valid()) {
       DVLOG(1) << "Invalid alternative fallback origin:"
           << alt_fallback_origin_.spec();
       return false;
     }
   }
 
   if (allowed && !probe_url_.is_valid()) {
     DVLOG(1) << "Invalid probe url: <null>";
     return false;
   }
 
   if (fallback_allowed_ && !allowed_) {
     DVLOG(1) << "The data reduction proxy fallback cannot be allowed if "
         << "the data reduction proxy is not allowed";
     return false;
   }
+  if (alt_fallback_allowed_ && !alt_allowed_) {
+    DVLOG(1) << "The data reduction proxy alternative fallback cannot be "
+        << "allowed if the alternative data reduction proxy is not allowed";
+    return false;
+  }
   if (promo_allowed_ && !allowed_) {
     DVLOG(1) << "The data reduction proxy promo cannot be allowed if the "
         << "data reduction proxy is not allowed";
     return false;
   }
   return true;
 
 }
 
 void DataReductionProxyParams::InitWithoutChecks() {
@@ skipping 17 matching lines @@
   configured_on_command_line_ =
       !(origin.empty() && fallback_origin.empty() && ssl_origin.empty() &&
           alt_origin.empty() && alt_fallback_origin.empty());
 
 
   // Configuring the proxy on the command line overrides the values of
   // |allowed_| and |alt_allowed_|.
   if (configured_on_command_line_)
     allowed_ = true;
   if (!(ssl_origin.empty() &&
-        alt_origin.empty() &&
-        alt_fallback_origin.empty()))
+        alt_origin.empty()))
     alt_allowed_ = true;
 
   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())
@@ skipping 50 matching lines @@
       proxy_info->proxy_servers.first = fallback_origin();
       proxy_info->proxy_servers.second = GURL();
       proxy_info->is_fallback = true;
     }
     return true;
   }
   if (net::HostPortPair::FromURL(alt_origin()).Equals(host_port_pair)) {
     if (proxy_info) {
       proxy_info->proxy_servers.first = alt_origin();
       proxy_info->is_alternative = true;
-      if (fallback_allowed())
+      if (alternative_fallback_allowed())
         proxy_info->proxy_servers.second = alt_fallback_origin();
     }
     return true;
   }
-  if (fallback_allowed() &&
+  if (alternative_fallback_allowed() &&
       net::HostPortPair::FromURL(alt_fallback_origin()).Equals(
       host_port_pair)) {
     if (proxy_info) {
       proxy_info->proxy_servers.first = alt_fallback_origin();
       proxy_info->proxy_servers.second = GURL();
       proxy_info->is_fallback = true;
       proxy_info->is_alternative = true;
     }
     return true;
   }
@@ skipping 196 matching lines @@
 }
 
 std::string DataReductionProxyParams::GetDefaultWarmupURL() const {
 #if defined(DATA_REDUCTION_PROXY_WARMUP_URL)
   return DATA_REDUCTION_PROXY_WARMUP_URL;
 #endif
   return std::string();
 }
 
 }  // namespace data_reduction_proxy