Independently enable SPDY versions from field trial.

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 19 matching lines @@
  public:
   static void ConfigureQuicGlobals(
       const base::CommandLine& command_line,
       base::StringPiece quic_trial_group,
       const std::map<std::string, std::string>& quic_trial_params,
       IOThread::Globals* globals) {
     IOThread::ConfigureQuicGlobals(command_line, quic_trial_group,
                                    quic_trial_params, 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);
   }
-
-  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) {
     globals_.http_server_properties.reset(new net::HttpServerPropertiesImpl());
   }
 
   void ConfigureQuicGlobals() {
     IOThreadPeer::ConfigureQuicGlobals(command_line_, field_trial_group_,
                                        field_trial_params_, &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_;
   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);
   EXPECT_EQ(globals_.quic_connection_options,
             params.quic_connection_options);
 }
 
 TEST_F(IOThreadTest, SpdyFieldTrialHoldbackEnabled) {
   net::HttpStreamFactory::set_spdy_enabled(true);
-  IOThreadPeer::ConfigureSpdyFromTrial("SpdyDisabled", &globals_);
+  field_trial_group_ = "SpdyDisabled";
+  ConfigureSpdyGlobals();
   EXPECT_FALSE(net::HttpStreamFactory::spdy_enabled());
 }
 
 TEST_F(IOThreadTest, SpdyFieldTrialSpdy31Enabled) {
   bool use_alternate_protocols = false;
-  IOThreadPeer::ConfigureSpdyFromTrial("Spdy31Enabled", &globals_);
+  field_trial_group_ = "Spdy31Enabled";
+  ConfigureSpdyGlobals();
   EXPECT_THAT(globals_.next_protos,
               ElementsAre(net::kProtoHTTP11,
-                          net::kProtoQUIC1SPDY3,
                           net::kProtoSPDY31));
   globals_.use_alternate_protocols.CopyToIfSet(&use_alternate_protocols);
   EXPECT_TRUE(use_alternate_protocols);
 }
 
 TEST_F(IOThreadTest, SpdyFieldTrialSpdy4Enabled) {
   bool use_alternate_protocols = false;
-  IOThreadPeer::ConfigureSpdyFromTrial("Spdy4Enabled", &globals_);
-  EXPECT_THAT(
-      globals_.next_protos,
-      ElementsAre(net::kProtoHTTP11, net::kProtoQUIC1SPDY3, net::kProtoSPDY31,
-                  net::kProtoSPDY4_14, net::kProtoSPDY4));
+  field_trial_group_ = "Spdy4Enabled";
+  ConfigureSpdyGlobals();
+  EXPECT_THAT(globals_.next_protos,
+              ElementsAre(net::kProtoHTTP11, net::kProtoSPDY31,
+                          net::kProtoSPDY4_14, net::kProtoSPDY4));
   globals_.use_alternate_protocols.CopyToIfSet(&use_alternate_protocols);
   EXPECT_TRUE(use_alternate_protocols);
 }
 
+TEST_F(IOThreadTest, SpdyFieldTrialDefault) {
+  field_trial_group_ = "";
+  ConfigureSpdyGlobals();
+  EXPECT_THAT(globals_.next_protos,
+              ElementsAre(net::kProtoHTTP11, net::kProtoSPDY31,
+                          net::kProtoSPDY4_14, net::kProtoSPDY4));
+  bool use_alternate_protocols = false;
+  globals_.use_alternate_protocols.CopyToIfSet(&use_alternate_protocols);
+  EXPECT_TRUE(use_alternate_protocols);
+}
+
+TEST_F(IOThreadTest, SpdyFieldTrialParametrized) {
+  field_trial_params_["enable_spdy31"] = "false";
+  // Undefined parameter "h2_14_enabled" should default to false.
+  field_trial_params_["h2_enabled"] = "true";
+  field_trial_group_ = "ParametrizedHTTP2Only";
+  ConfigureSpdyGlobals();
+  EXPECT_THAT(globals_.next_protos,
+              ElementsAre(net::kProtoHTTP11, net::kProtoSPDY4));
+  bool use_alternate_protocols = false;
+  globals_.use_alternate_protocols.CopyToIfSet(&use_alternate_protocols);
+  EXPECT_TRUE(use_alternate_protocols);
+}
+
+TEST_F(IOThreadTest, SpdyCommandLineEnable) {
+  command_line_.AppendSwitch("enable-spdy4");
+  // Command line should overwrite field trial group.
+  field_trial_group_ = "SpdyDisabled";
+  ConfigureSpdyGlobals();
+  EXPECT_THAT(globals_.next_protos,
+              ElementsAre(net::kProtoHTTP11, net::kProtoSPDY31,
+                          net::kProtoSPDY4_14, net::kProtoSPDY4));
+  bool use_alternate_protocols = false;
+  globals_.use_alternate_protocols.CopyToIfSet(&use_alternate_protocols);
+  EXPECT_TRUE(use_alternate_protocols);
+}
+
+TEST_F(IOThreadTest, SpdyCommandLineDisable) {
+  command_line_.AppendSwitch("enable-npn-http");
+  // Command line should overwrite field trial group.
+  field_trial_group_ = "Spdy4Enabled";
+  ConfigureSpdyGlobals();
+  EXPECT_THAT(globals_.next_protos, ElementsAre(net::kProtoHTTP11));
+  bool use_alternate_protocols = true;
+  globals_.use_alternate_protocols.CopyToIfSet(&use_alternate_protocols);
+  EXPECT_FALSE(use_alternate_protocols);
+}
+
+TEST_F(IOThreadTest, SpdyCommandLineUseSpdyOff) {
+  command_line_.AppendSwitchASCII("use-spdy", "off");
+  // Command line should overwrite field trial group.
+  field_trial_group_ = "Spdy4Enabled";
+  ConfigureSpdyGlobals();
+  EXPECT_EQ(0u, globals_.next_protos.size());
+}
+
+TEST_F(IOThreadTest, SpdyCommandLineUseSpdySSL) {
+  command_line_.AppendSwitchASCII("use-spdy", "ssl");
+  // Command line should overwrite field trial group.
+  field_trial_group_ = "SpdyDisabled";
+  ConfigureSpdyGlobals();
+  bool force_spdy_over_ssl = false;
+  globals_.force_spdy_over_ssl.CopyToIfSet(&force_spdy_over_ssl);
+  EXPECT_TRUE(force_spdy_over_ssl);
+  bool force_spdy_always = false;
+  globals_.force_spdy_always.CopyToIfSet(&force_spdy_always);
+  EXPECT_TRUE(force_spdy_always);
+}
+
+TEST_F(IOThreadTest, SpdyCommandLineUseSpdyDisableAltProtocols) {
+  command_line_.AppendSwitchASCII("use-spdy", "no-alt-protocols");
+  ConfigureSpdyGlobals();
+  bool use_alternate_protocols = true;
+  globals_.use_alternate_protocols.CopyToIfSet(&use_alternate_protocols);
+  EXPECT_FALSE(use_alternate_protocols);
+}
+
 TEST_F(IOThreadTest, DisableQuicByDefault) {
   ConfigureQuicGlobals();
   net::HttpNetworkSession::Params params;
   InitializeNetworkSessionParams(&params);
   EXPECT_FALSE(params.enable_quic);
   EXPECT_FALSE(params.enable_quic_for_proxies);
   EXPECT_FALSE(IOThread::ShouldEnableQuicForDataReductionProxy());
 }
 
 TEST_F(IOThreadTest, EnableQuicFromFieldTrialGroup) {
@@ skipping 240 matching lines @@
   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);
 }
 
 }  // namespace test