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 BadEntropyProvider : public base::FieldTrial::EntropyProvider {
+ public:
+  ~BadEntropyProvider() override {}

[bengr, 2015/02/11 23:57:28]

Move close curly to new line.

[tbansal1, 2015/02/12 02:27:22]

I don't understand the comment.

[bengr, 2015/02/12 17:14:46]

I mean, style afaik is to do:
~BadEntopyProvider() override {
}

[tbansal1, 2015/02/13 17:10:39]

Not sure, see:
https://code.google.com/p/chromium/codesearch#search/&q=override%5C%20%7B%7D%...

Anyways, I copied this from data_reduction_proxy_bypass_protocol.cc, I can
change there too if you prefer.

+
+  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 385 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;
+    bool enable_quic_field_trial;
+  } tests[]  = {
+      {
+          false,

[bengr, 2015/02/11 23:57:28]

Indentation is off.  See other examples in our tests.

[tbansal1, 2015/02/12 02:27:22]

Done.

+          false,
+      },
+      {
+          false,
+          true,
+      },
+      {
+          true,
+          false,
+      },
+      {
+          true,
+          true,
+      },
+  };
+
+  for (size_t i = 0; i < arraysize(tests); ++i) {
+    // 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_,
+        request_context.get(),
+        &net_log_,
+        event_store_.get());
+
+    base::FieldTrialList field_trial_list(new BadEntropyProvider());
+    if (tests[i].enable_quic_field_trial){
+      base::FieldTrialList::CreateFieldTrial("DataReductionProxyUseQuic",
+                                             "Enabled");
+    } else {
+      base::FieldTrialList::CreateFieldTrial("DataReductionProxyUseQuic",
+                                             "Disabled");
+    }
+    settings_->EnableQUIC(tests[i].enable_quic);
+
+    settings_->SetOnDataReductionEnabledCallback(
+        base::Bind(&DataReductionProxySettingsTestBase::
+                   RegisterSyntheticFieldTrialCallback,
+                   base::Unretained(this)));
+
+    EXPECT_EQ(tests[i].enable_quic_field_trial,
+              settings->params()->IsIncludedInUseQUICFieldTrial()) << i;
+    EXPECT_EQ(tests[i].enable_quic && tests[i].enable_quic_field_trial,
+              settings->params()->origin().is_quic()) << i;
+
+    base::MessageLoop::current()->RunUntilIdle();

[bengr, 2015/02/11 23:57:28]

This can be part of the test harness.

[tbansal1, 2015/02/12 02:27:22]

removed since it was not useful for this test.

+  }
+}
+
 }  // namespace data_reduction_proxy