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 "base/test/mock_entropy_provider.h"
   8 #include "chrome/browser/io_thread.h"
   9 #include "chrome/common/chrome_switches.h"
  10 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_params.h"
  11 #include "net/http/http_network_session.h"
  12 #include "net/http/http_server_properties_impl.h"
  13 #include "net/quic/quic_protocol.h"
  14 #include "testing/gmock/include/gmock/gmock.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace test {
  18
  19 using ::testing::ElementsAre;
  20
  21 class IOThreadPeer {
  22  public:
  23   static void ConfigureQuicGlobals(
  24       const base::CommandLine& command_line,
  25       base::StringPiece quic_trial_group,
  26       const std::map<std::string, std::string>& quic_trial_params,
  27       bool is_quic_allowed_by_policy,
  28       IOThread::Globals* globals) {
  29     IOThread::ConfigureQuicGlobals(command_line, quic_trial_group,
  30                                    quic_trial_params, is_quic_allowed_by_policy,
  31                                    globals);
  32   }
  33
  34   static void ConfigureSpdyGlobals(
  35       const base::CommandLine& command_line,
  36       base::StringPiece spdy_trial_group,
  37       const std::map<std::string, std::string>& spdy_trial_params,
  38       IOThread::Globals* globals) {
  39     IOThread::ConfigureSpdyGlobals(command_line, spdy_trial_group,
  40                                    spdy_trial_params, globals);
  41   }
  42
  43   static void InitializeNetworkSessionParamsFromGlobals(
  44       const IOThread::Globals& globals,
  45       net::HttpNetworkSession::Params* params) {
  46     IOThread::InitializeNetworkSessionParamsFromGlobals(globals, params);
  47   }
  48 };
  49
  50 class IOThreadTest : public testing::Test {
  51  public:
  52   IOThreadTest()
  53       : command_line_(base::CommandLine::NO_PROGRAM),
  54         is_quic_allowed_by_policy_(true) {
  55     globals_.http_server_properties.reset(new net::HttpServerPropertiesImpl());
  56   }
  57
  58   void ConfigureQuicGlobals() {
  59     IOThreadPeer::ConfigureQuicGlobals(command_line_,
  60                                        field_trial_group_,
  61                                        field_trial_params_,
  62                                        is_quic_allowed_by_policy_,
  63                                        &globals_);
  64   }
  65
  66   void ConfigureSpdyGlobals() {
  67     IOThreadPeer::ConfigureSpdyGlobals(command_line_, field_trial_group_,
  68                                        field_trial_params_, &globals_);
  69   }
  70
  71   void InitializeNetworkSessionParams(net::HttpNetworkSession::Params* params) {
  72     IOThreadPeer::InitializeNetworkSessionParamsFromGlobals(globals_, params);
  73   }
  74
  75   base::CommandLine command_line_;
  76   IOThread::Globals globals_;
  77   std::string field_trial_group_;
  78   bool is_quic_allowed_by_policy_;
  79   std::map<std::string, std::string> field_trial_params_;
  80 };
  81
  82 TEST_F(IOThreadTest, InitializeNetworkSessionParamsFromGlobals) {
  83   globals_.quic_connection_options.push_back(net::kPACE);
  84   globals_.quic_connection_options.push_back(net::kTBBR);
  85   globals_.quic_connection_options.push_back(net::kTIME);
  86
  87   net::HttpNetworkSession::Params params;
  88   InitializeNetworkSessionParams(&params);
  89   EXPECT_EQ(globals_.quic_connection_options,
  90             params.quic_connection_options);
  91 }
  92
  93 TEST_F(IOThreadTest, SpdyFieldTrialHoldbackEnabled) {
  94   net::HttpStreamFactory::set_spdy_enabled(true);
  95   field_trial_group_ = "SpdyDisabled";
  96   ConfigureSpdyGlobals();
  97   EXPECT_FALSE(net::HttpStreamFactory::spdy_enabled());
  98 }
  99
 100 TEST_F(IOThreadTest, SpdyFieldTrialSpdy31Enabled) {
 101   bool use_alternate_protocols = false;
 102   field_trial_group_ = "Spdy31Enabled";
 103   ConfigureSpdyGlobals();
 104   EXPECT_THAT(globals_.next_protos,
 105               ElementsAre(net::kProtoHTTP11,
 106                           net::kProtoSPDY31));
 107   globals_.use_alternate_protocols.CopyToIfSet(&use_alternate_protocols);
 108   EXPECT_TRUE(use_alternate_protocols);
 109 }
 110
 111 TEST_F(IOThreadTest, SpdyFieldTrialSpdy4Enabled) {
 112   bool use_alternate_protocols = false;
 113   field_trial_group_ = "Spdy4Enabled";
 114   ConfigureSpdyGlobals();
 115   EXPECT_THAT(globals_.next_protos,
 116               ElementsAre(net::kProtoHTTP11, net::kProtoSPDY31,
 117                           net::kProtoSPDY4_14, net::kProtoSPDY4));
 118   globals_.use_alternate_protocols.CopyToIfSet(&use_alternate_protocols);
 119   EXPECT_TRUE(use_alternate_protocols);
 120 }
 121
 122 TEST_F(IOThreadTest, SpdyFieldTrialDefault) {
 123   field_trial_group_ = "";
 124   ConfigureSpdyGlobals();
 125   EXPECT_THAT(globals_.next_protos,
 126               ElementsAre(net::kProtoHTTP11, net::kProtoSPDY31,
 127                           net::kProtoSPDY4_14, net::kProtoSPDY4));
 128   bool use_alternate_protocols = false;
 129   globals_.use_alternate_protocols.CopyToIfSet(&use_alternate_protocols);
 130   EXPECT_TRUE(use_alternate_protocols);
 131 }
 132
 133 TEST_F(IOThreadTest, SpdyFieldTrialParametrized) {
 134   field_trial_params_["enable_spdy31"] = "false";
 135   // Undefined parameter "enable_http2_14" should default to false.
 136   field_trial_params_["enable_http2"] = "true";
 137   field_trial_group_ = "ParametrizedHTTP2Only";
 138   ConfigureSpdyGlobals();
 139   EXPECT_THAT(globals_.next_protos,
 140               ElementsAre(net::kProtoHTTP11, net::kProtoSPDY4));
 141   bool use_alternate_protocols = false;
 142   globals_.use_alternate_protocols.CopyToIfSet(&use_alternate_protocols);
 143   EXPECT_TRUE(use_alternate_protocols);
 144 }
 145
 146 TEST_F(IOThreadTest, SpdyCommandLineUseSpdyOff) {
 147   command_line_.AppendSwitchASCII("use-spdy", "off");
 148   // Command line should overwrite field trial group.
 149   field_trial_group_ = "Spdy4Enabled";
 150   ConfigureSpdyGlobals();
 151   EXPECT_EQ(0u, globals_.next_protos.size());
 152 }
 153
 154 TEST_F(IOThreadTest, SpdyCommandLineUseSpdyDisableAltProtocols) {
 155   command_line_.AppendSwitchASCII("use-spdy", "no-alt-protocols");
 156   ConfigureSpdyGlobals();
 157   bool use_alternate_protocols = true;
 158   globals_.use_alternate_protocols.CopyToIfSet(&use_alternate_protocols);
 159   EXPECT_FALSE(use_alternate_protocols);
 160 }
 161
 162 TEST_F(IOThreadTest, DisableQuicByDefault) {
 163   ConfigureQuicGlobals();
 164   net::HttpNetworkSession::Params params;
 165   InitializeNetworkSessionParams(&params);
 166   EXPECT_FALSE(params.enable_quic);
 167   EXPECT_FALSE(params.enable_quic_for_proxies);
 168   EXPECT_FALSE(IOThread::ShouldEnableQuicForDataReductionProxy());
 169 }
 170
 171 TEST_F(IOThreadTest, EnableQuicFromFieldTrialGroup) {
 172   field_trial_group_ = "Enabled";
 173
 174   ConfigureQuicGlobals();
 175   net::HttpNetworkSession::Params default_params;
 176   net::HttpNetworkSession::Params params;
 177   InitializeNetworkSessionParams(&params);
 178   EXPECT_TRUE(params.enable_quic);
 179   EXPECT_FALSE(params.disable_insecure_quic);
 180   EXPECT_TRUE(params.enable_quic_for_proxies);
 181   EXPECT_EQ(1350u, params.quic_max_packet_length);
 182   EXPECT_EQ(1.0, params.alternative_service_probability_threshold);
 183   EXPECT_EQ(default_params.quic_supported_versions,
 184             params.quic_supported_versions);
 185   EXPECT_EQ(net::QuicTagVector(), params.quic_connection_options);
 186   EXPECT_FALSE(params.quic_always_require_handshake_confirmation);
 187   EXPECT_FALSE(params.quic_disable_connection_pooling);
 188   EXPECT_EQ(0.25f, params.quic_load_server_info_timeout_srtt_multiplier);
 189   EXPECT_FALSE(params.quic_enable_connection_racing);
 190   EXPECT_FALSE(params.quic_enable_non_blocking_io);
 191   EXPECT_FALSE(params.quic_disable_disk_cache);
 192   EXPECT_EQ(0, params.quic_max_number_of_lossy_connections);
 193   EXPECT_EQ(1.0f, params.quic_packet_loss_threshold);
 194   EXPECT_FALSE(IOThread::ShouldEnableQuicForDataReductionProxy());
 195 }
 196
 197 TEST_F(IOThreadTest, EnableQuicFromQuicProxyFieldTrialGroup) {
 198   base::FieldTrialList field_trial_list(new base::MockEntropyProvider());
 199   base::FieldTrialList::CreateFieldTrial(
 200       data_reduction_proxy::DataReductionProxyParams::GetQuicFieldTrialName(),
 201       "Enabled");
 202
 203   ConfigureQuicGlobals();
 204   net::HttpNetworkSession::Params params;
 205   InitializeNetworkSessionParams(&params);
 206   EXPECT_FALSE(params.enable_quic);
 207   EXPECT_TRUE(params.enable_quic_for_proxies);
 208   EXPECT_TRUE(IOThread::ShouldEnableQuicForDataReductionProxy());
 209   EXPECT_EQ(1024 * 1024, params.quic_socket_receive_buffer_size);
 210 }
 211
 212 TEST_F(IOThreadTest, EnableQuicFromCommandLine) {
 213   command_line_.AppendSwitch("enable-quic");
 214
 215   ConfigureQuicGlobals();
 216   net::HttpNetworkSession::Params params;
 217   InitializeNetworkSessionParams(&params);
 218   EXPECT_TRUE(params.enable_quic);
 219   EXPECT_TRUE(params.enable_quic_for_proxies);
 220   EXPECT_FALSE(IOThread::ShouldEnableQuicForDataReductionProxy());
 221 }
 222
 223 TEST_F(IOThreadTest, EnablePacingFromCommandLine) {
 224   command_line_.AppendSwitch("enable-quic");
 225   command_line_.AppendSwitch("enable-quic-pacing");
 226
 227   ConfigureQuicGlobals();
 228   net::HttpNetworkSession::Params params;
 229   InitializeNetworkSessionParams(&params);
 230   net::QuicTagVector options;
 231   options.push_back(net::kPACE);
 232   EXPECT_EQ(options, params.quic_connection_options);
 233 }
 234 TEST_F(IOThreadTest, DisableInsecureQuicFromFieldTrialParams) {
 235   field_trial_group_ = "Enabled";
 236   field_trial_params_["disable_insecure_quic"] = "true";
 237
 238   ConfigureQuicGlobals();
 239   net::HttpNetworkSession::Params params;
 240   InitializeNetworkSessionParams(&params);
 241   EXPECT_TRUE(params.disable_insecure_quic);
 242 }
 243
 244 TEST_F(IOThreadTest, EnablePacingFromFieldTrialParams) {
 245   field_trial_group_ = "Enabled";
 246   field_trial_params_["enable_pacing"] = "true";
 247
 248   ConfigureQuicGlobals();
 249   net::HttpNetworkSession::Params params;
 250   InitializeNetworkSessionParams(&params);
 251   net::QuicTagVector options;
 252   options.push_back(net::kPACE);
 253   EXPECT_EQ(options, params.quic_connection_options);
 254 }
 255
 256 TEST_F(IOThreadTest, PacketLengthFromCommandLine) {
 257   command_line_.AppendSwitch("enable-quic");
 258   command_line_.AppendSwitchASCII("quic-max-packet-length", "1450");
 259
 260   ConfigureQuicGlobals();
 261   net::HttpNetworkSession::Params params;
 262   InitializeNetworkSessionParams(&params);
 263   EXPECT_EQ(1450u, params.quic_max_packet_length);
 264 }
 265
 266 TEST_F(IOThreadTest, PacketLengthFromFieldTrialParams) {
 267   field_trial_group_ = "Enabled";
 268   field_trial_params_["max_packet_length"] = "1450";
 269
 270   ConfigureQuicGlobals();
 271   net::HttpNetworkSession::Params params;
 272   InitializeNetworkSessionParams(&params);
 273   EXPECT_EQ(1450u, params.quic_max_packet_length);
 274 }
 275
 276 TEST_F(IOThreadTest, QuicVersionFromCommandLine) {
 277   command_line_.AppendSwitch("enable-quic");
 278   std::string version =
 279       net::QuicVersionToString(net::QuicSupportedVersions().back());
 280   command_line_.AppendSwitchASCII("quic-version", version);
 281
 282   ConfigureQuicGlobals();
 283   net::HttpNetworkSession::Params params;
 284   InitializeNetworkSessionParams(&params);
 285   net::QuicVersionVector supported_versions;
 286   supported_versions.push_back(net::QuicSupportedVersions().back());
 287   EXPECT_EQ(supported_versions, params.quic_supported_versions);
 288 }
 289
 290 TEST_F(IOThreadTest, QuicVersionFromFieldTrialParams) {
 291   field_trial_group_ = "Enabled";
 292   field_trial_params_["quic_version"] =
 293       net::QuicVersionToString(net::QuicSupportedVersions().back());
 294
 295   ConfigureQuicGlobals();
 296   net::HttpNetworkSession::Params params;
 297   InitializeNetworkSessionParams(&params);
 298   net::QuicVersionVector supported_versions;
 299   supported_versions.push_back(net::QuicSupportedVersions().back());
 300   EXPECT_EQ(supported_versions, params.quic_supported_versions);
 301 }
 302
 303 TEST_F(IOThreadTest, QuicConnectionOptionsFromCommandLine) {
 304   command_line_.AppendSwitch("enable-quic");
 305   command_line_.AppendSwitchASCII("quic-connection-options",
 306                                   "PACE,TIME,TBBR,REJ");
 307
 308   ConfigureQuicGlobals();
 309   net::HttpNetworkSession::Params params;
 310   InitializeNetworkSessionParams(&params);
 311
 312   net::QuicTagVector options;
 313   options.push_back(net::kPACE);
 314   options.push_back(net::kTIME);
 315   options.push_back(net::kTBBR);
 316   options.push_back(net::kREJ);
 317   EXPECT_EQ(options, params.quic_connection_options);
 318 }
 319
 320 TEST_F(IOThreadTest, QuicConnectionOptionsFromFieldTrialParams) {
 321   field_trial_group_ = "Enabled";
 322   field_trial_params_["connection_options"] = "PACE,TIME,TBBR,REJ";
 323
 324   ConfigureQuicGlobals();
 325   net::HttpNetworkSession::Params params;
 326   InitializeNetworkSessionParams(&params);
 327
 328   net::QuicTagVector options;
 329   options.push_back(net::kPACE);
 330   options.push_back(net::kTIME);
 331   options.push_back(net::kTBBR);
 332   options.push_back(net::kREJ);
 333   EXPECT_EQ(options, params.quic_connection_options);
 334 }
 335
 336 TEST_F(IOThreadTest,
 337        QuicAlwaysRequireHandshakeConfirmationFromFieldTrialParams) {
 338   field_trial_group_ = "Enabled";
 339   field_trial_params_["always_require_handshake_confirmation"] = "true";
 340   ConfigureQuicGlobals();
 341   net::HttpNetworkSession::Params params;
 342   InitializeNetworkSessionParams(&params);
 343   EXPECT_TRUE(params.quic_always_require_handshake_confirmation);
 344 }
 345
 346 TEST_F(IOThreadTest,
 347        QuicDisableConnectionPoolingFromFieldTrialParams) {
 348   field_trial_group_ = "Enabled";
 349   field_trial_params_["disable_connection_pooling"] = "true";
 350   ConfigureQuicGlobals();
 351   net::HttpNetworkSession::Params params;
 352   InitializeNetworkSessionParams(&params);
 353   EXPECT_TRUE(params.quic_disable_connection_pooling);
 354 }
 355
 356 TEST_F(IOThreadTest, QuicLoadServerInfoTimeToSmoothedRttFromFieldTrialParams) {
 357   field_trial_group_ = "Enabled";
 358   field_trial_params_["load_server_info_time_to_srtt"] = "0.5";
 359   ConfigureQuicGlobals();
 360   net::HttpNetworkSession::Params params;
 361   InitializeNetworkSessionParams(&params);
 362   EXPECT_EQ(0.5f, params.quic_load_server_info_timeout_srtt_multiplier);
 363 }
 364
 365 TEST_F(IOThreadTest, QuicEnableConnectionRacing) {
 366   field_trial_group_ = "Enabled";
 367   field_trial_params_["enable_connection_racing"] = "true";
 368   ConfigureQuicGlobals();
 369   net::HttpNetworkSession::Params params;
 370   InitializeNetworkSessionParams(&params);
 371   EXPECT_TRUE(params.quic_enable_connection_racing);
 372 }
 373
 374 TEST_F(IOThreadTest, QuicEnableNonBlockingIO) {
 375   field_trial_group_ = "Enabled";
 376   field_trial_params_["enable_non_blocking_io"] = "true";
 377   ConfigureQuicGlobals();
 378   net::HttpNetworkSession::Params params;
 379   InitializeNetworkSessionParams(&params);
 380   EXPECT_TRUE(params.quic_enable_non_blocking_io);
 381 }
 382
 383 TEST_F(IOThreadTest, QuicDisableDiskCache) {
 384   field_trial_group_ = "Enabled";
 385   field_trial_params_["disable_disk_cache"] = "true";
 386   ConfigureQuicGlobals();
 387   net::HttpNetworkSession::Params params;
 388   InitializeNetworkSessionParams(&params);
 389   EXPECT_TRUE(params.quic_disable_disk_cache);
 390 }
 391
 392 TEST_F(IOThreadTest, QuicMaxNumberOfLossyConnectionsFieldTrialParams) {
 393   field_trial_group_ = "Enabled";
 394   field_trial_params_["max_number_of_lossy_connections"] = "5";
 395   ConfigureQuicGlobals();
 396   net::HttpNetworkSession::Params params;
 397   InitializeNetworkSessionParams(&params);
 398   EXPECT_EQ(5, params.quic_max_number_of_lossy_connections);
 399 }
 400
 401 TEST_F(IOThreadTest, QuicPacketLossThresholdFieldTrialParams) {
 402   field_trial_group_ = "Enabled";
 403   field_trial_params_["packet_loss_threshold"] = "0.5";
 404   ConfigureQuicGlobals();
 405   net::HttpNetworkSession::Params params;
 406   InitializeNetworkSessionParams(&params);
 407   EXPECT_EQ(0.5f, params.quic_packet_loss_threshold);
 408 }
 409
 410 TEST_F(IOThreadTest, QuicReceiveBufferSize) {
 411   field_trial_group_ = "Enabled";
 412   field_trial_params_["receive_buffer_size"] = "2097152";
 413   ConfigureQuicGlobals();
 414   net::HttpNetworkSession::Params params;
 415   InitializeNetworkSessionParams(&params);
 416   EXPECT_EQ(2097152, params.quic_socket_receive_buffer_size);
 417 }
 418
 419 TEST_F(IOThreadTest, AlternativeServiceProbabilityThresholdFromFlag) {
 420   command_line_.AppendSwitchASCII("alternative-service-probability-threshold",
 421                                   "0.5");
 422
 423   ConfigureQuicGlobals();
 424   net::HttpNetworkSession::Params params;
 425   InitializeNetworkSessionParams(&params);
 426   EXPECT_EQ(.5, params.alternative_service_probability_threshold);
 427 }
 428
 429 TEST_F(IOThreadTest, AlternativeServiceProbabilityThresholdFromEnableQuicFlag) {
 430   command_line_.AppendSwitch("enable-quic");
 431
 432   ConfigureQuicGlobals();
 433   net::HttpNetworkSession::Params params;
 434   InitializeNetworkSessionParams(&params);
 435   EXPECT_EQ(0, params.alternative_service_probability_threshold);
 436 }
 437
 438 // TODO(bnc): Remove when new parameter name rolls out and server configuration
 439 // is changed.
 440 TEST_F(IOThreadTest, AlternativeServiceProbabilityThresholdFromOldParams) {
 441   field_trial_group_ = "Enabled";
 442   field_trial_params_["alternate_protocol_probability_threshold"] = ".5";
 443
 444   ConfigureQuicGlobals();
 445   net::HttpNetworkSession::Params params;
 446   InitializeNetworkSessionParams(&params);
 447   EXPECT_EQ(.5, params.alternative_service_probability_threshold);
 448 }
 449
 450 TEST_F(IOThreadTest, AlternativeServiceProbabilityThresholdFromParams) {
 451   field_trial_group_ = "Enabled";
 452   field_trial_params_["alternative_service_probability_threshold"] = ".5";
 453
 454   ConfigureQuicGlobals();
 455   net::HttpNetworkSession::Params params;
 456   InitializeNetworkSessionParams(&params);
 457   EXPECT_EQ(.5, params.alternative_service_probability_threshold);
 458 }
 459
 460 TEST_F(IOThreadTest, QuicDisallowedByPolicy) {
 461   command_line_.AppendSwitch(switches::kEnableQuic);
 462   is_quic_allowed_by_policy_ = false;
 463   ConfigureQuicGlobals();
 464
 465   net::HttpNetworkSession::Params params;
 466   InitializeNetworkSessionParams(&params);
 467   EXPECT_FALSE(params.enable_quic);
 468 }
 469
 470 }  // namespace test