SPDY - disable spdy/2.1 (flow control) by default

net/http/http_stream_factory.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 "net/http/http_stream_factory.h"
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/host_mapping_rules.h"
 #include "net/base/host_port_pair.h"
-#include "net/http/http_server_properties.h"
 
 namespace net {
 
 // WARNING: If you modify or add any static flags, you must keep them in sync
 // with |ResetStaticSettingsToInit|. This is critical for unit test isolation.
 
 // static
 const HostMappingRules* HttpStreamFactory::host_mapping_rules_ = NULL;
 // static
 std::vector<std::string>* HttpStreamFactory::next_protos_ = NULL;
 // static
 bool HttpStreamFactory::spdy_enabled_ = true;
 // static
 bool HttpStreamFactory::use_alternate_protocols_ = false;
 // static
 bool HttpStreamFactory::force_spdy_over_ssl_ = true;
 // static
 bool HttpStreamFactory::force_spdy_always_ = false;
 // static
 std::list<HostPortPair>* HttpStreamFactory::forced_spdy_exclusions_ = NULL;
 // static
 bool HttpStreamFactory::ignore_certificate_errors_ = false;
 // static
 bool HttpStreamFactory::http_pipelining_enabled_ = false;
 // static
 uint16 HttpStreamFactory::testing_fixed_http_port_ = 0;
 // static
 uint16 HttpStreamFactory::testing_fixed_https_port_ = 0;
+// static
+AlternateProtocol HttpStreamFactory::supported_spdy_version_ = NPN_SPDY_2;
 
 HttpStreamFactory::~HttpStreamFactory() {}
 
 // static
 void HttpStreamFactory::ResetStaticSettingsToInit() {
   // WARNING: These must match the initializers above.
   delete host_mapping_rules_;
   delete next_protos_;
   delete forced_spdy_exclusions_;
   host_mapping_rules_ = NULL;
   next_protos_ = NULL;
   spdy_enabled_ = true;
   use_alternate_protocols_ = false;
   force_spdy_over_ssl_ = true;
   force_spdy_always_ = false;
   forced_spdy_exclusions_ = NULL;
   ignore_certificate_errors_ = false;
+  supported_spdy_version_ = NPN_SPDY_2;
 }
 
 void HttpStreamFactory::ProcessAlternateProtocol(
     HttpServerProperties* http_server_properties,
     const std::string& alternate_protocol_str,
     const HostPortPair& http_host_port_pair) {
   std::vector<std::string> port_protocol_vector;
   base::SplitString(alternate_protocol_str, ':', &port_protocol_vector);
   if (port_protocol_vector.size() != 2) {
     DLOG(WARNING) << kAlternateProtocolHeader
@@ skipping 11 matching lines @@
     return;
   }
 
   AlternateProtocol protocol = ALTERNATE_PROTOCOL_BROKEN;
   // We skip NPN_SPDY_1 here, because we've rolled the protocol version to 2.
   for (int i = NPN_SPDY_2; i < NUM_ALTERNATE_PROTOCOLS; ++i) {
     if (port_protocol_vector[1] == kAlternateProtocolStrings[i])
       protocol = static_cast<AlternateProtocol>(i);
   }
 
-  if (protocol == ALTERNATE_PROTOCOL_BROKEN) {
+  if (protocol != supported_spdy_version_ ||

[Ryan Hamilton, 2012/03/01 18:56:20]

As we discussed offline, this approach only allows us to speak a single version
at a time.  It would prevent us from speaking 2 or 2.1 depending on what the
server advertises.

We discussed having HttpStreamFactory maintain an array of booleans indexed by
NPN_foo.  If array[NPN_foo] is true, then that version is enabled, otherwise it
is not.  This would be simple, efficient, and flexible.

[willchan no longer on Chromium, 2012/03/01 18:57:54]

Whew, good catch! I didn't notice this. This is important, since most other SPDY
websites won't advertise 2.1.

+      protocol == ALTERNATE_PROTOCOL_BROKEN) {
     // Currently, we only recognize the npn-spdy protocol.
     DLOG(WARNING) << kAlternateProtocolHeader
                   << " header has unrecognized protocol: "
                   << port_protocol_vector[1];
     return;
   }
 
   HostPortPair host_port(http_host_port_pair);
   host_mapping_rules().RewriteHost(&host_port);
 
@@ skipping 54 matching lines @@
 HttpStreamFactory::HttpStreamFactory() {}
 
 // static
 const HostMappingRules& HttpStreamFactory::host_mapping_rules() {
   if (!host_mapping_rules_)
     host_mapping_rules_ = new HostMappingRules;
   return *host_mapping_rules_;
 }
 
 }  // namespace net