Refactor ConnectJob and TCPConnectJob.

net/socket/tcp_client_socket_pool.cc

 // Copyright (c) 2006-2008 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/time.h"
 #include "net/base/net_errors.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/socket/tcp_client_socket.h"
 
 using base::TimeDelta;
 
 namespace net {
 
 TCPConnectJob::TCPConnectJob(
     const std::string& group_name,
     const HostResolver::RequestInfo& resolve_info,
     const ClientSocketHandle* handle,
     ClientSocketFactory* client_socket_factory,
     HostResolver* host_resolver,
     Delegate* delegate)
-    : group_name_(group_name),
+    : ConnectJob(group_name, handle, delegate),
       resolve_info_(resolve_info),
-      handle_(handle),
       client_socket_factory_(client_socket_factory),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           callback_(this,
                     &TCPConnectJob::OnIOComplete)),
-      delegate_(delegate),
       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.
 }
 
 int TCPConnectJob::Connect() {
-  set_load_state(LOAD_STATE_RESOLVING_HOST);
-  int rv = resolver_.Resolve(resolve_info_, &addresses_, &callback_);
+  next_state_ = kStateResolveHost;
+  return DoLoop(OK);
+}
+
+void TCPConnectJob::OnIOComplete(int result) {
+  int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING)
-    rv = OnIOCompleteInternal(rv, true /* synchronous */);
+    delegate()->OnConnectJobComplete(rv, this);  // Deletes |this|
+}
+
+int TCPConnectJob::DoLoop(int result) {
+  DCHECK_NE(next_state_, kStateNone);
+
+  int rv = result;
+  do {
+    State state = next_state_;
+    next_state_ = kStateNone;
+    switch (state) {
+      case kStateResolveHost:
+        DCHECK_EQ(OK, rv);
+        rv = DoResolveHost();
+        break;
+      case kStateResolveHostComplete:
+        rv = DoResolveHostComplete(rv);
+        break;
+      case kStateTCPConnect:
+        DCHECK_EQ(OK, rv);
+        rv = DoTCPConnect();
+        break;
+      case kStateTCPConnectComplete:
+        rv = DoTCPConnectComplete(rv);
+        break;
+      default:
+        NOTREACHED();
+        rv = ERR_FAILED;
+        break;
+    }
+  } while (rv != ERR_IO_PENDING && next_state_ != kStateNone);
+
   return rv;
 }
 
-void TCPConnectJob::OnIOComplete(int result) {
-  OnIOCompleteInternal(result, false /* asynchronous */);
+int TCPConnectJob::DoResolveHost() {
+  set_load_state(LOAD_STATE_RESOLVING_HOST);
+  next_state_ = kStateResolveHostComplete;
+  return resolver_.Resolve(resolve_info_, &addresses_, &callback_);
 }
 
-int TCPConnectJob::OnIOCompleteInternal(
-    int result, bool synchronous) {
-  CHECK(result != ERR_IO_PENDING);
+int TCPConnectJob::DoResolveHostComplete(int result) {
+  DCHECK_EQ(LOAD_STATE_RESOLVING_HOST, load_state());
+  if (result == OK)
+    next_state_ = kStateTCPConnect;
+  return result;
+}
 
-  if (result == OK && load_state() == LOAD_STATE_RESOLVING_HOST) {
-    set_load_state(LOAD_STATE_CONNECTING);
-    socket_.reset(client_socket_factory_->CreateTCPClientSocket(addresses_));
-    connect_start_time_ = base::TimeTicks::Now();
-    result = socket_->Connect(&callback_);
-    if (result == ERR_IO_PENDING)
-      return result;
-  }
+int TCPConnectJob::DoTCPConnect() {
+  next_state_ = kStateTCPConnectComplete;
+  set_load_state(LOAD_STATE_CONNECTING);
+  set_socket(client_socket_factory_->CreateTCPClientSocket(addresses_));
+  connect_start_time_ = base::TimeTicks::Now();
+  return socket()->Connect(&callback_);
+}
 
+int TCPConnectJob::DoTCPConnectComplete(int result) {
+  DCHECK_EQ(load_state(), LOAD_STATE_CONNECTING);
   if (result == OK) {
-    DCHECK_EQ(load_state(), LOAD_STATE_CONNECTING);
-    CHECK(connect_start_time_ != base::TimeTicks());
+    DCHECK(connect_start_time_ != base::TimeTicks());
     base::TimeDelta connect_duration =
         base::TimeTicks::Now() - connect_start_time_;
 
     UMA_HISTOGRAM_CLIPPED_TIMES("Net.TCP_Connection_Latency",
         connect_duration,
         base::TimeDelta::FromMilliseconds(1),
         base::TimeDelta::FromMinutes(10),
         100);
   }
 
-  // Now, we either succeeded at Connect()'ing, or we failed at host resolution
-  // or Connect()'ing.  Either way, we'll run the callback to alert the client.
-
-  delegate_->OnConnectJobComplete(
-      group_name_,
-      handle_,
-      result == OK ? socket_.release() : NULL,
-      result,
-      !synchronous);
-
-  // |this| is deleted after this point.
   return result;
 }
 
 ConnectJob* TCPClientSocketPool::TCPConnectJobFactory::NewConnectJob(
     const std::string& group_name,
     const ClientSocketPoolBase::Request& request,
     ConnectJob::Delegate* delegate) const {
   return new TCPConnectJob(
       group_name, request.resolve_info, request.handle,
       client_socket_factory_, host_resolver_, delegate);
@@ skipping 39 matching lines @@
     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