Add a new GetNegotiatedProtocol method to StreamSocket and implement in all subclasses.

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 <map>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 420 matching lines @@
 
   state_ = CONNECTED;
   connection_.reset(connection);
   connection_->AddLayeredPool(this);
   is_secure_ = is_secure;
   certificate_error_code_ = certificate_error_code;
 
   NextProto protocol = g_default_protocol;
   if (is_secure_) {
     SSLClientSocket* ssl_socket = GetSSLClientSocket();
-    NextProto protocol_negotiated = ssl_socket->protocol_negotiated();
+    NextProto protocol_negotiated = ssl_socket->GetNegotiatedProtocol();
     if (protocol_negotiated != kProtoUnknown) {
       protocol = protocol_negotiated;
     }
 
     if (ssl_socket->WasDomainBoundCertSent()) {
       // According to the SPDY spec, the credential associated with the TLS
       // connection is stored in slot[1].
       credential_state_.SetHasCredential(GURL("https://" +
                                               host_port_pair().ToString()));
     }
@@ skipping 174 matching lines @@
   DCHECK(priority >= net::HIGHEST && priority < net::NUM_PRIORITIES);
 
   DCHECK_EQ(active_streams_[stream_id].get(), stream.get());
   return OK;
 }
 
 bool SpdySession::NeedsCredentials() const {
   if (!is_secure_)
     return false;
   SSLClientSocket* ssl_socket = GetSSLClientSocket();
-  if (ssl_socket->protocol_negotiated() < kProtoSPDY3)
+  if (ssl_socket->GetNegotiatedProtocol() < kProtoSPDY3)
     return false;
   return ssl_socket->WasDomainBoundCertSent();
 }
 
 void SpdySession::AddPooledAlias(const HostPortProxyPair& alias) {
   pooled_aliases_.insert(alias);
 }
 
 int SpdySession::GetProtocolVersion() const {
   DCHECK(buffered_spdy_framer_.get());
@@ skipping 533 matching lines @@
 
   dict->SetInteger("active_streams", active_streams_.size());
 
   dict->SetInteger("unclaimed_pushed_streams",
       unclaimed_pushed_streams_.size());
 
   dict->SetBoolean("is_secure", is_secure_);
 
   NextProto proto = kProtoUnknown;
   if (is_secure_) {
-    proto = GetSSLClientSocket()->protocol_negotiated();
+    proto = GetSSLClientSocket()->GetNegotiatedProtocol();
   }
   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",
@@ skipping 99 matching lines @@
 bool SpdySession::GetSSLInfo(SSLInfo* ssl_info,
                              bool* was_npn_negotiated,
                              NextProto* protocol_negotiated) {
   if (!is_secure_) {
     *protocol_negotiated = kProtoUnknown;
     return false;
   }
   SSLClientSocket* ssl_socket = GetSSLClientSocket();
   ssl_socket->GetSSLInfo(ssl_info);
   *was_npn_negotiated = ssl_socket->was_npn_negotiated();
-  *protocol_negotiated = ssl_socket->protocol_negotiated();
+  *protocol_negotiated = ssl_socket->GetNegotiatedProtocol();
   return true;
 }
 
 bool SpdySession::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   if (!is_secure_)
     return false;
   GetSSLClientSocket()->GetSSLCertRequestInfo(cert_request_info);
   return true;
 }
@@ skipping 654 matching lines @@
 SSLClientSocket* SpdySession::GetSSLClientSocket() const {
   if (!is_secure_)
     return NULL;
   SSLClientSocket* ssl_socket =
       reinterpret_cast<SSLClientSocket*>(connection_->socket());
   DCHECK(ssl_socket);
   return ssl_socket;
 }
 
 }  // namespace net