Add data reduction functionality to all platforms.

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 "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"
 #include "net/proxy/proxy_service.h"
 
 using base::StringPiece;
 using base::TimeDelta;
 using net::ProxyService;
 
+namespace {
+
+// 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 anonymous

[Ryan Sleevi, 2014/07/22 08:22:24]

1) line break after this
2) It's not // namespace anonymous. Just omit the comment.

[Not at Google. Contact bengr, 2014/07/22 23:03:53]

Done.

 namespace data_reduction_proxy {
 
-bool GetDataReductionProxyBypassDuration(
+bool ParseHeadersAndSetBypassDuration(
     const net::HttpResponseHeaders* headers,
     const std::string& action_prefix,
-    base::TimeDelta* duration) {
+    base::TimeDelta* bypass_duration) {
   void* iter = NULL;
   std::string value;
   std::string name = "chrome-proxy";

[Ryan Sleevi, 2014/07/22 08:22:24]

You're adding a new header into the exposed web platform. That it's already on
mobile is an unfortunate thing, but we shouldn't be doing it in Chrome just
because.

[bengr, 2014/07/22 19:57:15]

This isn't going to change, even for desktop. We've been through this one a lot
of times. The data reduction proxy is different from a standard proxy because it
can send additional instructions along with a response. For example, it can tell
the client to bypass it for 17 seconds. Eventually we may be able to standardize
this functionality, but not now.

 
   while (headers->EnumerateHeader(&iter, name, &value)) {
     if (value.size() > action_prefix.size()) {
       if (LowerCaseEqualsASCII(value.begin(),
                                value.begin() + action_prefix.size(),
                                action_prefix.c_str())) {
         int64 seconds;
         if (!base::StringToInt64(
                 StringPiece(value.begin() + action_prefix.size(), value.end()),
                 &seconds) || seconds < 0) {
           continue;  // In case there is a well formed instruction.
         }
-        *duration = TimeDelta::FromSeconds(seconds);
+        if (seconds != 0) {
+          *bypass_duration = TimeDelta::FromSeconds(seconds);
+        } else {
+          // Server deferred to us to choose a duration. Default to a random
+          // duration between one and five minutes.
+          *bypass_duration = GetDefaultBypassDuration();
+        }
         return true;
       }
     }
   }
   return false;
 }
 
-bool GetDataReductionProxyInfo(const net::HttpResponseHeaders* headers,
-                               DataReductionProxyInfo* proxy_info) {
+bool ParseHeadersAndSetProxyInfo(const net::HttpResponseHeaders* headers,
+                                 DataReductionProxyInfo* proxy_info) {
   DCHECK(proxy_info);
   proxy_info->bypass_all = false;
-  proxy_info->bypass_duration = TimeDelta();
+
   // 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.
   // TODO(bengr): Reduce checks for 'block' and 'bypass' to a single loop.
-  if (GetDataReductionProxyBypassDuration(
+  if (ParseHeadersAndSetBypassDuration(
       headers, "block=", &proxy_info->bypass_duration)) {
     proxy_info->bypass_all = true;
     return true;
   }
 
   // Next, look for 'bypass'.
-  if (GetDataReductionProxyBypassDuration(
+  if (ParseHeadersAndSetBypassDuration(
       headers, "bypass=", &proxy_info->bypass_duration)) {
     return true;
   }
   return false;
 }
 
 bool HasDataReductionProxyViaHeader(const net::HttpResponseHeaders* headers) {
   const size_t kVersionSize = 4;
   const char kDataReductionProxyViaValue[] = "Chrome-Compression-Proxy";
   size_t value_len = strlen(kDataReductionProxyViaValue);
@@ skipping 15 matching lines @@
   iter = NULL;
   while (headers->EnumerateHeader(&iter, "via", &value))
     if (value == kDeprecatedDataReductionProxyViaValue)
       return true;
 
   return false;
 }
 
 const int kShortBypassMaxSeconds = 59;
 const int kMediumBypassMaxSeconds = 300;
 net::ProxyService::DataReductionProxyBypassType

[Ryan Sleevi, 2014/07/22 08:22:24]

1) linebreak between these constants.
2) Follow
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Declar...
3) function-level or unnamed namespace level. These are inviting ODR violations
because they're neither.

[Not at Google. Contact bengr, 2014/07/22 23:03:53]

Moved constants to top in anonymous namespace.

 GetDataReductionProxyBypassType(
     const net::HttpResponseHeaders* headers,
     DataReductionProxyInfo* data_reduction_proxy_info) {
   DCHECK(data_reduction_proxy_info);
-  if (GetDataReductionProxyInfo(headers, 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.
     const TimeDelta& duration = data_reduction_proxy_info->bypass_duration;
     if (duration <= TimeDelta::FromSeconds(kShortBypassMaxSeconds))
       return ProxyService::SHORT_BYPASS;
     if (duration <= TimeDelta::FromSeconds(kMediumBypassMaxSeconds))
       return ProxyService::MEDIUM_BYPASS;
     return ProxyService::LONG_BYPASS;
   }
+
   // Fall back if a 500, 502 or 503 is returned.
-  if (headers->response_code() == net::HTTP_INTERNAL_SERVER_ERROR)
-    return ProxyService::STATUS_500_HTTP_INTERNAL_SERVER_ERROR;
-  if (headers->response_code() == net::HTTP_BAD_GATEWAY)
-    return ProxyService::STATUS_502_HTTP_BAD_GATEWAY;
-  if (headers->response_code() == net::HTTP_SERVICE_UNAVAILABLE)
-    return ProxyService::STATUS_503_HTTP_SERVICE_UNAVAILABLE;
+  if (headers->response_code() == net::HTTP_INTERNAL_SERVER_ERROR ||
+      headers->response_code() == net::HTTP_BAD_GATEWAY ||
+      headers->response_code() == net::HTTP_SERVICE_UNAVAILABLE) {
+    data_reduction_proxy_info->bypass_duration = GetDefaultBypassDuration();
+
+    if (headers->response_code() == net::HTTP_INTERNAL_SERVER_ERROR)
+      return ProxyService::STATUS_500_HTTP_INTERNAL_SERVER_ERROR;
+    if (headers->response_code() == net::HTTP_BAD_GATEWAY)
+      return ProxyService::STATUS_502_HTTP_BAD_GATEWAY;
+    if (headers->response_code() == net::HTTP_SERVICE_UNAVAILABLE)
+      return ProxyService::STATUS_503_HTTP_SERVICE_UNAVAILABLE;
+  }
+
   // TODO(kundaji): Bypass if Proxy-Authenticate header value cannot be
   // interpreted by data reduction proxy.
   if (headers->response_code() == net::HTTP_PROXY_AUTHENTICATION_REQUIRED &&
       !headers->HasHeader("Proxy-Authenticate")) {
+    data_reduction_proxy_info->bypass_duration = GetDefaultBypassDuration();
     return ProxyService::MALFORMED_407;
   }
   if (!HasDataReductionProxyViaHeader(headers) &&
       (headers->response_code() != net::HTTP_NOT_MODIFIED)) {
+    data_reduction_proxy_info->bypass_duration = GetDefaultBypassDuration();
     // A Via header might not be present in a 304. Since the goal of a 304
     // response is to minimize information transfer, a sender in general
     // should not generate representation metadata other than Cache-Control,
     // Content-Location, Date, ETag, Expires, and Vary.
 
     // The proxy Via header might also not be present in a 4xx response.
     // Separate this case from other responses that are missing the header.
     if (headers->response_code() >= net::HTTP_BAD_REQUEST &&
         headers->response_code() < net::HTTP_INTERNAL_SERVER_ERROR) {
       return ProxyService::MISSING_VIA_HEADER_4XX;
     }
     return ProxyService::MISSING_VIA_HEADER_OTHER;
   }
   // There is no bypass event.
   return ProxyService::BYPASS_EVENT_TYPE_MAX;
 }
 
 }  // namespace data_reduction_proxy