Add the spdy protocol to the information displayed about a spdy session in net-internals.

net/spdy/spdy_session.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/spdy/spdy_session.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop.h"
@@ skipping 1092 matching lines @@
   dict->SetString("host_port_pair", host_port_proxy_pair_.first.ToString());
   dict->SetString("proxy", host_port_proxy_pair_.second.ToURI());
 
   dict->SetInteger("active_streams", active_streams_.size());
 
   dict->SetInteger("unclaimed_pushed_streams",
       unclaimed_pushed_streams_.size());
 
   dict->SetBoolean("is_secure", is_secure_);
 
+  SSLClientSocket::NextProto proto = SSLClientSocket::kProtoUnknown;
+  if (is_secure_) {
+    SSLClientSocket* ssl_socket =
+        reinterpret_cast<SSLClientSocket*>(connection_->socket());

[eroman, 2012/03/07 19:27:32]

Are you absolutely sure about this? Reinterpret cast scares the hell out of me.

[mmenke, 2012/03/07 19:32:32]

Drive by comment:  Looks like all the other instances of
reinterpret_cast<SSLClientSocket*> in this file either have a
"DCHECK(is_secure_)" or an "if (is_secure_)".  I'd suggest the latter here,
seeing as if that assumption ever changes, testing of net-internals is pretty
sparse, so it could easily go unnoticed.

[Ryan Hamilton, 2012/03/07 19:46:22]

Heh, yes I agree.  This is already wrapped in an if (is_secure) on line 1114,
right?

[Ryan Hamilton, 2012/03/07 19:46:22]

eroman: yes in the sense that we do this repeatedly in spdy_session.cc:

grep 'reinterpret_cast<SSLClientSocket' net/spdy/spdy_session.cc | wc -l
8

[mmenke, 2012/03/07 19:47:59]

Oops...Indeed it is.  Amusingly, I just looked at other instances of
reinterpret_cast<SSLClientSocket*>, without double-checking that this one had
it.

+    DCHECK(ssl_socket);
+    proto = ssl_socket->protocol_negotiated();
+  }
+  dict->SetString("protocol_negotiated",
+                  SSLClientSocket::NextProtoToString(proto));
+
   dict->SetInteger("error", error_);
   dict->SetInteger("max_concurrent_streams", max_concurrent_streams_);
 
   dict->SetInteger("streams_initiated_count", streams_initiated_count_);
   dict->SetInteger("streams_pushed_count", streams_pushed_count_);
   dict->SetInteger("streams_pushed_and_claimed_count",
       streams_pushed_and_claimed_count_);
   dict->SetInteger("streams_abandoned_count", streams_abandoned_count_);
   dict->SetInteger("frames_received", buffered_spdy_framer_.frames_received());
 
@@ skipping 756 matching lines @@
   if (it == pending_callback_map_.end())
     return;
 
   CompletionCallback callback = it->second.callback;
   int result = it->second.result;
   pending_callback_map_.erase(it);
   callback.Run(result);
 }
 
 }  // namespace net