Independently enable SPDY versions from field trial.

chrome/browser/io_thread.cc

 // Copyright (c) 2012 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 "chrome/browser/io_thread.h"
 
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 118 matching lines @@
 //  * A "holdback" group with SPDY disabled, and corresponding control
 //  (SPDY/3.1). The primary purpose of the holdback group is to encourage site
 //  operators to do feature detection rather than UA-sniffing. As such, this
 //  trial runs continuously.
 //  * A SPDY/4 experiment, for SPDY/4 (aka HTTP/2) vs SPDY/3.1 comparisons and
 //  eventual SPDY/4 deployment.
 const char kSpdyFieldTrialName[] = "SPDY";
 const char kSpdyFieldTrialHoldbackGroupNamePrefix[] = "SpdyDisabled";
 const char kSpdyFieldTrialSpdy31GroupNamePrefix[] = "Spdy31Enabled";
 const char kSpdyFieldTrialSpdy4GroupNamePrefix[] = "Spdy4Enabled";
+const char kSpdyFieldTrialParametrizedPrefix[] = "Parametrized";
 
 // Field trial for Cache-Control: stale-while-revalidate directive.
 const char kStaleWhileRevalidateFieldTrialName[] = "StaleWhileRevalidate";
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 void ObserveKeychainEvents() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   net::CertDatabase::GetInstance()->SetMessageLoopForKeychainEvents();
 }
 #endif
@@ skipping 709 matching lines @@
 }
 
 void IOThread::InitializeNetworkOptions(const base::CommandLine& command_line) {
   // Only handle use-spdy command line flags if "spdy.disabled" preference is
   // not disabled via policy.
   if (is_spdy_disabled_by_policy_) {
     base::FieldTrial* trial = base::FieldTrialList::Find(kSpdyFieldTrialName);
     if (trial)
       trial->Disable();
   } else {
-    if (command_line.HasSwitch(switches::kTrustedSpdyProxy)) {
-      globals_->trusted_spdy_proxy.set(
-          command_line.GetSwitchValueASCII(switches::kTrustedSpdyProxy));
+    std::string group = base::FieldTrialList::FindFullName(kSpdyFieldTrialName);
+    VariationParameters params;
+    if (!variations::GetVariationParams(kSpdyFieldTrialName, &params)) {
+      params.clear();
     }
-    if (command_line.HasSwitch(switches::kIgnoreUrlFetcherCertRequests))
-      net::URLFetcher::SetIgnoreCertificateRequests(true);
-
-    if (command_line.HasSwitch(switches::kUseSpdy)) {
-      std::string spdy_mode =
-          command_line.GetSwitchValueASCII(switches::kUseSpdy);
-      EnableSpdy(spdy_mode);
-    } else if (command_line.HasSwitch(switches::kEnableSpdy4)) {
-      globals_->next_protos = net::NextProtosSpdy4Http2();
-      globals_->use_alternate_protocols.set(true);
-    } else if (command_line.HasSwitch(switches::kEnableNpnHttpOnly)) {
-      globals_->next_protos = net::NextProtosHttpOnly();
-      globals_->use_alternate_protocols.set(false);
-    } else {
-      // No SPDY command-line flags have been specified. Examine trial groups.
-      ConfigureSpdyFromTrial(
-          base::FieldTrialList::FindFullName(kSpdyFieldTrialName), globals_);
-    }
+    ConfigureSpdyGlobals(command_line, group, params, globals_);
   }
 
   ConfigureTCPFastOpen(command_line);
   ConfigureSdch();
 
   // TODO(rch): Make the client socket factory a per-network session
   // instance, constructed from a NetworkSession::Params, to allow us
   // to move this option to IOThread::Globals &
   // HttpNetworkSession::Params.
 }
@@ skipping 23 matching lines @@
       base::FieldTrialList::FindFullName(kSdchFieldTrialName);
   base::StringPiece sdch_trial_group(sdch_trial_group_string);
   if (sdch_trial_group.starts_with(kEnabledHttpOnlyGroupName)) {
     net::SdchManager::EnableSdchSupport(true);
     net::SdchManager::EnableSecureSchemeSupport(false);
   } else if (sdch_trial_group.starts_with(kDisabledAllGroupName)) {
     net::SdchManager::EnableSdchSupport(false);
   }
 }
 
-void IOThread::ConfigureSpdyFromTrial(base::StringPiece spdy_trial_group,
-                                      Globals* globals) {
-  if (spdy_trial_group.starts_with(kSpdyFieldTrialHoldbackGroupNamePrefix)) {
-    // TODO(jgraettinger): Use net::NextProtosHttpOnly() instead?
-    net::HttpStreamFactory::set_spdy_enabled(false);
-  } else if (spdy_trial_group.starts_with(
-                 kSpdyFieldTrialSpdy31GroupNamePrefix)) {
-    globals->next_protos = net::NextProtosSpdy31();
+// static
+void IOThread::ConfigureSpdyGlobals(
+    const base::CommandLine& command_line,
+    base::StringPiece spdy_trial_group,
+    const VariationParameters& spdy_trial_params,
+    IOThread::Globals* globals) {
+  if (command_line.HasSwitch(switches::kTrustedSpdyProxy)) {
+    globals->trusted_spdy_proxy.set(
+        command_line.GetSwitchValueASCII(switches::kTrustedSpdyProxy));
+  }
+  if (command_line.HasSwitch(switches::kIgnoreUrlFetcherCertRequests))
+    net::URLFetcher::SetIgnoreCertificateRequests(true);
+
+  if (command_line.HasSwitch(switches::kUseSpdy)) {

[Ryan Hamilton, 2015/03/20 23:38:07]

Let's use early-return to clean up this mess :>

if (command_line.HasSwitch(switches::kUseSpdy)) {
  ...
  return;
}

if (command_line.HasSwitch(switches::kEnableSpdy4)) {
  ...
  return;
}

if (command_line.HasSwitch(switches::kEnableNpnHttpOnly)) { 
  ...
  return;
}

if (spdy_trial_group.starts_with(kSpdyFieldTrialHoldbackGroupNamePrefix)) {
  ...
  return;
}

if (spdy_trial_group.starts_with(kSpdyFieldTrialSpdy31GroupNamePrefix)) {
  ...
  return;
}
  
if (spdy_trial_group.starts_with(kSpdyFieldTrialSpdy4GroupNamePrefix)) {
  ...
  return;
}

if (spdy_trial_group.starts_with(kSpdyFieldTrialParametrizedPrefix)) {
  ...
  return;
}

// By default, enable HTTP/2.
globals->next_protos = net::NextProtos(true, true, true, true);
globals->use_alternate_protocols.set(true);
}

[Bence, 2015/03/23 14:19:13]

Done.

+    std::string spdy_mode =
+        command_line.GetSwitchValueASCII(switches::kUseSpdy);
+    EnableSpdy(spdy_mode, globals);

[Ryan Hamilton, 2015/03/20 23:38:07]

Ah, so here's the one place this method is called. Perhaps it should be called
something like ConfigureSpdyGlobalsFromUseSpdyArgument() or some such.

Since it's a helper of ConfigureSpdy, you could also make it a method in an
anon-namespace of this class. Your call.

[Bence, 2015/03/23 14:19:13]

Great idea.  Done.

+  } else if (command_line.HasSwitch(switches::kEnableSpdy4)) {
+    globals->next_protos = net::NextProtos(true, true, true, true);
     globals->use_alternate_protocols.set(true);
-  } else if (spdy_trial_group.starts_with(
-                 kSpdyFieldTrialSpdy4GroupNamePrefix)) {
-    globals->next_protos = net::NextProtosSpdy4Http2();
-    globals->use_alternate_protocols.set(true);
+  } else if (command_line.HasSwitch(switches::kEnableNpnHttpOnly)) {
+    globals->next_protos = net::NextProtos(false, false, false, false);
+    globals->use_alternate_protocols.set(false);
   } else {
-    // By default, enable HTTP/2.
-    globals->next_protos = net::NextProtosSpdy4Http2();
-    globals->use_alternate_protocols.set(true);
+    // No SPDY command-line flags have been specified. Examine trial groups.
+    if (spdy_trial_group.starts_with(kSpdyFieldTrialHoldbackGroupNamePrefix)) {
+      // TODO(jgraettinger): Use net::NextProtosHttpOnly() instead?
+      net::HttpStreamFactory::set_spdy_enabled(false);
+    } else if (spdy_trial_group.starts_with(
+                   kSpdyFieldTrialSpdy31GroupNamePrefix)) {
+      globals->next_protos = net::NextProtosSpdy31();
+      globals->use_alternate_protocols.set(true);
+    } else if (spdy_trial_group.starts_with(
+                   kSpdyFieldTrialSpdy4GroupNamePrefix)) {
+      globals->next_protos = net::NextProtos(true, true, true, true);
+      globals->use_alternate_protocols.set(true);
+    } else if (spdy_trial_group.starts_with(
+                   kSpdyFieldTrialParametrizedPrefix)) {
+      bool quic_enabled = LowerCaseEqualsASCII(
+          GetVariationParam(spdy_trial_params, "quic_enabled"), "true");

[Ryan Hamilton, 2015/03/20 23:38:07]

I think this is going to fight with the QUIC field trial which tries to be
responsible for enabling QUIC.

[Bence, 2015/03/23 14:19:13]

Good point.  I have the impression that this is preexisting problem.  I'm
solving it by adding QUIC to next_protos iff enable_quic as determined earlier
by ConfigureQuic.

Done.

+      bool spdy31_enabled = LowerCaseEqualsASCII(
+          GetVariationParam(spdy_trial_params, "spdy31_enabled"), "true");
+      bool h2_14_enabled = LowerCaseEqualsASCII(
+          GetVariationParam(spdy_trial_params, "h2_14_enabled"), "true");
+      bool h2_enabled = LowerCaseEqualsASCII(
+          GetVariationParam(spdy_trial_params, "h2_enabled"), "true");
+      globals->next_protos = net::NextProtos(quic_enabled, spdy31_enabled,
+                                             h2_14_enabled, h2_enabled);
+      globals->use_alternate_protocols.set(true);
+    } else {
+      // By default, enable HTTP/2.
+      globals->next_protos = net::NextProtos(true, true, true, true);
+      globals->use_alternate_protocols.set(true);
+    }
   }
 }
 
-void IOThread::EnableSpdy(const std::string& mode) {
+// static
+void IOThread::EnableSpdy(const std::string& mode, IOThread::Globals* globals) {
   static const char kOff[] = "off";
   static const char kSSL[] = "ssl";
   static const char kDisableSSL[] = "no-ssl";
   static const char kDisablePing[] = "no-ping";
   static const char kExclude[] = "exclude";  // Hosts to exclude
   static const char kDisableCompression[] = "no-compress";
   static const char kDisableAltProtocols[] = "no-alt-protocols";
   static const char kForceAltProtocols[] = "force-alt-protocols";
   static const char kSingleDomain[] = "single-domain";
 
   static const char kInitialMaxConcurrentStreams[] = "init-max-streams";
 
   std::vector<std::string> spdy_options;
   base::SplitString(mode, ',', &spdy_options);
 
   for (std::vector<std::string>::iterator it = spdy_options.begin();
        it != spdy_options.end(); ++it) {
     const std::string& element = *it;
     std::vector<std::string> name_value;
     base::SplitString(element, '=', &name_value);
     const std::string& option =
         name_value.size() > 0 ? name_value[0] : std::string();
     const std::string value =
         name_value.size() > 1 ? name_value[1] : std::string();
 
     if (option == kOff) {
       net::HttpStreamFactory::set_spdy_enabled(false);
     } else if (option == kDisableSSL) {
-      globals_->spdy_default_protocol.set(net::kProtoSPDY31);
-      globals_->force_spdy_over_ssl.set(false);
-      globals_->force_spdy_always.set(true);
+      globals->spdy_default_protocol.set(net::kProtoSPDY31);
+      globals->force_spdy_over_ssl.set(false);
+      globals->force_spdy_always.set(true);
     } else if (option == kSSL) {
-      globals_->spdy_default_protocol.set(net::kProtoSPDY31);
-      globals_->force_spdy_over_ssl.set(true);
-      globals_->force_spdy_always.set(true);
+      globals->spdy_default_protocol.set(net::kProtoSPDY31);
+      globals->force_spdy_over_ssl.set(true);
+      globals->force_spdy_always.set(true);
     } else if (option == kDisablePing) {
-      globals_->enable_spdy_ping_based_connection_checking.set(false);
+      globals->enable_spdy_ping_based_connection_checking.set(false);
     } else if (option == kExclude) {
-      globals_->forced_spdy_exclusions.insert(
+      globals->forced_spdy_exclusions.insert(
           net::HostPortPair::FromURL(GURL(value)));
     } else if (option == kDisableCompression) {
-      globals_->enable_spdy_compression.set(false);
+      globals->enable_spdy_compression.set(false);
     } else if (option == kDisableAltProtocols) {
-      globals_->use_alternate_protocols.set(false);
+      globals->use_alternate_protocols.set(false);
     } else if (option == kForceAltProtocols) {
       net::AlternateProtocolInfo pair(443, net::NPN_SPDY_3, 1);
       net::HttpServerPropertiesImpl::ForceAlternateProtocol(pair);
     } else if (option == kSingleDomain) {
       DVLOG(1) << "FORCING SINGLE DOMAIN";
-      globals_->force_spdy_single_domain.set(true);
+      globals->force_spdy_single_domain.set(true);
     } else if (option == kInitialMaxConcurrentStreams) {
       int streams;
       if (base::StringToInt(value, &streams))
-        globals_->initial_max_spdy_concurrent_streams.set(streams);
+        globals->initial_max_spdy_concurrent_streams.set(streams);
     } else if (option.empty() && it == spdy_options.begin()) {
       continue;
     } else {
       LOG(DFATAL) << "Unrecognized spdy option: " << option;
     }
   }
 }
 
 // static
 void IOThread::RegisterPrefs(PrefRegistrySimple* registry) {
@@ skipping 496 matching lines @@
   net::QuicVersionVector supported_versions = net::QuicSupportedVersions();
   for (size_t i = 0; i < supported_versions.size(); ++i) {
     net::QuicVersion version = supported_versions[i];
     if (net::QuicVersionToString(version) == quic_version) {
       return version;
     }
   }
 
   return net::QUIC_VERSION_UNSUPPORTED;
 }