Added support for 'Chrome-Proxy: block-once' header

components/data_reduction_proxy/common/data_reduction_proxy_headers.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/common/data_reduction_proxy_headers.h"
 
 #include <string>
 #include <vector>
 
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 
 using base::StringPiece;
 using base::TimeDelta;
 
 namespace {
 
 const char kChromeProxyHeader[] = "chrome-proxy";
 const char kActionValueDelimiter = '=';
 
+const char kChromeProxyActionBlockOnce[] = "block-once";
 const char kChromeProxyActionBlock[] = "block";
 const char kChromeProxyActionBypass[] = "bypass";
 
 // Actions for tamper detection fingerprints.
 const char kChromeProxyActionFingerprintChromeProxy[]   = "fcp";
 const char kChromeProxyActionFingerprintVia[]           = "fvia";
 const char kChromeProxyActionFingerprintOtherHeaders[]  = "foh";
 const char kChromeProxyActionFingerprintContentLength[] = "fcl";
 
 const int kShortBypassMaxSeconds = 59;
 const int kMediumBypassMaxSeconds = 300;
 
 // Returns a random bypass duration between 1 and 5 minutes.
 base::TimeDelta GetDefaultBypassDuration() {
   const int64 delta_ms =
       base::RandInt(base::TimeDelta::FromMinutes(1).InMilliseconds(),
                     base::TimeDelta::FromMinutes(5).InMilliseconds());
   return TimeDelta::FromMilliseconds(delta_ms);
 }
+
 }  // namespace
 
 namespace data_reduction_proxy {
 
 bool GetDataReductionProxyActionValue(
     const net::HttpResponseHeaders* headers,
     const std::string& action_prefix,
     std::string* action_value) {
   DCHECK(headers);
   DCHECK(!action_prefix.empty());
@@ skipping 49 matching lines @@
         return true;
       }
     }
   }
   return false;
 }
 
 bool ParseHeadersAndSetProxyInfo(const net::HttpResponseHeaders* headers,
                                  DataReductionProxyInfo* proxy_info) {
   DCHECK(proxy_info);
-  proxy_info->bypass_all = false;
+
   // Support header of the form Chrome-Proxy: bypass|block=<duration>, where
   // <duration> is the number of seconds to wait before retrying
   // the proxy. If the duration is 0, then the default proxy retry delay
   // (specified in |ProxyList::UpdateRetryInfoOnFallback|) will be used.
   // 'bypass' instructs Chrome to bypass the currently connected data reduction
   // proxy, whereas 'block' instructs Chrome to bypass all available data
   // reduction proxies.
 
-  // 'block' takes precedence over 'bypass', so look for it first.
+  // 'block' takes precedence over 'bypass' and 'block-once', so look for it
+  // first.
   // TODO(bengr): Reduce checks for 'block' and 'bypass' to a single loop.
   if (ParseHeadersAndSetBypassDuration(
           headers, kChromeProxyActionBlock, &proxy_info->bypass_duration)) {
     proxy_info->bypass_all = true;
+    proxy_info->mark_proxies_as_bad = true;
     return true;
   }
 
   // Next, look for 'bypass'.
   if (ParseHeadersAndSetBypassDuration(
           headers, kChromeProxyActionBypass, &proxy_info->bypass_duration)) {
+    proxy_info->bypass_all = false;
+    proxy_info->mark_proxies_as_bad = true;
     return true;
   }
+
+  // Lastly, look for 'block-once'. 'block-once' instructs Chrome to retry the
+  // current request (if it's idempotent), bypassing all available data
+  // reduction proxies. Unlike 'block', 'block-once' does not cause data
+  // reduction proxies to be bypassed for an extended period of time;
+  // 'block-once' only affects the retry of the current request.
+  if (headers->HasHeaderValue(kChromeProxyHeader,

[bengr, 2014/08/12 20:57:10]

If we believe that this will become the dominant instruction, then would it make
sense to put it first?

[sclittle, 2014/08/12 21:24:43]

I'm not certain what the priorities should be. The reason I put 'block-once'
last was because the effects of 'block-once' are a subset of the effects of
'block' (and also 'bypass'), but I can switch them around if you'd prefer.

+                              kChromeProxyActionBlockOnce)) {
+    proxy_info->bypass_all = true;
+    proxy_info->mark_proxies_as_bad = false;
+    proxy_info->bypass_duration = TimeDelta();
+    return true;
+  }
+
   return false;
 }
 
 bool HasDataReductionProxyViaHeader(const net::HttpResponseHeaders* headers,
                                     bool* has_intermediary) {
   const size_t kVersionSize = 4;
   const char kDataReductionProxyViaValue[] = "Chrome-Compression-Proxy";
   size_t value_len = strlen(kDataReductionProxyViaValue);
   void* iter = NULL;
   std::string value;
@@ skipping 26 matching lines @@
   return false;
 }
 
 DataReductionProxyBypassType GetDataReductionProxyBypassType(
     const net::HttpResponseHeaders* headers,
     DataReductionProxyInfo* data_reduction_proxy_info) {
   DCHECK(data_reduction_proxy_info);
   if (ParseHeadersAndSetProxyInfo(headers, data_reduction_proxy_info)) {
     // A chrome-proxy response header is only present in a 502. For proper
     // reporting, this check must come before the 5xx checks below.
+    if (!data_reduction_proxy_info->mark_proxies_as_bad)
+      return BYPASS_EVENT_TYPE_CURRENT;
+
     const TimeDelta& duration = data_reduction_proxy_info->bypass_duration;
-    // bypass=0 means bypass for a random duration between 1 to 5 minutes
-    if (duration == TimeDelta())
-      return BYPASS_EVENT_TYPE_MEDIUM;
     if (duration <= TimeDelta::FromSeconds(kShortBypassMaxSeconds))
       return BYPASS_EVENT_TYPE_SHORT;
     if (duration <= TimeDelta::FromSeconds(kMediumBypassMaxSeconds))
       return BYPASS_EVENT_TYPE_MEDIUM;
     return BYPASS_EVENT_TYPE_LONG;
   }
+  data_reduction_proxy_info->mark_proxies_as_bad = true;

[bengr, 2014/08/12 20:57:11]

Please add a comment to explain why this gets set to true here.

[sclittle, 2014/08/12 21:24:43]

Done.

   data_reduction_proxy_info->bypass_duration = GetDefaultBypassDuration();
   // Fall back if a 500, 502 or 503 is returned.
   if (headers->response_code() == net::HTTP_INTERNAL_SERVER_ERROR)
     return BYPASS_EVENT_TYPE_STATUS_500_HTTP_INTERNAL_SERVER_ERROR;
   if (headers->response_code() == net::HTTP_BAD_GATEWAY)
     return BYPASS_EVENT_TYPE_STATUS_502_HTTP_BAD_GATEWAY;
   if (headers->response_code() == net::HTTP_SERVICE_UNAVAILABLE)
     return BYPASS_EVENT_TYPE_STATUS_503_HTTP_SERVICE_UNAVAILABLE;
   // TODO(kundaji): Bypass if Proxy-Authenticate header value cannot be
   // interpreted by data reduction proxy.
@@ skipping 72 matching lines @@
           value.begin() + chrome_proxy_fingerprint_prefix.size(),
           chrome_proxy_fingerprint_prefix.c_str())) {
         continue;
       }
     }
     values->push_back(value);
   }
 }
 
 }  // namespace data_reduction_proxy