Add Finch experiment for selectively bypassing proxies.

components/data_reduction_proxy/browser/data_reduction_proxy_protocol.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_protocol.h"
 
 #include "base/memory/ref_counted.h"
 #include "base/time/time.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_params.h"
 #include "components/data_reduction_proxy/common/data_reduction_proxy_headers.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_list.h"
 #include "net/proxy/proxy_server.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "url/gurl.h"
 
 namespace {
+
 bool SetProxyServerFromGURL(const GURL& gurl,
                             net::ProxyServer* proxy_server) {
   DCHECK(proxy_server);
   if (!gurl.SchemeIsHTTPOrHTTPS())
     return false;
   *proxy_server = net::ProxyServer(gurl.SchemeIs("http") ?
                                        net::ProxyServer::SCHEME_HTTP :
                                        net::ProxyServer::SCHEME_HTTPS,
                                    net::HostPortPair::FromURL(gurl));
   return true;
 }
+
 }  // namespace
 
 namespace data_reduction_proxy {
 
 bool MaybeBypassProxyAndPrepareToRetry(
     const DataReductionProxyParams* data_reduction_proxy_params,
     net::URLRequest* request,
     const net::HttpResponseHeaders* original_response_headers,
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers) {
   if (!data_reduction_proxy_params)
@@ skipping 35 matching lines @@
   // Only retry idempotent methods.
   if (!IsRequestIdempotent(request))
     return false;
 
   OverrideResponseAsRedirect(request,
                              original_response_headers,
                              override_response_headers);
   return true;
 }
 
-
+void OnResolveProxyHandler(const GURL& url,
+                           int load_flags,
+                           const DataReductionProxyParams* params,
+                           net::ProxyInfo* result) {
+  if ((load_flags & net::LOAD_BYPASS_DATA_REDUCTION_PROXY) &&
+      DataReductionProxyParams::IsIncludedInCriticalPathBypassFieldTrial() &&
+      !result->is_empty() &&
+      !result->is_direct() &&
+      params &&
+      params->IsDataReductionProxy(
+          result->proxy_server().host_port_pair(), NULL)) {
+    result->UseDirect();
+  }
+}
 
 bool IsRequestIdempotent(const net::URLRequest* request) {
   DCHECK(request);
   if (request->method() == "GET" ||
       request->method() == "OPTIONS" ||
       request->method() == "HEAD" ||
       request->method() == "PUT" ||
       request->method() == "DELETE" ||
       request->method() == "TRACE")
     return true;
@@ skipping 47 matching lines @@
   net::ProxyService* proxy_service = request->context()->proxy_service();
   DCHECK(proxy_service);
 
   proxy_service->MarkProxiesAsBadUntil(proxy_info,
                                        bypass_duration,
                                        fallback,
                                        request->net_log());
 }
 
 }  // namespace data_reduction_proxy