Created policy QuicAllowed

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 "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"
@@ skipping 14 matching lines @@
     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 InitializeNetworkSessionParamsFromGlobals(
       const IOThread::Globals& globals,
       net::HttpNetworkSession::Params* params) {
     IOThread::InitializeNetworkSessionParamsFromGlobals(globals, params);
   }
 
   static void ConfigureSpdyFromTrial(const std::string& trial_group,
                                      IOThread::Globals* globals) {
     IOThread::ConfigureSpdyFromTrial(trial_group, globals);
   }
 };
 
 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) {

[Ryan Hamilton, 2015/03/20 18:21:58]

Can you wrap the : command_line_(...) onto the next line, and line up
"is_quic.." with "command_line" (not with the ":", but with the "c")

[peletskyi, 2015/03/23 10:03:18]

Done.

     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 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 281 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("enable-quic");
+  is_quic_allowed_by_policy_ = false;
+  ConfigureQuicGlobals();
+
+  net::HttpNetworkSession::Params params;
+  InitializeNetworkSessionParams(&params);
+  EXPECT_FALSE(params.enable_quic);
+}
+
 }  // namespace test