Change SpdySession::GetSSLInfo to get the SSLInfo from the underlying socket

net/socket/socket_test_util.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/socket/socket_test_util.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 686 matching lines @@
   bool rv = ParseIPLiteralToNumber("192.0.2.33", &ip);
   CHECK(rv);
   *address = IPEndPoint(ip, 123);
   return OK;
 }
 
 const BoundNetLog& MockClientSocket::NetLog() const {
   return net_log_;
 }
 
-void MockClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
-  NOTREACHED();
-}
-
 void MockClientSocket::GetSSLCertRequestInfo(
   SSLCertRequestInfo* cert_request_info) {
 }
 
 int MockClientSocket::ExportKeyingMaterial(const base::StringPiece& label,
                                            bool has_context,
                                            const base::StringPiece& context,
                                            unsigned char* out,
                                            unsigned int outlen) {
   memset(out, 'A', outlen);
@@ skipping 144 matching lines @@
   return num_bytes_read_;
 }
 
 base::TimeDelta MockTCPClientSocket::GetConnectTimeMicros() const {
   // Dummy value.
   static const base::TimeDelta kTestingConnectTimeMicros =
       base::TimeDelta::FromMicroseconds(20);
   return kTestingConnectTimeMicros;
 }
 
+bool MockTCPClientSocket::WasNpnNegotiated() const {
+  return false;
+}
+
+bool MockTCPClientSocket::GetSSLInfo(SSLInfo* ssl_info) const {
+  return false;
+}
+
 void MockTCPClientSocket::OnReadComplete(const MockRead& data) {
   // There must be a read pending.
   DCHECK(pending_buf_);
   // You can't complete a read with another ERR_IO_PENDING status code.
   DCHECK_NE(ERR_IO_PENDING, data.result);
   // Since we've been waiting for data, need_read_data_ should be true.
   DCHECK(need_read_data_);
 
   read_data_ = data;
   need_read_data_ = false;
@@ skipping 50 matching lines @@
 DeterministicMockTCPClientSocket::DeterministicMockTCPClientSocket(
     net::NetLog* net_log, DeterministicSocketData* data)
     : MockClientSocket(net_log),
       write_pending_(false),
       write_result_(0),
       read_data_(),
       read_buf_(NULL),
       read_buf_len_(0),
       read_pending_(false),
       data_(data),
-      was_used_to_convey_data_(false) {}
+      was_used_to_convey_data_(false) {
+  peer_addr_ = data->connect_data().peer_addr;
+}
 
 DeterministicMockTCPClientSocket::~DeterministicMockTCPClientSocket() {}
 
 void DeterministicMockTCPClientSocket::CompleteWrite() {
   was_used_to_convey_data_ = true;
   write_pending_ = false;
   write_callback_.Run(write_result_);
 }
 
 int DeterministicMockTCPClientSocket::CompleteRead() {
@@ skipping 106 matching lines @@
 }
 
 int64 DeterministicMockTCPClientSocket::NumBytesRead() const {
   return -1;
 }
 
 base::TimeDelta DeterministicMockTCPClientSocket::GetConnectTimeMicros() const {
   return base::TimeDelta::FromMicroseconds(-1);
 }
 
+bool DeterministicMockTCPClientSocket::WasNpnNegotiated() const {
+  return false;
+}
+
+bool DeterministicMockTCPClientSocket::GetSSLInfo(SSLInfo* ssl_info) const {
+  return false;
+}
+
 void DeterministicMockTCPClientSocket::OnReadComplete(const MockRead& data) {}
 
 // static
 void MockSSLClientSocket::ConnectCallback(
     MockSSLClientSocket *ssl_client_socket,
     const CompletionCallback& callback,
     int rv) {
   if (rv == OK)
     ssl_client_socket->connected_ = true;
   callback.Run(rv);
@@ skipping 67 matching lines @@
 }
 
 int MockSSLClientSocket::GetPeerAddress(IPEndPoint* address) const {
   return transport_->socket()->GetPeerAddress(address);
 }
 
 base::TimeDelta MockSSLClientSocket::GetConnectTimeMicros() const {
   return base::TimeDelta::FromMicroseconds(-1);
 }
 
-void MockSSLClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
+bool MockSSLClientSocket::GetSSLInfo(SSLInfo* ssl_info) const {
   ssl_info->Reset();
   ssl_info->cert = data_->cert;
   ssl_info->client_cert_sent = data_->client_cert_sent;
   ssl_info->channel_id_sent = data_->channel_id_sent;
+  return true;
 }
 
 void MockSSLClientSocket::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   DCHECK(cert_request_info);
   if (data_->cert_request_info) {
     cert_request_info->host_and_port =
         data_->cert_request_info->host_and_port;
     cert_request_info->client_certs = data_->cert_request_info->client_certs;
   } else {
@@ skipping 12 matching lines @@
   if (is_npn_state_set_)
     return new_npn_value_;
   return data_->was_npn_negotiated;
 }
 
 bool MockSSLClientSocket::set_was_npn_negotiated(bool negotiated) {
   is_npn_state_set_ = true;
   return new_npn_value_ = negotiated;
 }
 
+bool MockSSLClientSocket::WasNpnNegotiated() const {
+  return was_npn_negotiated();
+}
+
 NextProto MockSSLClientSocket::GetNegotiatedProtocol() const {
   if (is_protocol_negotiated_set_)
     return protocol_negotiated_;
   return data_->protocol_negotiated;
 }
 
 void MockSSLClientSocket::set_protocol_negotiated(
     NextProto protocol_negotiated) {
   is_protocol_negotiated_set_ = true;
   protocol_negotiated_ = protocol_negotiated;
@@ skipping 435 matching lines @@
 
 const char kSOCKS5OkRequest[] =
     { 0x05, 0x01, 0x00, 0x03, 0x04, 'h', 'o', 's', 't', 0x00, 0x50 };
 const int kSOCKS5OkRequestLength = arraysize(kSOCKS5OkRequest);
 
 const char kSOCKS5OkResponse[] =
     { 0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x00, 0x50 };
 const int kSOCKS5OkResponseLength = arraysize(kSOCKS5OkResponse);
 
 }  // namespace net