Integrate the SpdyProxyClientSocket into the HttpStreamRequest...

net/socket/socket_test_util.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/socket/socket_test_util.h"
 
 #include <algorithm>
 #include <vector>
 
 
@@ skipping 109 matching lines @@
       connected_(false),
       net_log_(NetLog::Source(), net_log) {
 }
 
 void MockClientSocket::GetSSLInfo(net::SSLInfo* ssl_info) {
   NOTREACHED();
 }
 
 void MockClientSocket::GetSSLCertRequestInfo(
     net::SSLCertRequestInfo* cert_request_info) {
-  NOTREACHED();
 }
 
 SSLClientSocket::NextProtoStatus
 MockClientSocket::GetNextProto(std::string* proto) {
   proto->clear();
   return SSLClientSocket::kNextProtoUnsupported;
 }
 
 void MockClientSocket::Disconnect() {
   connected_ = false;
@@ skipping 1087 matching lines @@
 const int kSOCKS5GreetResponseLength = arraysize(kSOCKS5GreetResponse);
 
 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);
 
-MockSSLClientSocketPool::MockSSLClientSocketPool(
-    int max_sockets,
-    int max_sockets_per_group,
-    ClientSocketPoolHistograms* histograms,
-    ClientSocketFactory* socket_factory,
-    TCPClientSocketPool* tcp_pool)
-    : SSLClientSocketPool(max_sockets, max_sockets_per_group, histograms,
-                          NULL, NULL, socket_factory,
-                          tcp_pool,
-                          NULL, NULL, NULL, NULL),
-      client_socket_factory_(socket_factory),
-      release_count_(0),
-      cancel_count_(0) {
-}
-
-int MockSSLClientSocketPool::RequestSocket(const std::string& group_name,
-                                           const void* socket_params,
-                                           RequestPriority priority,
-                                           ClientSocketHandle* handle,
-                                           CompletionCallback* callback,
-                                           const BoundNetLog& net_log) {
-  ClientSocket* socket = client_socket_factory_->CreateTCPClientSocket(
-      AddressList(), net_log.net_log(), net::NetLog::Source());
-  MockConnectJob* job = new MockConnectJob(socket, handle, callback);
-  job_list_.push_back(job);
-  handle->set_pool_id(1);
-  return job->Connect();
-}
-
-void MockSSLClientSocketPool::CancelRequest(const std::string& group_name,
-                                            ClientSocketHandle* handle) {
-  std::vector<MockConnectJob*>::iterator i;
-  for (i = job_list_.begin(); i != job_list_.end(); ++i) {
-    if ((*i)->CancelHandle(handle)) {
-      cancel_count_++;
-      break;
-    }
-  }
-}
-
-void MockSSLClientSocketPool::ReleaseSocket(const std::string& group_name,
-                                            ClientSocket* socket, int id) {
-  EXPECT_EQ(1, id);
-  release_count_++;
-  delete socket;
-}
-
-MockSSLClientSocketPool::~MockSSLClientSocketPool() {}
-
-MockSSLClientSocketPool::MockConnectJob::MockConnectJob(
-    ClientSocket* socket,
-    ClientSocketHandle* handle,
-    CompletionCallback* callback)
-    : socket_(socket),
-      handle_(handle),
-      user_callback_(callback),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          connect_callback_(this, &MockConnectJob::OnConnect)) {
-}
-
-int MockSSLClientSocketPool::MockConnectJob::Connect() {
-  int rv = socket_->Connect(&connect_callback_);
-  if (rv == OK) {
-    user_callback_ = NULL;
-    OnConnect(OK);
-  }
-  return rv;
-}
-
-bool MockSSLClientSocketPool::MockConnectJob::CancelHandle(
-    const ClientSocketHandle* handle) {
-  if (handle != handle_)
-    return false;
-  socket_.reset();
-  handle_ = NULL;
-  user_callback_ = NULL;
-  return true;
-}
-
-void MockSSLClientSocketPool::MockConnectJob::OnConnect(int rv) {
-  if (!socket_.get())
-    return;
-  if (rv == OK) {
-    handle_->set_socket(socket_.release());
-  } else {
-    socket_.reset();
-  }
-
-  handle_ = NULL;
-
-  if (user_callback_) {
-    CompletionCallback* callback = user_callback_;
-    user_callback_ = NULL;
-    callback->Run(rv);
-  }
-}
 }  // namespace net