base::Bind: Convert most of net/http.

net/socket/client_socket_pool_base.h

 // Copyright (c) 2011 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 15 matching lines @@
 #include <deque>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_export.h"
 #include "net/base/net_log.h"
 #include "net/base/network_change_notifier.h"
@@ skipping 136 matching lines @@
     // Socket which scores highest on large bytes transferred and low idle time.
     USE_WARM_SOCKET = 1,
 
     // Socket which was most recently used.
     USE_LAST_ACCESSED_SOCKET = 2,
   };
 
   class NET_EXPORT_PRIVATE Request {
    public:
     Request(ClientSocketHandle* handle,
-            OldCompletionCallback* callback,
+            const CompletionCallback& callback,
             RequestPriority priority,
             bool ignore_limits,
             Flags flags,
             const BoundNetLog& net_log);
 
     virtual ~Request();
 
     ClientSocketHandle* handle() const { return handle_; }
-    OldCompletionCallback* callback() const { return callback_; }
+    const CompletionCallback& callback() const { return callback_; }
     RequestPriority priority() const { return priority_; }
     bool ignore_limits() const { return ignore_limits_; }
     Flags flags() const { return flags_; }
     const BoundNetLog& net_log() const { return net_log_; }
 
    private:
     ClientSocketHandle* const handle_;
-    OldCompletionCallback* const callback_;
+    CompletionCallback callback_;
     const RequestPriority priority_;
     bool ignore_limits_;
     const Flags flags_;
     BoundNetLog net_log_;
 
     DISALLOW_COPY_AND_ASSIGN(Request);
   };
 
   class ConnectJobFactory {
    public:
@@ skipping 171 matching lines @@
 
     bool IsStalled(int max_sockets_per_group) const {
       return HasAvailableSocketSlot(max_sockets_per_group) &&
           pending_requests_.size() > jobs_.size();
     }
 
     RequestPriority TopPendingPriority() const {
       return pending_requests_.front()->priority();
     }
 
-    bool HasBackupJob() const { return !method_factory_.empty(); }
+    bool HasBackupJob() const { return weak_factory_.HasWeakPtrs(); }
 
     void CleanupBackupJob() {
-      method_factory_.RevokeAll();
+      weak_factory_.InvalidateWeakPtrs();
     }
 
     // Set a timer to create a backup socket if it takes too long to create one.
     void StartBackupSocketTimer(const std::string& group_name,
                                 ClientSocketPoolBaseHelper* pool);
 
     // Searches |jobs_| to see if there's a preconnect ConnectJob, and if so,
     // uses it.  Returns true on success.  Otherwise, returns false.
     bool TryToUsePreconnectConnectJob();
 
@@ skipping 15 matching lines @@
     // Called when the backup socket timer fires.
     void OnBackupSocketTimerFired(
         std::string group_name,
         ClientSocketPoolBaseHelper* pool);
 
     std::list<IdleSocket> idle_sockets_;
     std::set<ConnectJob*> jobs_;
     RequestQueue pending_requests_;
     int active_socket_count_;  // number of active sockets used by clients
     // A factory to pin the backup_job tasks.
-    ScopedRunnableMethodFactory<Group> method_factory_;
+    base::WeakPtrFactory<Group> weak_factory_;
   };
 
   typedef std::map<std::string, Group*> GroupMap;
 
   typedef std::set<ConnectJob*> ConnectJobSet;
 
   struct CallbackResultPair {
-    CallbackResultPair() : callback(NULL), result(OK) {}
-    CallbackResultPair(OldCompletionCallback* callback_in, int result_in)
+    CallbackResultPair() : result(OK) {}
+    CallbackResultPair(const CompletionCallback& callback_in, int result_in)
         : callback(callback_in), result(result_in) {}
+    ~CallbackResultPair();
 
-    OldCompletionCallback* callback;
+    CompletionCallback callback;
     int result;
   };
 
   typedef std::map<const ClientSocketHandle*, CallbackResultPair>
       PendingCallbackMap;
 
   static void InsertRequestIntoQueue(const Request* r,
                                      RequestQueue* pending_requests);
   static const Request* RemoveRequestFromQueue(const RequestQueue::iterator& it,
                                                Group* group);
@@ skipping 71 matching lines @@
   bool CloseOneIdleSocketExceptInGroup(const Group* group);
 
   // Checks if there are stalled socket groups that should be notified
   // for possible wakeup.
   void CheckForStalledSocketGroups();
 
   // Posts a task to call InvokeUserCallback() on the next iteration through the
   // current message loop.  Inserts |callback| into |pending_callback_map_|,
   // keyed by |handle|.
   void InvokeUserCallbackLater(
-      ClientSocketHandle* handle, OldCompletionCallback* callback, int rv);
+      ClientSocketHandle* handle, const CompletionCallback& callback, int rv);
 
   // Invokes the user callback for |handle|.  By the time this task has run,
   // it's possible that the request has been cancelled, so |handle| may not
   // exist in |pending_callback_map_|.  We look up the callback and result code
   // in |pending_callback_map_|.
   void InvokeUserCallback(ClientSocketHandle* handle);
 
   GroupMap group_map_;
 
   // Map of the ClientSocketHandles for which we have a pending Task to invoke a
@@ skipping 32 matching lines @@
   // TODO(vandebo) Remove when backup jobs move to TransportClientSocketPool
   bool connect_backup_jobs_enabled_;
 
   // A unique id for the pool.  It gets incremented every time we Flush() the
   // pool.  This is so that when sockets get released back to the pool, we can
   // make sure that they are discarded rather than reused.
   int pool_generation_number_;
 
   std::set<LayeredPool*> higher_layer_pools_;
 
-  ScopedRunnableMethodFactory<ClientSocketPoolBaseHelper> method_factory_;
+  base::WeakPtrFactory<ClientSocketPoolBaseHelper> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolBaseHelper);
 };
 
 }  // namespace internal
 
 template <typename SocketParams>
 class ClientSocketPoolBase {
  public:
   class Request : public internal::ClientSocketPoolBaseHelper::Request {
    public:
     Request(ClientSocketHandle* handle,
-            OldCompletionCallback* callback,
+            const CompletionCallback& callback,
             RequestPriority priority,
             internal::ClientSocketPoolBaseHelper::Flags flags,
             bool ignore_limits,
             const scoped_refptr<SocketParams>& params,
             const BoundNetLog& net_log)
         : internal::ClientSocketPoolBaseHelper::Request(
               handle, callback, priority, ignore_limits, flags, net_log),
           params_(params) {}
 
     const scoped_refptr<SocketParams>& params() const { return params_; }
@@ skipping 46 matching lines @@
   void RemoveLayeredPool(LayeredPool* pool) {
     helper_.RemoveLayeredPool(pool);
   }
 
   // RequestSocket bundles up the parameters into a Request and then forwards to
   // ClientSocketPoolBaseHelper::RequestSocket().
   int RequestSocket(const std::string& group_name,
                     const scoped_refptr<SocketParams>& params,
                     RequestPriority priority,
                     ClientSocketHandle* handle,
-                    OldCompletionCallback* callback,
+                    const CompletionCallback& callback,
                     const BoundNetLog& net_log) {
     Request* request =
         new Request(handle, callback, priority,
                     internal::ClientSocketPoolBaseHelper::NORMAL,
                     params->ignore_limits(),
                     params, net_log);
     return helper_.RequestSocket(group_name, request);
   }
 
   // RequestSockets bundles up the parameters into a Request and then forwards
   // to ClientSocketPoolBaseHelper::RequestSockets().  Note that it assigns the
   // priority to LOWEST and specifies the NO_IDLE_SOCKETS flag.
   void RequestSockets(const std::string& group_name,
                       const scoped_refptr<SocketParams>& params,
                       int num_sockets,
                       const BoundNetLog& net_log) {
     const Request request(NULL /* no handle */,
-                          NULL /* no callback */,
+                          CompletionCallback(),
                           LOWEST,
                           internal::ClientSocketPoolBaseHelper::NO_IDLE_SOCKETS,
                           params->ignore_limits(),
                           params,
                           net_log);
     helper_.RequestSockets(group_name, request, num_sockets);
   }
 
   void CancelRequest(const std::string& group_name,
                      ClientSocketHandle* handle) {
@@ skipping 98 matching lines @@
   // Histograms for the pool
   ClientSocketPoolHistograms* const histograms_;
   internal::ClientSocketPoolBaseHelper helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolBase);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_