Add field trial stats for alternate_protocol.

net/http/http_network_transaction.cc

 // Copyright (c) 2010 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_transaction.h"
 
 #include "base/compiler_specific.h"
 #include "base/field_trial.h"
 #include "base/format_macros.h"
 #include "base/histogram.h"
@@ skipping 137 matching lines @@
   if (request_info->extra_headers.GetHeader(HttpRequestHeaders::kUserAgent,
                                             &user_agent))
     request_headers->SetHeader(HttpRequestHeaders::kUserAgent, user_agent);
 
   request_headers->MergeFrom(authorization_headers);
 }
 
 void ProcessAlternateProtocol(const HttpResponseHeaders& headers,
                               const HostPortPair& http_host_port_pair,
                               HttpAlternateProtocols* alternate_protocols) {
-  if (!g_next_protos || g_next_protos->empty()) {
-    // This implies that NPN is not supported.  We don't currently support any
-    // alternate protocols that don't use NPN.
-    return;
-  }
 
   std::string alternate_protocol_str;
   if (!headers.EnumerateHeader(NULL, HttpAlternateProtocols::kHeader,
                                &alternate_protocol_str)) {
     // Header is not present.
     return;
   }
 
   std::vector<std::string> port_protocol_vector;
   SplitString(alternate_protocol_str, ':', &port_protocol_vector);
@@ skipping 583 matching lines @@
     url_canon::Replacements<char> replacements;
     const std::string port_str = IntToString(endpoint_.port);
     replacements.SetPort(port_str.c_str(),
                          url_parse::Component(0, port_str.size()));
     replacements.SetHost(endpoint_.host.c_str(),
                          url_parse::Component(0, endpoint_.host.size()));
     alternate_endpoint_url = curr_endpoint_url->ReplaceComponents(replacements);
     curr_endpoint_url = &alternate_endpoint_url;
   }
 
-  if (alternate_protocol_mode_ == kUnspecified) {
-    const HttpAlternateProtocols& alternate_protocols =
-        session_->alternate_protocols();
-    if (alternate_protocols.HasAlternateProtocolFor(endpoint_)) {
+  const HttpAlternateProtocols& alternate_protocols =
+      session_->alternate_protocols();
+  if (alternate_protocols.HasAlternateProtocolFor(endpoint_)) {
+    response_.was_alternate_protocol_available = true;
+    if (alternate_protocol_mode_ == kUnspecified) {
       HttpAlternateProtocols::PortProtocolPair alternate =
           alternate_protocols.GetAlternateProtocolFor(endpoint_);
       if (alternate.protocol != HttpAlternateProtocols::BROKEN) {
         DCHECK_EQ(HttpAlternateProtocols::NPN_SPDY_1, alternate.protocol);
         endpoint_.port = alternate.port;
         alternate_protocol_ = HttpAlternateProtocols::NPN_SPDY_1;
         alternate_protocol_mode_ = kUsingAlternateProtocol;
 
         url_canon::Replacements<char> replacements;
         replacements.SetScheme("https",
@@ skipping 1252 matching lines @@
       endpoint_);
 
   alternate_protocol_mode_ = kDoNotUseAlternateProtocol;
   if (connection_->socket())
     connection_->socket()->Disconnect();
   connection_->Reset();
   next_state_ = STATE_INIT_CONNECTION;
 }
 
 }  // namespace net