Add Finch experiment for selectively bypassing proxies.

components/data_reduction_proxy/browser/data_reduction_proxy_protocol_unittest.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 <utility>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_params_test_utils.h"
 #include "net/base/completion_callback.h"
 #include "net/base/host_port_pair.h"
+#include "net/base/load_flags.h"
 #include "net/base/network_delegate.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_transaction_test_util.h"
+#include "net/proxy/proxy_service.h"
 #include "net/socket/socket_test_util.h"
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::HttpResponseHeaders;
 using net::HostPortPair;
 using net::MockRead;
@@ skipping 575 matching lines @@
 
    EXPECT_EQ(net::URLRequestStatus::SUCCESS, r.status().status());
    EXPECT_EQ(net::OK, r.status().error());
 
   EXPECT_EQ("Bypass message", d.data_received());
 
   // We should have no entries in our bad proxy list.
   TestBadProxies(0, -1, "", "");
 }
 
+class BadEntropyProvider : public base::FieldTrial::EntropyProvider {
+ public:
+  virtual ~BadEntropyProvider() {}
+
+  virtual double GetEntropyForTrial(const std::string& trial_name,
+                                    uint32 randomization_seed) const OVERRIDE {
+    return 0.5;
+  }
+};
+
+TEST_F(DataReductionProxyProtocolTest, OnResolveProxyHandler) {
+  int load_flags = 0;
+  GURL url("http://www.google.com/");
+
+  // Data reduction proxy
+  ProxyInfo info1;
+  data_reduction_proxy.UseNamedProxy("proxy.googlezip.net:443");
+
+  // Other proxy
+  ProxyInfo info2;
+  data_reduction_proxy.UseNamedProxy("proxy.com");
+
+  // Without DataCompressionProxyCriticalBypass Finch trial set, should never
+  // bypass.
+  OnResolveProxyHandler(url, load_flags, &info1);
+  EXPECT_FALSE(info1.is_direct());
+  EXPECT_FALSE(info1.did_bypass_proxy());
+
+  OnResolveProxyHandler(url, load_flags, &info2);
+  EXPECT_FALSE(info2.is_direct());
+  EXPECT_FALSE(info2.did_bypass_proxy());
+
+  load_flags |= net::LOAD_BYPASS_DATA_REDUCTION_PROXY;
+
+  OnResolveProxyHandler(url, load_flags, &info1);
+  EXPECT_FALSE(info1.is_direct());
+  EXPECT_FALSE(info1.did_bypass_proxy());
+
+  OnResolveProxyHandler(url, load_flags, &info2);
+  EXPECT_FALSE(info2.is_direct());
+  EXPECT_FALSE(info2.did_bypass_proxy());
+
+  // With Finch trial set, should only bypass if LOAD flag is set and the
+  // effective proxy is the data compression proxy.
+  base::FieldTrialList field_trial_list(new BadEntropyProvider());
+  ASSERT_TRUE(base::FieldTrialList::CreateTrialsFromString(
+              "DataCompressionProxyCriticalBypass/Enabled/",
+              base::FieldTrialList::ACTIVATE_TRIALS,
+              std::set<std::string>()));
+
+  load_flags = 0;
+
+  OnResolveProxyHandler(url, load_flags, &info1);
+  EXPECT_FALSE(info1.is_direct());
+  EXPECT_FALSE(info1.did_bypass_proxy());
+
+  OnResolveProxyHandler(url, load_flags, &info2);
+  EXPECT_FALSE(info2.is_direct());
+  EXPECT_FALSE(info2.did_bypass_proxy());
+
+  load_flags |= net::LOAD_BYPASS_DATA_REDUCTION_PROXY;
+
+  OnResolveProxyHandler(url, load_flags, &info2);
+  EXPECT_FALSE(info2.is_direct());
+  EXPECT_FALSE(info2.did_bypass_proxy());
+
+  OnResolveProxyHandler(url, load_flags, &info1);
+  EXPECT_TRUE(info1.is_direct());
+  EXPECT_TRUE(info1.did_bypass_proxy());
+}
+
 }  // namespace data_reduction_proxy