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::enabled_protocols_[NUM_ALTERNATE_PROTOCOLS];
+// 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
@@ skipping 14 matching lines @@
   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;
+  for (int i = 0; i < NUM_ALTERNATE_PROTOCOLS; ++i)
+    enabled_protocols_[i] = false;
 }
 
 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
                   << " header has too many tokens: "
                   << alternate_protocol_str;
     return;
   }
 
   int port;
   if (!base::StringToInt(port_protocol_vector[0], &port) ||
       port <= 0 || port >= 1 << 16) {
     DLOG(WARNING) << kAlternateProtocolHeader
                   << " header has unrecognizable port: "
                   << port_protocol_vector[0];
     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])
+  for (int i = 0; i < NUM_ALTERNATE_PROTOCOLS; ++i) {
+    if (enabled_protocols_[i] &&
+        port_protocol_vector[1] == kAlternateProtocolStrings[i]) {
       protocol = static_cast<AlternateProtocol>(i);
+    }
   }
 
   if (protocol == ALTERNATE_PROTOCOL_BROKEN) {
     // Currently, we only recognize the npn-spdy protocol.
     DLOG(WARNING) << kAlternateProtocolHeader
                   << " header has unrecognized protocol: "
                   << port_protocol_vector[1];
     return;
   }
 
@@ skipping 40 matching lines @@
     return false;
 
   std::list<HostPortPair>::const_iterator it;
   for (it = exclusions->begin(); it != exclusions->end(); ++it)
     if (it->Equals(endpoint))
       return true;
   return false;
 }
 
 // static
+void HttpStreamFactory::SetNextProtos(const std::vector<std::string>& value) {
+  if (!next_protos_)
+    next_protos_ = new std::vector<std::string>;
+
+  *next_protos_ = value;
+
+  for (uint32 i = 0; i < NUM_ALTERNATE_PROTOCOLS; ++i)
+    enabled_protocols_[i] = false;
+
+  // TODO(rtenneti): bug 116575 - consider using same strings/enums for SPDY
+  // versions in next_protos and kAlternateProtocolStrings.
+  for (uint32 i = 0; i < value.size(); ++i) {
+    if (value[i] == "spdy/1") {
+      enabled_protocols_[NPN_SPDY_1] = true;
+    } else if (value[i] == "spdy/2") {
+      enabled_protocols_[NPN_SPDY_2] = true;
+    } else if (value[i] == "spdy/2.1") {
+      enabled_protocols_[NPN_SPDY_21] = true;
+    }
+  }
+  enabled_protocols_[NPN_SPDY_1] = false;
+}
+
+// static
 void HttpStreamFactory::SetHostMappingRules(const std::string& rules) {
   HostMappingRules* host_mapping_rules = new HostMappingRules;
   host_mapping_rules->SetRulesFromString(rules);
   delete host_mapping_rules_;
   host_mapping_rules_ = host_mapping_rules;
 }
 
 HttpStreamFactory::HttpStreamFactory() {}
 
 // static
 const HostMappingRules& HttpStreamFactory::host_mapping_rules() {
   if (!host_mapping_rules_)
     host_mapping_rules_ = new HostMappingRules;
   return *host_mapping_rules_;
 }
 
 }  // namespace net