Added QuicAllowed policy. Added unit and browser tests.

chrome/browser/io_thread_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 "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "chrome/browser/io_thread.h"
+#include "chrome/common/chrome_switches.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_params.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/quic/quic_protocol.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace test {
 
 using ::testing::ElementsAre;
 
 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 IOThreadPeer {
  public:
   static void ConfigureQuicGlobals(
       const base::CommandLine& command_line,
       base::StringPiece quic_trial_group,
       const std::map<std::string, std::string>& quic_trial_params,
+      bool is_quic_allowed_by_policy,
       IOThread::Globals* globals) {
     IOThread::ConfigureQuicGlobals(command_line, quic_trial_group,
-                                   quic_trial_params, globals);
+                                   quic_trial_params, is_quic_allowed_by_policy,
+                                   globals);
   }
 
   static void ConfigureSpdyGlobals(
       const base::CommandLine& command_line,
       base::StringPiece spdy_trial_group,
       const std::map<std::string, std::string>& spdy_trial_params,
       IOThread::Globals* globals) {
     IOThread::ConfigureSpdyGlobals(command_line, spdy_trial_group,
                                    spdy_trial_params, globals);
   }
 
   static void InitializeNetworkSessionParamsFromGlobals(
       const IOThread::Globals& globals,
       net::HttpNetworkSession::Params* params) {
     IOThread::InitializeNetworkSessionParamsFromGlobals(globals, params);
   }
 };
 
 class IOThreadTest : public testing::Test {
  public:
-  IOThreadTest() : command_line_(base::CommandLine::NO_PROGRAM) {
+  IOThreadTest()
+      : command_line_(base::CommandLine::NO_PROGRAM),
+        is_quic_allowed_by_policy_(true) {
     globals_.http_server_properties.reset(new net::HttpServerPropertiesImpl());
   }
 
   void ConfigureQuicGlobals() {
-    IOThreadPeer::ConfigureQuicGlobals(command_line_, field_trial_group_,
-                                       field_trial_params_, &globals_);
+    IOThreadPeer::ConfigureQuicGlobals(command_line_,
+                                       field_trial_group_,
+                                       field_trial_params_,
+                                       is_quic_allowed_by_policy_,
+                                       &globals_);
   }
 
   void ConfigureSpdyGlobals() {
     IOThreadPeer::ConfigureSpdyGlobals(command_line_, field_trial_group_,
                                        field_trial_params_, &globals_);
   }
 
   void InitializeNetworkSessionParams(net::HttpNetworkSession::Params* params) {
     IOThreadPeer::InitializeNetworkSessionParamsFromGlobals(globals_, params);
   }
 
   base::CommandLine command_line_;
   IOThread::Globals globals_;
   std::string field_trial_group_;
+  bool is_quic_allowed_by_policy_;
   std::map<std::string, std::string> field_trial_params_;
 };
 
 TEST_F(IOThreadTest, InitializeNetworkSessionParamsFromGlobals) {
   globals_.quic_connection_options.push_back(net::kPACE);
   globals_.quic_connection_options.push_back(net::kTBBR);
   globals_.quic_connection_options.push_back(net::kTIME);
 
   net::HttpNetworkSession::Params params;
   InitializeNetworkSessionParams(&params);
@@ skipping 379 matching lines @@
        AlternateProtocolProbabilityThresholdFromParams) {
   field_trial_group_ = "Enabled";
   field_trial_params_["alternate_protocol_probability_threshold"] = ".5";
 
   ConfigureQuicGlobals();
   net::HttpNetworkSession::Params params;
   InitializeNetworkSessionParams(&params);
   EXPECT_EQ(.5, params.alternate_protocol_probability_threshold);
 }
 
+TEST_F(IOThreadTest, QuicDisallowedByPolicy) {
+  command_line_.AppendSwitch(switches::kEnableQuic);
+  is_quic_allowed_by_policy_ = false;
+  ConfigureQuicGlobals();
+
+  net::HttpNetworkSession::Params params;
+  InitializeNetworkSessionParams(&params);
+  EXPECT_FALSE(params.enable_quic);
+}
+
 }  // namespace test