Proof of concept for tr1-based Task replacement.

net/socket/client_socket_pool_base.cc

 // 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.
 
 #include "net/socket/client_socket_pool_base.h"
 
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/message_loop.h"
 #include "base/metrics/stats_counters.h"
@@ skipping 115 matching lines @@
 
   net_log_.AddEvent(NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_TIMED_OUT, NULL);
 
   NotifyDelegateOfCompletion(ERR_TIMED_OUT);
 }
 
 namespace internal {
 
 ClientSocketPoolBaseHelper::Request::Request(
     ClientSocketHandle* handle,
-    CompletionCallback* callback,
+    Tr1CompletionCallback callback,
     RequestPriority priority,
     Flags flags,
     const BoundNetLog& net_log)
     : handle_(handle),
       callback_(callback),
       priority_(priority),
       flags_(flags),
       net_log_(net_log) {}
 
 ClientSocketPoolBaseHelper::Request::~Request() {}
 
 ClientSocketPoolBaseHelper::ClientSocketPoolBaseHelper(
     int max_sockets,
     int max_sockets_per_group,
     base::TimeDelta unused_idle_socket_timeout,
     base::TimeDelta used_idle_socket_timeout,
     ConnectJobFactory* connect_job_factory)
     : idle_socket_count_(0),
       connecting_socket_count_(0),
       handed_out_socket_count_(0),
       max_sockets_(max_sockets),
       max_sockets_per_group_(max_sockets_per_group),
       unused_idle_socket_timeout_(unused_idle_socket_timeout),
       used_idle_socket_timeout_(used_idle_socket_timeout),
       connect_job_factory_(connect_job_factory),
       connect_backup_jobs_enabled_(false),
-      pool_generation_number_(0),
-      method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+      pool_generation_number_(0) {
   DCHECK_LE(0, max_sockets_per_group);
   DCHECK_LE(max_sockets_per_group, max_sockets);
 
   NetworkChangeNotifier::AddObserver(this);
 }
 
 ClientSocketPoolBaseHelper::~ClientSocketPoolBaseHelper() {
   // Clean up any idle sockets and pending connect jobs.  Assert that we have no
   // remaining active sockets or pending requests.  They should have all been
   // cleaned up prior to |this| being destroyed.
@@ skipping 26 matching lines @@
   group->mutable_pending_requests()->erase(it);
   // If there are no more requests, we kill the backup timer.
   if (group->pending_requests().empty())
     group->CleanupBackupJob();
   return req;
 }
 
 int ClientSocketPoolBaseHelper::RequestSocket(
     const std::string& group_name,
     const Request* request) {
-  CHECK(request->callback());
   CHECK(request->handle());
 
   request->net_log().BeginEvent(NetLog::TYPE_SOCKET_POOL, NULL);
   Group* group = GetOrCreateGroup(group_name);
 
   int rv = RequestSocketInternal(group_name, request);
   if (rv != ERR_IO_PENDING) {
     request->net_log().EndEvent(NetLog::TYPE_SOCKET_POOL, NULL);
     CHECK(!request->handle()->is_initialized());
     delete request;
   } else {
     InsertRequestIntoQueue(request, group->mutable_pending_requests());
   }
   return rv;
 }
 
 void ClientSocketPoolBaseHelper::RequestSockets(
     const std::string& group_name,
     const Request& request,
     int num_sockets) {
-  DCHECK(!request.callback());
   DCHECK(!request.handle());
 
   if (num_sockets > max_sockets_per_group_) {
     num_sockets = max_sockets_per_group_;
   }
 
   request.net_log().BeginEvent(
       NetLog::TYPE_SOCKET_POOL_CONNECTING_N_SOCKETS,
       make_scoped_refptr(new NetLogIntegerParameter(
           "num_sockets", num_sockets)));
@@ skipping 725 matching lines @@
     }
   }
 
   if (!exception_group)
     LOG(DFATAL) << "No idle socket found to close!.";
 
   return false;
 }
 
 void ClientSocketPoolBaseHelper::InvokeUserCallbackLater(
-    ClientSocketHandle* handle, CompletionCallback* callback, int rv) {
+    ClientSocketHandle* handle, Tr1CompletionCallback callback, int rv) {
+  using ::std::tr1::bind;
+  using ::std::tr1::function;
+
   CHECK(!ContainsKey(pending_callback_map_, handle));
   pending_callback_map_[handle] = CallbackResultPair(callback, rv);
-  MessageLoop::current()->PostTask(
-      FROM_HERE,
-      method_factory_.NewRunnableMethod(
-          &ClientSocketPoolBaseHelper::InvokeUserCallback,
-          handle));
+
+  function<void(void)> invoke_thunk =
+      bind(&ClientSocketPoolBaseHelper::InvokeUserCallback, this, handle);
+  MessageLoop::current()->PostClosure(FROM_HERE,
+                                      closure_canceller_.Wrap(invoke_thunk));
 }
 
 void ClientSocketPoolBaseHelper::InvokeUserCallback(
     ClientSocketHandle* handle) {
   PendingCallbackMap::iterator it = pending_callback_map_.find(handle);
 
   // Exit if the request has already been cancelled.
   if (it == pending_callback_map_.end())
     return;
 
   CHECK(!handle->is_initialized());
-  CompletionCallback* callback = it->second.callback;
+  Tr1CompletionCallback callback = it->second.callback;
   int result = it->second.result;
   pending_callback_map_.erase(it);
-  callback->Run(result);
+  callback(result);
 }
 
 ClientSocketPoolBaseHelper::Group::Group()
-    : active_socket_count_(0),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {}
+    : active_socket_count_(0) {}
 
 ClientSocketPoolBaseHelper::Group::~Group() {
   CleanupBackupJob();
 }
 
 void ClientSocketPoolBaseHelper::Group::StartBackupSocketTimer(
     const std::string& group_name,
     ClientSocketPoolBaseHelper* pool) {
+  using ::std::tr1::bind;
+  using ::std::tr1::function;
+
   // Only allow one timer pending to create a backup socket.
-  if (!method_factory_.empty())
+  if (!closure_canceller_.empty())
     return;
 
-  MessageLoop::current()->PostDelayedTask(
+  // TODO(ajwong): Somethings wrong with inlining this call as opposed to
+  // breaking out a separate variable.  Figure out syntax issue. It's probably
+  // the template in ClosureCanceller::Wrap.
+  function<void(void)> invoke_thunk =
+      bind(&Group::OnBackupSocketTimerFired, this, group_name, pool);
+
+  MessageLoop::current()->PostDelayedClosure(
       FROM_HERE,
-      method_factory_.NewRunnableMethod(
-          &Group::OnBackupSocketTimerFired, group_name, pool),
+      closure_canceller_.Wrap(invoke_thunk),
       pool->ConnectRetryIntervalMs());
 }
 
 bool ClientSocketPoolBaseHelper::Group::TryToUsePreconnectConnectJob() {
   for (std::set<ConnectJob*>::iterator it = jobs_.begin();
        it != jobs_.end(); ++it) {
     ConnectJob* job = *it;
     if (job->is_unused_preconnect()) {
       job->UseForNormalRequest();
       return true;
@@ skipping 35 matching lines @@
   AddJob(backup_job);
   if (rv != ERR_IO_PENDING)
     pool->OnConnectJobComplete(rv, backup_job);
 }
 
 void ClientSocketPoolBaseHelper::Group::RemoveAllJobs() {
   // Delete active jobs.
   STLDeleteElements(&jobs_);
 
   // Cancel pending backup job.
-  method_factory_.RevokeAll();
+  closure_canceller_.RevokeAll();
 }
 
 }  // namespace internal
 
 }  // namespace net