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::supported_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 = NPN_SPDY_1; i < NUM_ALTERNATE_PROTOCOLS; ++i)

[Ryan Hamilton, 2012/03/02 16:46:53]

Start at 0 just to be simple.

[ramant (doing other things), 2012/03/02 18:40:41]

Done.

+    supported_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) {

[Ryan Hamilton, 2012/03/02 16:46:53]

Please start at 0.  If we want to avoid SPDY_1, either set the boolean to false,
or else remove it from the enum definition.

[ramant (doing other things), 2012/03/02 18:40:41]

Done.

-    if (port_protocol_vector[1] == kAlternateProtocolStrings[i])
+    if (supported_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 = NPN_SPDY_1; i < NUM_ALTERNATE_PROTOCOLS; ++i)
+    supported_protocols_[i] = false;
+
+  for (uint32 i = 0; i < value.size(); ++i) {

[Ryan Hamilton, 2012/03/02 16:46:53]

Let's not hard-code the strings again, please.  How about something like:

for (uint32 i = 0; i < value.size(); ++i) {
  for (int p = 0; p < NUM_ALTERNATE_PROTOCOLS; ++p) {
    if (values[i] == kAlternateProtocolStrings[p]) {
       .....
    }
  }
}

[ramant (doing other things), 2012/03/02 18:40:41]

As we had discussed, added a TODO and issue 116575. kAlternateProtocolStrings
have different strings from next_protos strings, thus wasn't able to use
kAlternateProtocolStrings.

+    if (value[i] == "spdy/1") {
+      supported_protocols_[NPN_SPDY_1] = true;
+    } else if (value[i] == "spdy/2") {
+      supported_protocols_[NPN_SPDY_2] = true;
+    } else if (value[i] == "spdy/2.1") {
+      supported_protocols_[NPN_SPDY_21] = true;
+    }
+  }
+}
+
+// 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