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