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

jingle/notifier/base/chrome_async_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/chrome_async_socket.h"
 
 #if defined(OS_WIN)

[akalin, 2011/04/15 17:41:05]

remove this block since you moved it to the unittest file

[sanjeevr, 2011/04/15 18:04:33]

Done.

 #include <winsock2.h>
 #elif defined(OS_POSIX)
 #include <arpa/inet.h>
 #endif
 
 #include <algorithm>
 #include <cstring>
 #include <cstdlib>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
+#include "jingle/notifier/base/resolving_client_socket_factory.h"
 #include "net/base/address_list.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_util.h"
 #include "net/base/ssl_config_service.h"
 #include "net/base/sys_addrinfo.h"
 #include "net/socket/client_socket_factory.h"
+#include "net/socket/client_socket_handle.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/tcp_client_socket.h"
 #include "talk/base/socketaddress.h"
 
 namespace notifier {
 
 ChromeAsyncSocket::ChromeAsyncSocket(
-    net::ClientSocketFactory* client_socket_factory,
-    const net::SSLConfig& ssl_config,
-    net::CertVerifier* cert_verifier,
+    ResolvingClientSocketFactory* client_socket_factory,
     size_t read_buf_size,
     size_t write_buf_size,
     net::NetLog* net_log)
     : connect_callback_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
                         &ChromeAsyncSocket::ProcessConnectDone),
       read_callback_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
                      &ChromeAsyncSocket::ProcessReadDone),
       write_callback_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
                      &ChromeAsyncSocket::ProcessWriteDone),
       ssl_connect_callback_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
                             &ChromeAsyncSocket::ProcessSSLConnectDone),
       client_socket_factory_(client_socket_factory),
-      ssl_config_(ssl_config),
-      cert_verifier_(cert_verifier),
       bound_net_log_(
           net::BoundNetLog::Make(net_log, net::NetLog::SOURCE_SOCKET)),
       state_(STATE_CLOSED),
       error_(ERROR_NONE),
       net_error_(net::OK),
       scoped_runnable_method_factory_(
           ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       read_state_(IDLE),
       read_buf_(new net::IOBufferWithSize(read_buf_size)),
       read_start_(0U),
@@ skipping 34 matching lines @@
 void ChromeAsyncSocket::DoNetError(net::Error net_error) {
   error_ = ERROR_WINSOCK;
   net_error_ = net_error;
 }
 
 void ChromeAsyncSocket::DoNetErrorFromStatus(int status) {
   DCHECK_LT(status, net::OK);
   DoNetError(static_cast<net::Error>(status));
 }
 
-namespace {
-
-// Takes a 32-bit integer in host byte order and converts it to a
-// net::IPAddressNumber.
-net::IPAddressNumber Uint32ToIPAddressNumber(uint32 ip) {
-  uint32 ip_nbo = htonl(ip);
-  const unsigned char* const ip_start =
-      reinterpret_cast<const unsigned char*>(&ip_nbo);
-  return net::IPAddressNumber(ip_start, ip_start + (sizeof ip_nbo));
-}
-
-net::AddressList SocketAddressToAddressList(
-    const talk_base::SocketAddress& address) {
-  DCHECK_NE(address.ip(), 0U);
-  return net::AddressList(Uint32ToIPAddressNumber(address.ip()),
-                          address.port(), false);
-}
-
-}  // namespace
-
 // STATE_CLOSED -> STATE_CONNECTING
 
 bool ChromeAsyncSocket::Connect(const talk_base::SocketAddress& address) {
   if (state_ != STATE_CLOSED) {
     LOG(DFATAL) << "Connect() called on non-closed socket";
     DoNonNetError(ERROR_WRONGSTATE);
     return false;
   }
-  if (address.ip() == 0) {
+  // We can't work with an empty hostname and IP address.
+  if (address.hostname().empty() && (address.ip() == 0)) {
     DoNonNetError(ERROR_DNS);
     return false;
   }
 
   DCHECK_EQ(state_, buzz::AsyncSocket::STATE_CLOSED);
   DCHECK_EQ(read_state_, IDLE);
   DCHECK_EQ(write_state_, IDLE);
 
   state_ = STATE_CONNECTING;
 
   DCHECK(scoped_runnable_method_factory_.empty());
   scoped_runnable_method_factory_.RevokeAll();
 
-  net::AddressList address_list = SocketAddressToAddressList(address);
+  net::HostPortPair dest_host_port_pair(address.IPAsString(), address.port());
+
   transport_socket_.reset(
       client_socket_factory_->CreateTransportClientSocket(
-          address_list, bound_net_log_.net_log(), net::NetLog::Source()));
+          dest_host_port_pair, bound_net_log_.net_log()));
   int status = transport_socket_->Connect(&connect_callback_);
   if (status != net::ERR_IO_PENDING) {
     // We defer execution of ProcessConnectDone instead of calling it
     // directly here as the caller may not expect an error/close to
     // happen here.  This is okay, as from the caller's point of view,
     // the connect always happens asynchronously.
     MessageLoop* message_loop = MessageLoop::current();
     CHECK(message_loop);
     message_loop->PostTask(
         FROM_HERE,
@@ skipping 267 matching lines @@
   state_ = STATE_TLS_CONNECTING;
   read_state_ = IDLE;
   read_start_ = 0U;
   read_end_ = 0U;
   DCHECK_EQ(write_end_, 0U);
 
   // Clear out any posted DoRead() tasks.
   scoped_runnable_method_factory_.RevokeAll();
 
   DCHECK(transport_socket_.get());
+  net::ClientSocketHandle* socket_handle = new net::ClientSocketHandle();
+  socket_handle->set_socket(transport_socket_.release());
   transport_socket_.reset(
       client_socket_factory_->CreateSSLClientSocket(
-          transport_socket_.release(), net::HostPortPair(domain_name, 443),
-          ssl_config_, NULL /* ssl_host_info */,
-          cert_verifier_));
+          socket_handle, net::HostPortPair(domain_name, 443)));
   int status = transport_socket_->Connect(&ssl_connect_callback_);
   if (status != net::ERR_IO_PENDING) {
     MessageLoop* message_loop = MessageLoop::current();
     CHECK(message_loop);
     message_loop->PostTask(
         FROM_HERE,
         scoped_runnable_method_factory_.NewRunnableMethod(
             &ChromeAsyncSocket::ProcessSSLConnectDone, status));
   }
   return true;
@@ skipping 18 matching lines @@
   }
   state_ = STATE_TLS_OPEN;
   PostDoRead();
   if (write_end_ > 0U) {
     PostDoWrite();
   }
   SignalSSLConnected();
 }
 
 }  // namespace notifier