Make GetLoadState virtual in ConnectJob().

net/socket/client_socket_pool_base_unittest.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/client_socket_pool_base.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/platform_thread.h"
 #include "base/scoped_vector.h"
@@ skipping 100 matching lines @@
                  const std::string& group_name,
                  const TestClientSocketPoolBase::Request& request,
                  base::TimeDelta timeout_duration,
                  ConnectJob::Delegate* delegate,
                  MockClientSocketFactory* client_socket_factory,
                  LoadLog* load_log)
       : ConnectJob(group_name, request.handle(), timeout_duration,
                    delegate, load_log),
         job_type_(job_type),
         client_socket_factory_(client_socket_factory),
-        method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
+        method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+        load_state_(LOAD_STATE_IDLE) {}
 
   void Signal() {
     DoConnect(waiting_success_, true /* async */);
   }
 
+  virtual LoadState GetLoadState() const { return load_state_; }
+
  private:
   // ConnectJob methods:
 
   virtual int ConnectInternal() {
     AddressList ignored;
     client_socket_factory_->CreateTCPClientSocket(ignored);
     set_socket(new MockClientSocket());
     switch (job_type_) {
       case kMockJob:
         return DoConnect(true /* successful */, false /* sync */);
@@ skipping 18 matching lines @@
                true  /* async */));
         return ERR_IO_PENDING;
       case kMockWaitingJob:
         client_socket_factory_->WaitForSignal(this);
         waiting_success_ = true;
         return ERR_IO_PENDING;
       case kMockAdvancingLoadStateJob:
         MessageLoop::current()->PostTask(
             FROM_HERE,
             method_factory_.NewRunnableMethod(
-                &TestConnectJob::AdvanceLoadState, load_state()));
+                &TestConnectJob::AdvanceLoadState, load_state_));
         return ERR_IO_PENDING;
       default:
         NOTREACHED();
         set_socket(NULL);
         return ERR_FAILED;
     }
   }
 
+  void set_load_state(LoadState load_state) { load_state_ = load_state; }
+
   int DoConnect(bool succeed, bool was_async) {
     int result = ERR_CONNECTION_FAILED;
     if (succeed) {
       result = OK;
       socket()->Connect(NULL);
     } else {
       set_socket(NULL);
     }
 
     if (was_async)
@@ skipping 11 matching lines @@
         FROM_HERE,
         method_factory_.NewRunnableMethod(&TestConnectJob::AdvanceLoadState,
                                           state),
         1 /* 1ms delay */);
   }
 
   bool waiting_success_;
   const JobType job_type_;
   MockClientSocketFactory* const client_socket_factory_;
   ScopedRunnableMethodFactory<TestConnectJob> method_factory_;
+  LoadState load_state_;
 
   DISALLOW_COPY_AND_ASSIGN(TestConnectJob);
 };
 
 class TestConnectJobFactory
     : public TestClientSocketPoolBase::ConnectJobFactory {
  public:
   explicit TestConnectJobFactory(MockClientSocketFactory* client_socket_factory)
       : job_type_(TestConnectJob::kMockJob),
         client_socket_factory_(client_socket_factory) {}
@@ skipping 1541 matching lines @@
   // Closing idle sockets should not get us into trouble, but in the bug
   // we were hitting a CHECK here.
   EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
   pool_->CloseIdleSockets();
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
 }
 
 }  // namespace
 
 }  // namespace net