Proof of concept for tr1-based Task replacement.

net/socket/client_socket_pool_base.h

 // Copyright (c) 2010 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 12 matching lines @@
 #define NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_
 #pragma once
 
 #include <deque>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
+#include "base/closure.h"
 #include "base/ref_counted.h"
 #include "base/scoped_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_log.h"
@@ skipping 115 matching lines @@
     : public ConnectJob::Delegate,
       public NetworkChangeNotifier::Observer {
  public:
   // Used to specify specific behavior for the ClientSocketPool.
   enum Flag {
     NORMAL = 0,  // Normal behavior.
     NO_IDLE_SOCKETS = 0x1,  // Do not return an idle socket. Create a new one.
   };
 
   typedef uint32 Flags;
+  typedef ::std::tr1::function<void(int)> Tr1CompletionCallback;
 
   class Request {
    public:
     Request(ClientSocketHandle* handle,
-            CompletionCallback* callback,
+            Tr1CompletionCallback callback,
             RequestPriority priority,
             Flags flags,
             const BoundNetLog& net_log);
 
     virtual ~Request();
 
     ClientSocketHandle* handle() const { return handle_; }
-    CompletionCallback* callback() const { return callback_; }
+    Tr1CompletionCallback callback() const { return callback_; }
     RequestPriority priority() const { return priority_; }
     Flags flags() const { return flags_; }
     const BoundNetLog& net_log() const { return net_log_; }
 
    private:
     ClientSocketHandle* const handle_;
-    CompletionCallback* const callback_;
+    Tr1CompletionCallback const callback_;
     const RequestPriority priority_;
     const Flags flags_;
     BoundNetLog net_log_;
 
     DISALLOW_COPY_AND_ASSIGN(Request);
   };
 
   class ConnectJobFactory {
    public:
     ConnectJobFactory() {}
@@ skipping 141 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 !closure_canceller_.empty(); }
 
     void CleanupBackupJob() {
-      method_factory_.RevokeAll();
+      closure_canceller_.RevokeAll();
     }
 
     // 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::ClosureCanceller closure_canceller_;
   };
 
   typedef std::map<std::string, Group*> GroupMap;
 
   typedef std::set<ConnectJob*> ConnectJobSet;
 
   struct CallbackResultPair {
     CallbackResultPair() : callback(NULL), result(OK) {}
-    CallbackResultPair(CompletionCallback* callback_in, int result_in)
+    CallbackResultPair(Tr1CompletionCallback callback_in, int result_in)
         : callback(callback_in), result(result_in) {}
 
-    CompletionCallback* callback;
+    Tr1CompletionCallback callback;
     int result;
   };
 
   typedef std::map<const ClientSocketHandle*, CallbackResultPair>
       PendingCallbackMap;
 
   static void InsertRequestIntoQueue(const Request* r,
                                      RequestQueue* pending_requests);
   static const Request* RemoveRequestFromQueue(RequestQueue::iterator it,
                                                Group* group);
@@ skipping 75 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, CompletionCallback* callback, int rv);
+      ClientSocketHandle* handle, Tr1CompletionCallback 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 27 matching lines @@
   const scoped_ptr<ConnectJobFactory> connect_job_factory_;
 
   // TODO(vandebo) Remove when backup jobs move to TCPClientSocketPool
   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_;
 
-  ScopedRunnableMethodFactory<ClientSocketPoolBaseHelper> method_factory_;
+  base::ClosureCanceller closure_canceller_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolBaseHelper);
 };
 
 }  // namespace internal
 
 // The maximum duration, in seconds, to keep used idle persistent sockets alive.
 static const int kUsedIdleSocketTimeout = 300;  // 5 minutes
 
 template <typename SocketParams>
 class ClientSocketPoolBase {
  public:
   class Request : public internal::ClientSocketPoolBaseHelper::Request {
    public:
     Request(ClientSocketHandle* handle,
             CompletionCallback* callback,
             RequestPriority priority,
             internal::ClientSocketPoolBaseHelper::Flags flags,
             const scoped_refptr<SocketParams>& params,
             const BoundNetLog& net_log)
+        // Do a hacky type transition from the CompletionCallback to
+        // Tr1CompletionCallback by binding the method.  This is complicated
+        // by the fact that the function we're wrapper has overloads which
+        // forces a cast to hint which overload we want to wrap.  This should
+        // not be an issue in most of the code since overloads are discouraged
+        // by the style guide.
+        //
+        // Also note that we We don't need to keep a reference to the callback
+        // because the API does not take ownership. One plus of Tr1 callback is
+        // that there is no such ownership ambiguity. But the downside is
+        // refcounting in the callback.
         : internal::ClientSocketPoolBaseHelper::Request(
-              handle, callback, priority, flags, net_log),
+              handle,
+              ::std::tr1::bind<void(CompletionCallback::*)(const int&)>(
+                  &CompletionCallback::Run,
+                  callback,
+                  std::tr1::placeholders::_1),
+              priority,
+              flags, net_log),
           params_(params) {}
 
     const scoped_refptr<SocketParams>& params() const { return params_; }
 
    private:
     const scoped_refptr<SocketParams> params_;
   };
 
   class ConnectJobFactory {
    public:
@@ skipping 159 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_