Changed the jingle network code in ChromeAsyncSocket to use the client socket pool. This also all...

jingle/notifier/base/fake_ssl_client_socket.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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 "jingle/notifier/base/fake_ssl_client_socket.h"
 
 #include <cstdlib>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
+#include "net/socket/client_socket_handle.h"
 
 namespace notifier {
 
 namespace {
 
 // The constants below were taken from libjingle's socketadapters.cc.
 // Basically, we do a "fake" SSL handshake to fool proxies into
 // thinking this is a real SSL connection.
 
 // This is a SSL v2 CLIENT_HELLO message.
@@ skipping 46 matching lines @@
   return base::StringPiece(reinterpret_cast<const char*>(kSslClientHello),
                            arraysize(kSslClientHello));
 }
 
 base::StringPiece FakeSSLClientSocket::GetSslServerHello() {
   return base::StringPiece(reinterpret_cast<const char*>(kSslServerHello),
                            arraysize(kSslServerHello));
 }
 
 FakeSSLClientSocket::FakeSSLClientSocket(
-    net::ClientSocket* transport_socket)
+    net::ClientSocketHandle* transport_socket)
     : connect_callback_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
                         &FakeSSLClientSocket::OnConnectDone),
       send_client_hello_callback_(
           ALLOW_THIS_IN_INITIALIZER_LIST(this),
           &FakeSSLClientSocket::OnSendClientHelloDone),
       verify_server_hello_callback_(
           ALLOW_THIS_IN_INITIALIZER_LIST(this),
           &FakeSSLClientSocket::OnVerifyServerHelloDone),
-      transport_socket_(transport_socket),
+      transport_(transport_socket),
       next_handshake_state_(STATE_NONE),
       handshake_completed_(false),
       user_connect_callback_(NULL),
       write_buf_(NewDrainableIOBufferWithSize(arraysize(kSslClientHello))),
       read_buf_(NewDrainableIOBufferWithSize(arraysize(kSslServerHello))) {
-  CHECK(transport_socket_.get());
+  CHECK(transport_.get());
   std::memcpy(write_buf_->data(), kSslClientHello, arraysize(kSslClientHello));
 }
 
 FakeSSLClientSocket::~FakeSSLClientSocket() {}
 
 int FakeSSLClientSocket::Read(net::IOBuffer* buf, int buf_len,
                              net::CompletionCallback* callback) {
   DCHECK_EQ(next_handshake_state_, STATE_NONE);
   DCHECK(handshake_completed_);
-  return transport_socket_->Read(buf, buf_len, callback);
+  return transport_->socket()->Read(buf, buf_len, callback);
 }
 
 int FakeSSLClientSocket::Write(net::IOBuffer* buf, int buf_len,
                               net::CompletionCallback* callback) {
   DCHECK_EQ(next_handshake_state_, STATE_NONE);
   DCHECK(handshake_completed_);
-  return transport_socket_->Write(buf, buf_len, callback);
+  return transport_->socket()->Write(buf, buf_len, callback);
 }
 
 bool FakeSSLClientSocket::SetReceiveBufferSize(int32 size) {
-  return transport_socket_->SetReceiveBufferSize(size);
+  return transport_->socket()->SetReceiveBufferSize(size);
 }
 
 bool FakeSSLClientSocket::SetSendBufferSize(int32 size) {
-  return transport_socket_->SetSendBufferSize(size);
+  return transport_->socket()->SetSendBufferSize(size);
 }
 
 int FakeSSLClientSocket::Connect(net::CompletionCallback* callback) {
   // We don't support synchronous operation, even if
   // |transport_socket_| does.
   DCHECK(callback);
   DCHECK_EQ(next_handshake_state_, STATE_NONE);
   DCHECK(!handshake_completed_);
   DCHECK(!user_connect_callback_);
   DCHECK_EQ(write_buf_->BytesConsumed(), 0);
@@ skipping 42 matching lines @@
 }
 
 void FakeSSLClientSocket::DoHandshakeLoopWithUserConnectCallback() {
   int status = DoHandshakeLoop();
   if (status != net::ERR_IO_PENDING) {
     RunUserConnectCallback(status);
   }
 }
 
 int FakeSSLClientSocket::DoConnect() {
-  int status = transport_socket_->Connect(&connect_callback_);
-  if (status != net::OK) {
+  // The passed in socket may already be connected.
+  int status = net::OK;
+  if (!transport_->socket()->IsConnected())
+    status = transport_->socket()->Connect(&connect_callback_);
+
+  if (status != net::OK)
     return status;
-  }
+
   ProcessConnectDone();
   return net::OK;
 }
 
 void FakeSSLClientSocket::OnConnectDone(int status) {
   DCHECK_NE(status, net::ERR_IO_PENDING);
   DCHECK_LE(status, net::OK);
   DCHECK(user_connect_callback_);
   if (status != net::OK) {
     RunUserConnectCallback(status);
     return;
   }
   ProcessConnectDone();
   DoHandshakeLoopWithUserConnectCallback();
 }
 
 void FakeSSLClientSocket::ProcessConnectDone() {
   DCHECK_EQ(write_buf_->BytesConsumed(), 0);
   DCHECK_EQ(read_buf_->BytesConsumed(), 0);
   next_handshake_state_ = STATE_SEND_CLIENT_HELLO;
 }
 
 int FakeSSLClientSocket::DoSendClientHello() {
-  int status = transport_socket_->Write(
+  int status = transport_->socket()->Write(
       write_buf_, write_buf_->BytesRemaining(),
       &send_client_hello_callback_);
   if (status < net::OK) {
     return status;
   }
   ProcessSendClientHelloDone(static_cast<size_t>(status));
   return net::OK;
 }
 
 void FakeSSLClientSocket::OnSendClientHelloDone(int status) {
@@ skipping 12 matching lines @@
   DCHECK_EQ(read_buf_->BytesConsumed(), 0);
   if (written < static_cast<size_t>(write_buf_->BytesRemaining())) {
     next_handshake_state_ = STATE_SEND_CLIENT_HELLO;
     write_buf_->DidConsume(written);
   } else {
     next_handshake_state_ = STATE_VERIFY_SERVER_HELLO;
   }
 }
 
 int FakeSSLClientSocket::DoVerifyServerHello() {
-  int status = transport_socket_->Read(
+  int status = transport_->socket()->Read(
       read_buf_, read_buf_->BytesRemaining(),
       &verify_server_hello_callback_);
   if (status < net::OK) {
     return status;
   }
   size_t read = static_cast<size_t>(status);
   return ProcessVerifyServerHelloDone(read);
 }
 
 void FakeSSLClientSocket::OnVerifyServerHelloDone(int status) {
@@ skipping 31 matching lines @@
     next_handshake_state_ = STATE_VERIFY_SERVER_HELLO;
     read_buf_->DidConsume(read);
   } else {
     next_handshake_state_ = STATE_NONE;
     handshake_completed_ = true;
   }
   return net::OK;
 }
 
 void FakeSSLClientSocket::Disconnect() {
-  transport_socket_->Disconnect();
+  transport_->Reset();
   next_handshake_state_ = STATE_NONE;
   handshake_completed_ = false;
   user_connect_callback_ = NULL;
   write_buf_->SetOffset(0);
   read_buf_->SetOffset(0);
 }
 
 bool FakeSSLClientSocket::IsConnected() const {
-  return handshake_completed_ && transport_socket_->IsConnected();
+  return handshake_completed_ && transport_->socket()->IsConnected();
 }
 
 bool FakeSSLClientSocket::IsConnectedAndIdle() const {
-  return handshake_completed_ && transport_socket_->IsConnectedAndIdle();
+  return handshake_completed_ && transport_->socket()->IsConnectedAndIdle();
 }
 
 int FakeSSLClientSocket::GetPeerAddress(net::AddressList* address) const {
-  return transport_socket_->GetPeerAddress(address);
+  return transport_->socket()->GetPeerAddress(address);
 }
 
 const net::BoundNetLog& FakeSSLClientSocket::NetLog() const {
-  return transport_socket_->NetLog();
+  return transport_->socket()->NetLog();
 }
 
 void FakeSSLClientSocket::SetSubresourceSpeculation() {
-  transport_socket_->SetSubresourceSpeculation();
+  transport_->socket()->SetSubresourceSpeculation();
 }
 
 void FakeSSLClientSocket::SetOmniboxSpeculation() {
-  transport_socket_->SetOmniboxSpeculation();
+  transport_->socket()->SetOmniboxSpeculation();
 }
 
 bool FakeSSLClientSocket::WasEverUsed() const {
-  return transport_socket_->WasEverUsed();
+  return transport_->socket()->WasEverUsed();
 }
 
 bool FakeSSLClientSocket::UsingTCPFastOpen() const {
-  return transport_socket_->UsingTCPFastOpen();
+  return transport_->socket()->UsingTCPFastOpen();
 }
 
 }  // namespace notifier