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 46 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.

[wtc, 2011/10/11 23:43:04]

Nit: it seems useful to preserve this comment in the new code.

[agl, 2011/10/17 17:37:24]

Done.

-  static const char kNpnProtosFullV1[] = "\x08http/1.1\x06spdy/1";
-  // No spdy specified.
-  static const char kNpnProtosHttpOnly[] = "\x08http/1.1\x07http1.1";
-
   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;
     std::vector<std::string> name_value;
     base::SplitString(element, '=', &name_value);
     const std::string& option = name_value[0];
     const std::string value = name_value.size() > 1 ? name_value[1] : "";
 
     if (option == kOff) {
       HttpStreamFactory::set_spdy_enabled(false);
     } else if (option == kDisableSSL) {
       SpdySession::SetSSLMode(false);  // Disable SSL
       HttpStreamFactory::set_force_spdy_over_ssl(false);
       HttpStreamFactory::set_force_spdy_always(true);
     } else if (option == kSSL) {
       HttpStreamFactory::set_force_spdy_over_ssl(true);
       HttpStreamFactory::set_force_spdy_always(true);
     } 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;
+      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) {
       HttpAlternateProtocols::PortProtocolPair pair;
       pair.port = 443;
       pair.protocol = HttpAlternateProtocols::NPN_SPDY_2;
       HttpAlternateProtocols::ForceAlternateProtocol(pair);
@@ skipping 31 matching lines @@
 
   if (session_)
     session_->CloseIdleConnections();
 }
 
 void HttpNetworkLayer::OnResume() {
   suspended_ = false;
 }
 
 }  // namespace net