chrome/browser/io_thread_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/command_line.h"
   6 #include "base/metrics/field_trial.h"
   7 #include "chrome/browser/io_thread.h"
   8 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_params.h"
   9 #include "net/http/http_network_session.h"
  10 #include "net/http/http_server_properties_impl.h"
  11 #include "net/quic/quic_protocol.h"
  12 #include "testing/gmock/include/gmock/gmock.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace test {
  16
  17 using ::testing::ElementsAre;
  18
  19 class BadEntropyProvider : public base::FieldTrial::EntropyProvider {
  20  public:
  21   ~BadEntropyProvider() override {}
  22
  23   double GetEntropyForTrial(const std::string& trial_name,
  24                             uint32 randomization_seed) const override {
  25     return 0.5;
  26   }
  27 };
  28
  29 class IOThreadPeer {
  30  public:
  31   static void ConfigureQuicGlobals(
  32       const base::CommandLine& command_line,
  33       base::StringPiece quic_trial_group,
  34       const std::map<std::string, std::string>& quic_trial_params,
  35       IOThread::Globals* globals) {
  36     IOThread::ConfigureQuicGlobals(command_line, quic_trial_group,
  37                                    quic_trial_params, globals);
  38   }
  39
  40   static void InitializeNetworkSessionParamsFromGlobals(
  41       const IOThread::Globals& globals,
  42       net::HttpNetworkSession::Params* params) {
  43     IOThread::InitializeNetworkSessionParamsFromGlobals(globals, params);
  44   }
  45
  46   static void ConfigureSpdyFromTrial(const std::string& trial_group,
  47                                      IOThread::Globals* globals) {
  48     IOThread::ConfigureSpdyFromTrial(trial_group, globals);
  49   }
  50 };
  51
  52 class IOThreadTest : public testing::Test {
  53  public:
  54   IOThreadTest() : command_line_(base::CommandLine::NO_PROGRAM) {
  55     globals_.http_server_properties.reset(new net::HttpServerPropertiesImpl());
  56   }
  57
  58   void ConfigureQuicGlobals() {
  59     IOThreadPeer::ConfigureQuicGlobals(command_line_, field_trial_group_,
  60                                        field_trial_params_, &globals_);
  61   }
  62
  63   void InitializeNetworkSessionParams(net::HttpNetworkSession::Params* params) {
  64     IOThreadPeer::InitializeNetworkSessionParamsFromGlobals(globals_, params);
  65   }
  66
  67   base::CommandLine command_line_;
  68   IOThread::Globals globals_;
  69   std::string field_trial_group_;
  70   std::map<std::string, std::string> field_trial_params_;
  71 };
  72
  73 TEST_F(IOThreadTest, InitializeNetworkSessionParamsFromGlobals) {
  74   globals_.quic_connection_options.push_back(net::kPACE);
  75   globals_.quic_connection_options.push_back(net::kTBBR);
  76   globals_.quic_connection_options.push_back(net::kTIME);
  77
  78   net::HttpNetworkSession::Params params;
  79   InitializeNetworkSessionParams(&params);
  80   EXPECT_EQ(globals_.quic_connection_options,
  81             params.quic_connection_options);
  82 }
  83
  84 TEST_F(IOThreadTest, SpdyFieldTrialHoldbackEnabled) {
  85   net::HttpStreamFactory::set_spdy_enabled(true);
  86   IOThreadPeer::ConfigureSpdyFromTrial("SpdyDisabled", &globals_);
  87   EXPECT_FALSE(net::HttpStreamFactory::spdy_enabled());
  88 }
  89
  90 TEST_F(IOThreadTest, SpdyFieldTrialHoldbackControl) {
  91   bool use_alternate_protocols = false;
  92   IOThreadPeer::ConfigureSpdyFromTrial("Control", &globals_);
  93   EXPECT_THAT(globals_.next_protos,
  94               ElementsAre(net::kProtoHTTP11,
  95                           net::kProtoQUIC1SPDY3,
  96                           net::kProtoSPDY31));
  97   globals_.use_alternate_protocols.CopyToIfSet(&use_alternate_protocols);
  98   EXPECT_TRUE(use_alternate_protocols);
  99 }
 100
 101 TEST_F(IOThreadTest, SpdyFieldTrialSpdy4Enabled) {
 102   bool use_alternate_protocols = false;
 103   IOThreadPeer::ConfigureSpdyFromTrial("Spdy4Enabled", &globals_);
 104   EXPECT_THAT(globals_.next_protos,
 105               ElementsAre(net::kProtoHTTP11,
 106                           net::kProtoQUIC1SPDY3,
 107                           net::kProtoSPDY31,
 108                           net::kProtoSPDY4_14));
 109   globals_.use_alternate_protocols.CopyToIfSet(&use_alternate_protocols);
 110   EXPECT_TRUE(use_alternate_protocols);
 111 }
 112
 113 TEST_F(IOThreadTest, SpdyFieldTrialSpdy4Control) {
 114   bool use_alternate_protocols = false;
 115   IOThreadPeer::ConfigureSpdyFromTrial("Spdy4Control", &globals_);
 116   EXPECT_THAT(globals_.next_protos,
 117               ElementsAre(net::kProtoHTTP11,
 118                           net::kProtoQUIC1SPDY3,
 119                           net::kProtoSPDY31));
 120   globals_.use_alternate_protocols.CopyToIfSet(&use_alternate_protocols);
 121   EXPECT_TRUE(use_alternate_protocols);
 122 }
 123
 124 TEST_F(IOThreadTest, DisableQuicByDefault) {
 125   ConfigureQuicGlobals();
 126   net::HttpNetworkSession::Params params;
 127   InitializeNetworkSessionParams(&params);
 128   EXPECT_FALSE(params.enable_quic);
 129   EXPECT_FALSE(params.enable_quic_for_proxies);
 130   EXPECT_FALSE(IOThread::ShouldEnableQuicForDataReductionProxy());
 131 }
 132
 133 TEST_F(IOThreadTest, EnableQuicFromFieldTrialGroup) {
 134   field_trial_group_ = "Enabled";
 135
 136   ConfigureQuicGlobals();
 137   net::HttpNetworkSession::Params default_params;
 138   net::HttpNetworkSession::Params params;
 139   InitializeNetworkSessionParams(&params);
 140   EXPECT_TRUE(params.enable_quic);
 141   EXPECT_TRUE(params.enable_quic_for_proxies);
 142   EXPECT_EQ(1350u, params.quic_max_packet_length);
 143   EXPECT_EQ(1.0, params.alternate_protocol_probability_threshold);
 144   EXPECT_EQ(default_params.quic_supported_versions,
 145             params.quic_supported_versions);
 146   EXPECT_EQ(net::QuicTagVector(), params.quic_connection_options);
 147   EXPECT_FALSE(params.quic_always_require_handshake_confirmation);
 148   EXPECT_FALSE(params.quic_disable_connection_pooling);
 149   EXPECT_EQ(0, params.quic_load_server_info_timeout_ms);
 150   EXPECT_EQ(0.0f, params.quic_load_server_info_timeout_srtt_multiplier);
 151   EXPECT_FALSE(params.quic_enable_truncated_connection_ids);
 152   EXPECT_FALSE(params.quic_enable_connection_racing);
 153   EXPECT_FALSE(params.quic_disable_disk_cache);
 154   EXPECT_FALSE(IOThread::ShouldEnableQuicForDataReductionProxy());
 155 }
 156
 157 TEST_F(IOThreadTest, EnableQuicFromQuicProxyFieldTrialGroup) {
 158   base::FieldTrialList field_trial_list(new BadEntropyProvider());
 159   base::FieldTrialList::CreateFieldTrial(
 160       data_reduction_proxy::DataReductionProxyParams::GetQuicFieldTrialName(),
 161       "Enabled");
 162
 163   ConfigureQuicGlobals();
 164   net::HttpNetworkSession::Params params;
 165   InitializeNetworkSessionParams(&params);
 166   EXPECT_FALSE(params.enable_quic);
 167   EXPECT_TRUE(params.enable_quic_for_proxies);
 168   EXPECT_TRUE(IOThread::ShouldEnableQuicForDataReductionProxy());
 169 }
 170
 171 TEST_F(IOThreadTest, EnableQuicFromCommandLine) {
 172   command_line_.AppendSwitch("enable-quic");
 173
 174   ConfigureQuicGlobals();
 175   net::HttpNetworkSession::Params params;
 176   InitializeNetworkSessionParams(&params);
 177   EXPECT_TRUE(params.enable_quic);
 178   EXPECT_TRUE(params.enable_quic_for_proxies);
 179   EXPECT_FALSE(IOThread::ShouldEnableQuicForDataReductionProxy());
 180 }
 181
 182 TEST_F(IOThreadTest, EnablePacingFromCommandLine) {
 183   command_line_.AppendSwitch("enable-quic");
 184   command_line_.AppendSwitch("enable-quic-pacing");
 185
 186   ConfigureQuicGlobals();
 187   net::HttpNetworkSession::Params params;
 188   InitializeNetworkSessionParams(&params);
 189   net::QuicTagVector options;
 190   options.push_back(net::kPACE);
 191   EXPECT_EQ(options, params.quic_connection_options);
 192 }
 193
 194 TEST_F(IOThreadTest, EnablePacingFromFieldTrialParams) {
 195   field_trial_group_ = "Enabled";
 196   field_trial_params_["enable_pacing"] = "true";
 197
 198   ConfigureQuicGlobals();
 199   net::HttpNetworkSession::Params params;
 200   InitializeNetworkSessionParams(&params);
 201   net::QuicTagVector options;
 202   options.push_back(net::kPACE);
 203   EXPECT_EQ(options, params.quic_connection_options);
 204 }
 205
 206 TEST_F(IOThreadTest, PacketLengthFromCommandLine) {
 207   command_line_.AppendSwitch("enable-quic");
 208   command_line_.AppendSwitchASCII("quic-max-packet-length", "1450");
 209
 210   ConfigureQuicGlobals();
 211   net::HttpNetworkSession::Params params;
 212   InitializeNetworkSessionParams(&params);
 213   EXPECT_EQ(1450u, params.quic_max_packet_length);
 214 }
 215
 216 TEST_F(IOThreadTest, PacketLengthFromFieldTrialParams) {
 217   field_trial_group_ = "Enabled";
 218   field_trial_params_["max_packet_length"] = "1450";
 219
 220   ConfigureQuicGlobals();
 221   net::HttpNetworkSession::Params params;
 222   InitializeNetworkSessionParams(&params);
 223   EXPECT_EQ(1450u, params.quic_max_packet_length);
 224 }
 225
 226 TEST_F(IOThreadTest, QuicVersionFromCommandLine) {
 227   command_line_.AppendSwitch("enable-quic");
 228   std::string version =
 229       net::QuicVersionToString(net::QuicSupportedVersions().back());
 230   command_line_.AppendSwitchASCII("quic-version", version);
 231
 232   ConfigureQuicGlobals();
 233   net::HttpNetworkSession::Params params;
 234   InitializeNetworkSessionParams(&params);
 235   net::QuicVersionVector supported_versions;
 236   supported_versions.push_back(net::QuicSupportedVersions().back());
 237   EXPECT_EQ(supported_versions, params.quic_supported_versions);
 238 }
 239
 240 TEST_F(IOThreadTest, QuicVersionFromFieldTrialParams) {
 241   field_trial_group_ = "Enabled";
 242   field_trial_params_["quic_version"] =
 243       net::QuicVersionToString(net::QuicSupportedVersions().back());
 244
 245   ConfigureQuicGlobals();
 246   net::HttpNetworkSession::Params params;
 247   InitializeNetworkSessionParams(&params);
 248   net::QuicVersionVector supported_versions;
 249   supported_versions.push_back(net::QuicSupportedVersions().back());
 250   EXPECT_EQ(supported_versions, params.quic_supported_versions);
 251 }
 252
 253 TEST_F(IOThreadTest, QuicConnectionOptionsFromCommandLine) {
 254   command_line_.AppendSwitch("enable-quic");
 255   command_line_.AppendSwitchASCII("quic-connection-options",
 256                                   "PACE,TIME,TBBR,REJ");
 257
 258   ConfigureQuicGlobals();
 259   net::HttpNetworkSession::Params params;
 260   InitializeNetworkSessionParams(&params);
 261
 262   net::QuicTagVector options;
 263   options.push_back(net::kPACE);
 264   options.push_back(net::kTIME);
 265   options.push_back(net::kTBBR);
 266   options.push_back(net::kREJ);
 267   EXPECT_EQ(options, params.quic_connection_options);
 268 }
 269
 270 TEST_F(IOThreadTest, QuicConnectionOptionsFromFieldTrialParams) {
 271   field_trial_group_ = "Enabled";
 272   field_trial_params_["connection_options"] = "PACE,TIME,TBBR,REJ";
 273
 274   ConfigureQuicGlobals();
 275   net::HttpNetworkSession::Params params;
 276   InitializeNetworkSessionParams(&params);
 277
 278   net::QuicTagVector options;
 279   options.push_back(net::kPACE);
 280   options.push_back(net::kTIME);
 281   options.push_back(net::kTBBR);
 282   options.push_back(net::kREJ);
 283   EXPECT_EQ(options, params.quic_connection_options);
 284 }
 285
 286 TEST_F(IOThreadTest,
 287        QuicAlwaysRequireHandshakeConfirmationFromFieldTrialParams) {
 288   field_trial_group_ = "Enabled";
 289   field_trial_params_["always_require_handshake_confirmation"] = "true";
 290   ConfigureQuicGlobals();
 291   net::HttpNetworkSession::Params params;
 292   InitializeNetworkSessionParams(&params);
 293   EXPECT_TRUE(params.quic_always_require_handshake_confirmation);
 294 }
 295
 296 TEST_F(IOThreadTest,
 297        QuicDisableConnectionPoolingFromFieldTrialParams) {
 298   field_trial_group_ = "Enabled";
 299   field_trial_params_["disable_connection_pooling"] = "true";
 300   ConfigureQuicGlobals();
 301   net::HttpNetworkSession::Params params;
 302   InitializeNetworkSessionParams(&params);
 303   EXPECT_TRUE(params.quic_disable_connection_pooling);
 304 }
 305
 306 TEST_F(IOThreadTest, QuicLoadServerInfoTimeoutFromFieldTrialParams) {
 307   field_trial_group_ = "Enabled";
 308   field_trial_params_["load_server_info_timeout"] = "50";
 309   ConfigureQuicGlobals();
 310   net::HttpNetworkSession::Params params;
 311   InitializeNetworkSessionParams(&params);
 312   EXPECT_EQ(50, params.quic_load_server_info_timeout_ms);
 313 }
 314
 315 TEST_F(IOThreadTest, QuicLoadServerInfoTimeToSmoothedRttFromFieldTrialParams) {
 316   field_trial_group_ = "Enabled";
 317   field_trial_params_["load_server_info_time_to_srtt"] = "0.5";
 318   ConfigureQuicGlobals();
 319   net::HttpNetworkSession::Params params;
 320   InitializeNetworkSessionParams(&params);
 321   EXPECT_EQ(0.5f, params.quic_load_server_info_timeout_srtt_multiplier);
 322 }
 323
 324 TEST_F(IOThreadTest, QuicEnableTruncatedConnectionIds) {
 325   field_trial_group_ = "Enabled";
 326   field_trial_params_["enable_truncated_connection_ids"] = "true";
 327   ConfigureQuicGlobals();
 328   net::HttpNetworkSession::Params params;
 329   InitializeNetworkSessionParams(&params);
 330   EXPECT_TRUE(params.quic_enable_truncated_connection_ids);
 331 }
 332
 333 TEST_F(IOThreadTest, QuicEnableConnectionRacing) {
 334   field_trial_group_ = "Enabled";
 335   field_trial_params_["enable_connection_racing"] = "true";
 336   ConfigureQuicGlobals();
 337   net::HttpNetworkSession::Params params;
 338   InitializeNetworkSessionParams(&params);
 339   EXPECT_TRUE(params.quic_enable_connection_racing);
 340 }
 341
 342 TEST_F(IOThreadTest, QuicDisableDiskCache) {
 343   field_trial_group_ = "Enabled";
 344   field_trial_params_["disable_disk_cache"] = "true";
 345   ConfigureQuicGlobals();
 346   net::HttpNetworkSession::Params params;
 347   InitializeNetworkSessionParams(&params);
 348   EXPECT_TRUE(params.quic_disable_disk_cache);
 349 }
 350
 351 TEST_F(IOThreadTest,
 352        AlternateProtocolProbabilityThresholdFromFlag) {
 353   command_line_.AppendSwitchASCII("alternate-protocol-probability-threshold",
 354                                   ".5");
 355
 356   ConfigureQuicGlobals();
 357   net::HttpNetworkSession::Params params;
 358   InitializeNetworkSessionParams(&params);
 359   EXPECT_EQ(.5, params.alternate_protocol_probability_threshold);
 360 }
 361
 362 TEST_F(IOThreadTest,
 363        AlternateProtocolProbabilityThresholdFromEnableQuicFlag) {
 364   command_line_.AppendSwitch("enable-quic");
 365
 366   ConfigureQuicGlobals();
 367   net::HttpNetworkSession::Params params;
 368   InitializeNetworkSessionParams(&params);
 369   EXPECT_EQ(0, params.alternate_protocol_probability_threshold);
 370 }
 371
 372 TEST_F(IOThreadTest,
 373        AlternateProtocolProbabilityThresholdFromParams) {
 374   field_trial_group_ = "Enabled";
 375   field_trial_params_["alternate_protocol_probability_threshold"] = ".5";
 376
 377   ConfigureQuicGlobals();
 378   net::HttpNetworkSession::Params params;
 379   InitializeNetworkSessionParams(&params);
 380   EXPECT_EQ(.5, params.alternate_protocol_probability_threshold);
 381 }
 382
 383 }  // namespace test