Make a proper TCPSocketParams

net/socket/tcp_client_socket_pool.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// 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/tcp_client_socket_pool.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/time.h"
@@ skipping 14 matching lines @@
 // TODO(eroman): The use of this constant needs to be re-evaluated. The time
 // needed for TCPClientSocketXXX::Connect() can be arbitrarily long, since
 // the address list may contain many alternatives, and most of those may
 // timeout. Even worse, the per-connect timeout threshold varies greatly
 // between systems (anywhere from 20 seconds to 190 seconds).
 // See comment #12 at http://crbug.com/23364 for specifics.
 static const int kTCPConnectJobTimeoutInSeconds = 240; // 4 minutes.
 
 TCPConnectJob::TCPConnectJob(
     const std::string& group_name,
-    const HostResolver::RequestInfo& resolve_info,
+    const TCPSocketParams& params,
     base::TimeDelta timeout_duration,
     ClientSocketFactory* client_socket_factory,
     HostResolver* host_resolver,
     Delegate* delegate,
     LoadLog* load_log)
     : ConnectJob(group_name, timeout_duration, delegate, load_log),
-      resolve_info_(resolve_info),
+      params_(params),
       client_socket_factory_(client_socket_factory),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           callback_(this,
                     &TCPConnectJob::OnIOComplete)),
       resolver_(host_resolver) {}
 
 TCPConnectJob::~TCPConnectJob() {
   // We don't worry about cancelling the host resolution and TCP connect, since
   // ~SingleRequestHostResolver and ~ClientSocket will take care of it.
 }
@@ skipping 51 matching lines @@
         rv = ERR_FAILED;
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != kStateNone);
 
   return rv;
 }
 
 int TCPConnectJob::DoResolveHost() {
   next_state_ = kStateResolveHostComplete;
-  return resolver_.Resolve(resolve_info_, &addresses_, &callback_, load_log());
+  return resolver_.Resolve(params_.destination(), &addresses_, &callback_,
+                           load_log());
 }
 
 int TCPConnectJob::DoResolveHostComplete(int result) {
   if (result == OK)
     next_state_ = kStateTCPConnect;
   return result;
 }
 
 int TCPConnectJob::DoTCPConnect() {
   next_state_ = kStateTCPConnectComplete;
@@ skipping 49 matching lines @@
     : base_(max_sockets, max_sockets_per_group,
             base::TimeDelta::FromSeconds(kUnusedIdleSocketTimeout),
             base::TimeDelta::FromSeconds(kUsedIdleSocketTimeout),
             new TCPConnectJobFactory(client_socket_factory, host_resolver),
             network_change_notifier) {}
 
 TCPClientSocketPool::~TCPClientSocketPool() {}
 
 int TCPClientSocketPool::RequestSocket(
     const std::string& group_name,
-    const void* resolve_info,
+    const void* params,
     RequestPriority priority,
     ClientSocketHandle* handle,
     CompletionCallback* callback,
     LoadLog* load_log) {
-  const HostResolver::RequestInfo* casted_resolve_info =
-      static_cast<const HostResolver::RequestInfo*>(resolve_info);
+  const TCPSocketParams* casted_params =
+      static_cast<const TCPSocketParams*>(params);
 
   if (LoadLog::IsUnbounded(load_log)) {
     LoadLog::AddString(
         load_log,
         StringPrintf("Requested TCP socket to: %s [port %d]",
-                     casted_resolve_info->hostname().c_str(),
-                     casted_resolve_info->port()));
+                     casted_params->destination().hostname().c_str(),
+                     casted_params->destination().port()));
   }
 
-  return base_.RequestSocket(
-      group_name, *casted_resolve_info, priority, handle, callback, load_log);
+  return base_.RequestSocket(group_name, *casted_params, priority, handle,
+                             callback, load_log);
 }
 
 void TCPClientSocketPool::CancelRequest(
     const std::string& group_name,
     const ClientSocketHandle* handle) {
   base_.CancelRequest(group_name, handle);
 }
 
 void TCPClientSocketPool::ReleaseSocket(
     const std::string& group_name,
     ClientSocket* socket) {
   base_.ReleaseSocket(group_name, socket);
 }
 
 void TCPClientSocketPool::CloseIdleSockets() {
   base_.CloseIdleSockets();
 }
 
 int TCPClientSocketPool::IdleSocketCountInGroup(
     const std::string& group_name) const {
   return base_.IdleSocketCountInGroup(group_name);
 }
 
 LoadState TCPClientSocketPool::GetLoadState(
     const std::string& group_name, const ClientSocketHandle* handle) const {
   return base_.GetLoadState(group_name, handle);
 }
 
 }  // namespace net