Make GetLoadState virtual in ConnectJob().

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"
@@ skipping 26 matching lines @@
       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.
 }
 
+LoadState TCPConnectJob::GetLoadState() const {
+  switch (next_state_) {
+    case kStateResolveHost:
+    case kStateResolveHostComplete:
+      return LOAD_STATE_RESOLVING_HOST;
+    case kStateTCPConnect:
+    case kStateTCPConnectComplete:
+      return LOAD_STATE_CONNECTING;
+    default:
+      NOTREACHED();
+      return LOAD_STATE_IDLE;
+  }
+}
+
 int TCPConnectJob::ConnectInternal() {
   next_state_ = kStateResolveHost;
   return DoLoop(OK);
 }
 
 void TCPConnectJob::OnIOComplete(int result) {
   int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING)
     NotifyDelegateOfCompletion(rv);  // Deletes |this|
 }
@@ skipping 24 matching lines @@
         NOTREACHED();
         rv = ERR_FAILED;
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != kStateNone);
 
   return rv;
 }
 
 int TCPConnectJob::DoResolveHost() {
-  set_load_state(LOAD_STATE_RESOLVING_HOST);
   next_state_ = kStateResolveHostComplete;
   return resolver_.Resolve(resolve_info_, &addresses_, &callback_, load_log());
 }
 
 int TCPConnectJob::DoResolveHostComplete(int result) {
-  DCHECK_EQ(LOAD_STATE_RESOLVING_HOST, load_state());
   if (result == OK)
     next_state_ = kStateTCPConnect;
   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();
   // TODO(eroman): Socket::Connect() should take a LoadLog.
   return socket()->Connect(&callback_);
 }
 
 int TCPConnectJob::DoTCPConnectComplete(int result) {
-  DCHECK_EQ(load_state(), LOAD_STATE_CONNECTING);
   if (result == OK) {
     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);
@@ skipping 59 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