Log server advertised protos and the selected

net/http/http_stream_factory_impl_job.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_stream_factory_impl_job.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
@@ skipping 47 matching lines @@
   const std::string url_;
 };
 
 Value* HttpStreamJobParameters::ToValue() const {
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString("original_url", original_url_);
   dict->SetString("url", url_);
   return dict;
 }
 
+// Parameters associated with the Proto (with NPN negotiation) of a HTTP stream.
+class HttpStreamProtoParameters : public NetLog::EventParameters {
+ public:
+  static scoped_refptr<HttpStreamProtoParameters> Create(
+      const SSLClientSocket::NextProtoStatus status,
+      const std::string& proto,
+      const std::string& server_protos) {
+    return make_scoped_refptr(new HttpStreamProtoParameters(
+        status, proto, server_protos));
+  }
+
+  virtual Value* ToValue() const;
+
+ private:
+  HttpStreamProtoParameters(const SSLClientSocket::NextProtoStatus status,
+                            const std::string& proto,
+                            const std::string& server_protos)
+      : status_(status),
+        proto_(proto),
+        server_protos_(server_protos) {}
+
+  const SSLClientSocket::NextProtoStatus status_;
+  const std::string proto_;
+  const std::string server_protos_;
+};
+
+Value* HttpStreamProtoParameters::ToValue() const {
+  DictionaryValue* dict = new DictionaryValue();
+
+  dict->SetString("next_proto_status",
+                  SSLClientSocket::NextProtoStatusToString(status_));
+  dict->SetString("proto", proto_);
+  dict->SetString("server_protos",
+                  SSLClientSocket::ServerProtosToString(server_protos_));
+  return dict;
+}
+
 HttpStreamFactoryImpl::Job::Job(HttpStreamFactoryImpl* stream_factory,
                                 HttpNetworkSession* session,
                                 const HttpRequestInfo& request_info,
                                 const SSLConfig& server_ssl_config,
                                 const SSLConfig& proxy_ssl_config,
                                 const BoundNetLog& net_log)
     : request_(NULL),
       request_info_(request_info),
       server_ssl_config_(server_ssl_config),
       proxy_ssl_config_(proxy_ssl_config),
@@ skipping 626 matching lines @@
   //     then the SSL handshake ran with an unrecoverable error.
   //   otherwise, the error came from one of the other pools.
   bool ssl_started = using_ssl_ && (result == OK || connection_->socket() ||
                                     connection_->is_ssl_error());
 
   if (ssl_started && (result == OK || IsCertificateError(result))) {
     SSLClientSocket* ssl_socket =
       static_cast<SSLClientSocket*>(connection_->socket());
     if (ssl_socket->was_npn_negotiated()) {
       was_npn_negotiated_ = true;
+      std::string proto;
+      std::string server_protos;
+      SSLClientSocket::NextProtoStatus status =
+          ssl_socket->GetNextProto(&proto, &server_protos);
+      net_log_.AddEvent(
+           NetLog::TYPE_HTTP_STREAM_REQUEST_PROTO,
+           HttpStreamProtoParameters::Create(status, proto, server_protos));
       if (ssl_socket->was_spdy_negotiated())
         SwitchToSpdyMode();
     }
     if (ShouldForceSpdySSL())
       SwitchToSpdyMode();
   } else if (proxy_info_.is_https() && connection_->socket() &&
         result == OK) {
     HttpProxyClientSocket* proxy_socket =
       static_cast<HttpProxyClientSocket*>(connection_->socket());
     if (proxy_socket->using_spdy()) {
@@ skipping 424 matching lines @@
     return false;
   }
   if (request_info_.method != "GET" && request_info_.method != "HEAD") {
     return false;
   }
   return stream_factory_->http_pipelined_host_pool_.IsHostEligibleForPipelining(
       origin_);
 }
 
 }  // namespace net