Make GetLoadState virtual in ConnectJob().

net/socket/client_socket_pool_base.h

 // 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.
 //
 // A ClientSocketPoolBase is used to restrict the number of sockets open at
 // a time.  It also maintains a list of idle persistent sockets for reuse.
 // Subclasses of ClientSocketPool should compose ClientSocketPoolBase to handle
 // the core logic of (1) restricting the number of active (connected or
 // connecting) sockets per "group" (generally speaking, the hostname), (2)
 // maintaining a per-group list of idle, persistent sockets for reuse, and (3)
@@ skipping 52 matching lines @@
   // A |timeout_duration| of 0 corresponds to no timeout.
   ConnectJob(const std::string& group_name,
              const ClientSocketHandle* key_handle,
              base::TimeDelta timeout_duration,
              Delegate* delegate,
              LoadLog* load_log);
   virtual ~ConnectJob();
 
   // Accessors
   const std::string& group_name() const { return group_name_; }
-  LoadState load_state() const { return load_state_; }
   const ClientSocketHandle* key_handle() const { return key_handle_; }
+  LoadLog* load_log() { return load_log_; }
 
   // Releases |socket_| to the client.  On connection error, this should return
   // NULL.
   ClientSocket* ReleaseSocket() { return socket_.release(); }
 
   // Begins connecting the socket.  Returns OK on success, ERR_IO_PENDING if it
   // cannot complete synchronously without blocking, or another net error code
   // on error.  In asynchronous completion, the ConnectJob will notify
   // |delegate_| via OnConnectJobComplete.  In both asynchronous and synchronous
   // completion, ReleaseSocket() can be called to acquire the connected socket
   // if it succeeded.
   int Connect();
 
-  LoadLog* load_log() { return load_log_; }
+  virtual LoadState GetLoadState() const = 0;
 
  protected:
-  void set_load_state(LoadState load_state) { load_state_ = load_state; }
   void set_socket(ClientSocket* socket) { socket_.reset(socket); }
   ClientSocket* socket() { return socket_.get(); }
   void NotifyDelegateOfCompletion(int rv);
 
  private:
   virtual int ConnectInternal() = 0;
 
   // Alerts the delegate that the ConnectJob has timed out.
   void OnTimeout();
 
   const std::string group_name_;
   // Temporarily needed until we switch to late binding.
   const ClientSocketHandle* const key_handle_;
   const base::TimeDelta timeout_duration_;
   // Timer to abort jobs that take too long.
   base::OneShotTimer<ConnectJob> timer_;
   Delegate* delegate_;
-  LoadState load_state_;
   scoped_ptr<ClientSocket> socket_;
   scoped_refptr<LoadLog> load_log_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectJob);
 };
 
 namespace internal {
 
 // ClientSocketPoolBaseHelper is an internal class that implements almost all
 // the functionality from ClientSocketPoolBase without using templates.
@@ skipping 409 matching lines @@
 // decoupled from socket connection jobs.  A socket request may initiate a
 // socket connection job, but there is no guarantee that that socket
 // connection will service the request (for example, a released socket may
 // service the request sooner, or a higher priority request may come in
 // afterward and receive the socket from the job).
 void EnableLateBindingOfSockets(bool enabled);
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_