Modify data_reduction_proxy_header to support tamper detection logic.

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/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 data_reduction_proxy {
 
 const char* kDataReductionProxyViaValues[] = {"Chrome-Compression-Proxy",
                                               "Chrome Compression Proxy"};
 
+bool GetDataReductionProxyActionValue(
+    const net::HttpResponseHeaders* headers,
+    const std::string& action_prefix,
+    std::string* action_value) {
+  DCHECK(action_prefix.size());
+  void* iter = NULL;
+  std::string value;
+  std::string name = "chrome-proxy";
+
+  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()) &&
+          value[action_prefix.size()] == '=') {
+        if (action_value)
+          *action_value = value.substr(action_prefix.size() + 1);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 bool GetDataReductionProxyBypassDuration(

[bolian, 2014/07/14 22:42:43]

why doesn't this one call GetDataReductionProxyActionValue?

[xingx, 2014/07/14 22:51:08]

Need to discuss with Ben: my function (above) returns the first matched string;
his function (below) returns the first matched, integer-convertable string.

     const net::HttpResponseHeaders* headers,
     const std::string& action_prefix,
     base::TimeDelta* duration) {
+  DCHECK(action_prefix.size());
   void* iter = NULL;
   std::string value;
   std::string name = "chrome-proxy";
 
   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())) {
+                               action_prefix.c_str()) &&
+          value[action_prefix.size()] == '=') {
         int64 seconds;
         if (!base::StringToInt64(
-                StringPiece(value.begin() + action_prefix.size(), value.end()),
+                StringPiece(value.begin() + action_prefix.size() + 1,
+                            value.end()),
                 &seconds) || seconds < 0) {
           continue;  // In case there is a well formed instruction.
         }
         *duration = TimeDelta::FromSeconds(seconds);
         return true;
       }
     }
   }
   return false;
 }
 
 bool GetDataReductionProxyInfo(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(
-      headers, "block=", &proxy_info->bypass_duration)) {
+      headers, "block", &proxy_info->bypass_duration)) {
     proxy_info->bypass_all = true;
     return true;
   }
 
   // Next, look for 'bypass'.
   if (GetDataReductionProxyBypassDuration(
-      headers, "bypass=", &proxy_info->bypass_duration)) {
+      headers, "bypass", &proxy_info->bypass_duration)) {
     return true;
   }
   return false;
 }
 
 bool HasDataReductionProxyViaHeader(const net::HttpResponseHeaders* headers) {
   const size_t kVersionSize = 4;
   size_t value_len = strlen(kDataReductionProxyViaValues[0]);
   void* iter = NULL;
   std::string value;
@@ skipping 50 matching lines @@
         headers->response_code() < net::HTTP_INTERNAL_SERVER_ERROR) {
       return ProxyService::PROXY_4XX_BYPASS;
     }
     return ProxyService::MISSING_VIA_HEADER;
   }
   // There is no bypass event.
   return ProxyService::BYPASS_EVENT_TYPE_MAX;
 }
 
 }  // namespace data_reduction_proxy