net: rework the NPN patch.

net/http/http_network_layer.cc

 // Copyright (c) 2011 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_network_layer.h"
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
@@ skipping 48 matching lines @@
   // We want an A/B experiment between SPDY enabled and SPDY disabled,
   // but only for pages where SPDY *could have been* negotiated.  To do
   // this, we use NPN, but prevent it from negotiating SPDY.  If the
   // server negotiates HTTP, rather than SPDY, today that will only happen
   // on servers that installed NPN (and could have done SPDY).  But this is
   // a bit of a hack, as this correlation between NPN and SPDY is not
   // really guaranteed.
   static const char kEnableNPN[] = "npn";
   static const char kEnableNpnHttpOnly[] = "npn-http";
 
-  // Except for the first element, the order is irrelevant.  First element
-  // specifies the fallback in case nothing matches
-  // (SSLClientSocket::kNextProtoNoOverlap).  Otherwise, the SSL library
-  // will choose the first overlapping protocol in the server's list, since
-  // it presumedly has a better understanding of which protocol we should
-  // use, therefore the rest of the ordering here is not important.
-  static const char kNpnProtosFull[] = "\x08http/1.1\x06spdy/2";
-  // This is a temporary hack to pretend we support version 1.
-  static const char kNpnProtosFullV1[] = "\x08http/1.1\x06spdy/1";
-  // No spdy specified.
-  static const char kNpnProtosHttpOnly[] = "\x08http/1.1\x07http1.1";
-
   static const char kInitialMaxConcurrentStreams[] = "init-max-streams";
 
   std::vector<std::string> spdy_options;
   base::SplitString(mode, ',', &spdy_options);
 
   bool use_alt_protocols = true;
 
   for (std::vector<std::string>::iterator it = spdy_options.begin();
        it != spdy_options.end(); ++it) {
     const std::string& element = *it;
@@ skipping 12 matching lines @@
       HttpStreamFactory::set_force_spdy_over_ssl(true);
       HttpStreamFactory::set_force_spdy_always(true);
     } else if (option == kDisablePing) {
       SpdySession::set_enable_ping_based_connection_checking(false);
     } else if (option == kExclude) {
       HttpStreamFactory::add_forced_spdy_exclusion(value);
     } else if (option == kDisableCompression) {
       spdy::SpdyFramer::set_enable_compression_default(false);
     } else if (option == kEnableNPN) {
       HttpStreamFactory::set_use_alternate_protocols(use_alt_protocols);
-      HttpStreamFactory::set_next_protos(kNpnProtosFull);
+      std::vector<std::string> next_protos;
+      next_protos.push_back("http/1.1");
+      next_protos.push_back("spdy/2");
+      HttpStreamFactory::set_next_protos(next_protos);
     } else if (option == kEnableNpnHttpOnly) {
       // Avoid alternate protocol in this case. Otherwise, browser will try SSL
       // and then fallback to http. This introduces extra load.
       HttpStreamFactory::set_use_alternate_protocols(false);
-      HttpStreamFactory::set_next_protos(kNpnProtosHttpOnly);
+      std::vector<std::string> next_protos;
+      next_protos.push_back("http/1.1");
+      next_protos.push_back("http1.1");
+      HttpStreamFactory::set_next_protos(next_protos);
     } else if (option == kEnableVersionOne) {
       spdy::SpdyFramer::set_protocol_version(1);
-      HttpStreamFactory::set_next_protos(kNpnProtosFullV1);
+      std::vector<std::string> next_protos;
+      // This is a temporary hack to pretend we support version 1.
+      next_protos.push_back("http/1.1");
+      next_protos.push_back("spdy/1");
+      HttpStreamFactory::set_next_protos(next_protos);
     } else if (option == kDisableAltProtocols) {
       use_alt_protocols = false;
       HttpStreamFactory::set_use_alternate_protocols(false);
     } else if (option == kEnableFlowControl) {
       SpdySession::set_flow_control(true);
     } else if (option == kForceAltProtocols) {
       PortAlternateProtocolPair pair;
       pair.port = 443;
       pair.protocol = NPN_SPDY_2;
       HttpServerPropertiesImpl::ForceAlternateProtocol(pair);
@@ skipping 35 matching lines @@
 
   if (session_)
     session_->CloseIdleConnections();
 }
 
 void HttpNetworkLayer::OnResume() {
   suspended_ = false;
 }
 
 }  // namespace net