Enable QUIC for proxies based on Finch config and command line switch.

components/data_reduction_proxy/core/browser/data_reduction_proxy_settings_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/core/browser/data_reduction_proxy_settings.h"
 
 #include "base/command_line.h"
 #include "base/md5.h"
 #include "base/message_loop/message_loop.h"
+#include "base/metrics/field_trial.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_simple_task_runner.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_configurator_test_utils.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_settings_test_utils.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_params.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_pref_names.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_switches.h"
 #include "net/http/http_auth.h"
 #include "net/http/http_auth_cache.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char kProbeURLWithOKResponse[] = "http://ok.org/";
 const char kProbeURLWithBadResponse[] = "http://bad.org/";
 const char kProbeURLWithNoResponse[] = "http://no.org/";
 
 }  // namespace
 
 namespace data_reduction_proxy {
 
 class DataReductionProxyStatisticsPrefs;
 
+class BadEntropyProvider : public base::FieldTrial::EntropyProvider {
+ public:
+  ~BadEntropyProvider() override {}
+
+  double GetEntropyForTrial(const std::string& trial_name,
+                            uint32 randomization_seed) const override {
+    return 0.5;
+  }
+};
+
 class DataReductionProxySettingsTest
     : public ConcreteDataReductionProxySettingsTest<
           DataReductionProxySettings> {
 };
 
 TEST_F(DataReductionProxySettingsTest, TestGetDataReductionProxyOrigin) {
   // SetUp() adds the origin to the command line, which should be returned here.
   std::string result =
       settings_->params()->origin().ToURI();
   EXPECT_EQ(expected_params_->DefaultOrigin(), result);
@@ skipping 386 matching lines @@
       &net_log_,
       event_store_.get());
   settings_->SetOnDataReductionEnabledCallback(
       base::Bind(&DataReductionProxySettingsTestBase::
                  RegisterSyntheticFieldTrialCallback,
                  base::Unretained(this)));
 
   base::MessageLoop::current()->RunUntilIdle();
 }
 
+TEST_F(DataReductionProxySettingsTest, CheckQUICFieldTrials) {
+  const struct {
+    bool enable_quic;
+  } tests[]  = {
+    {
+      false,
+    },
+    {
+      true,
+    },
+  };
+
+  for (size_t i = 0; i < arraysize(tests); ++i) {

[Ryan Hamilton, 2015/02/14 00:09:23]

nit: Your call but consider writing this as:

for (int i = 0; i < 2; ++i) {
  bool enable_quic = i == 0;
  ...
}

It's a lot fewer lines.

[tbansal1, 2015/02/14 01:06:11]

Good suggestion, done.

+    // No call to |AddProxyToCommandLine()| was made, so the proxy feature
+    // should be unavailable.
+    base::MessageLoopForUI loop;
+    // Clear the command line. Setting flags can force the proxy to be allowed.
+    base::CommandLine::ForCurrentProcess()->InitFromArgv(0, NULL);
+
+    ResetSettings(false, false, false, false, false);
+    MockSettings* settings = static_cast<MockSettings*>(settings_.get());
+    EXPECT_FALSE(settings->params()->allowed());
+    EXPECT_CALL(*settings, RecordStartupState(PROXY_NOT_AVAILABLE));
+
+    scoped_ptr<DataReductionProxyConfigurator> configurator(
+        new TestDataReductionProxyConfigurator(
+            scoped_refptr<base::TestSimpleTaskRunner>(
+                new base::TestSimpleTaskRunner()),
+                &net_log_, event_store_.get()));
+    settings_->SetProxyConfigurator(configurator.get());
+    scoped_refptr<net::TestURLRequestContextGetter> request_context =
+        new net::TestURLRequestContextGetter(base::MessageLoopProxy::current());
+
+    settings_->InitDataReductionProxySettings(
+         &pref_service_,
+         scoped_ptr<DataReductionProxyStatisticsPrefs>(),
+         request_context.get(),
+         &net_log_,
+         event_store_.get());
+
+    base::FieldTrialList field_trial_list(new BadEntropyProvider());
+    if (tests[i].enable_quic){
+      base::FieldTrialList::CreateFieldTrial(
+          DataReductionProxyParams::GetQuicFieldTrialName(),
+          "Enabled");
+    } else {
+      base::FieldTrialList::CreateFieldTrial(
+          DataReductionProxyParams::GetQuicFieldTrialName(),
+          "Disabled");
+    }
+    settings_->params()->EnableQuic(tests[i].enable_quic);
+
+    settings_->SetOnDataReductionEnabledCallback(
+        base::Bind(&DataReductionProxySettingsTestBase::
+                   RegisterSyntheticFieldTrialCallback,
+                   base::Unretained(this)));
+
+    EXPECT_EQ(tests[i].enable_quic,
+              settings->params()->origin().is_quic()) << i;
+  }
+}
+
 }  // namespace data_reduction_proxy