CancelableTaskTracker::PostDelayedTask() support

base/task/cancelable_task_tracker.cc

 // Copyright 2014 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 "base/task/cancelable_task_tracker.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/task_runner.h"
+#include "base/thread_task_runner_handle.h"
 
 using base::Bind;
 using base::CancellationFlag;
 using base::Closure;
 using base::hash_map;
 using base::TaskRunner;
 
 namespace {
 
 void RunIfNotCanceled(const CancellationFlag* flag, const Closure& task) {
@@ skipping 38 matching lines @@
 CancelableTaskTracker::~CancelableTaskTracker() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   TryCancelAll();
 }
 
 CancelableTaskTracker::TaskId CancelableTaskTracker::PostTask(
     TaskRunner* task_runner,
     const tracked_objects::Location& from_here,
     const Closure& task) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  return PostDelayedTaskAndReply(task_runner, from_here, task,
+                                 Bind(&base::DoNothing), TimeDelta());
+}
 
-  return PostTaskAndReply(task_runner, from_here, task, Bind(&base::DoNothing));
+CancelableTaskTracker::TaskId CancelableTaskTracker::PostDelayedTask(
+    TaskRunner* task_runner,
+    const tracked_objects::Location& from_here,
+    const Closure& task,
+    const TimeDelta& delay) {
+  return PostDelayedTaskAndReply(task_runner, from_here, task,
+                                 Bind(&base::DoNothing), delay);
 }
 
 CancelableTaskTracker::TaskId CancelableTaskTracker::PostTaskAndReply(
     TaskRunner* task_runner,
     const tracked_objects::Location& from_here,
     const Closure& task,
     const Closure& reply) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  // We need a MessageLoop to run reply.
-  DCHECK(base::MessageLoopProxy::current().get());
-
-  // Owned by reply callback below.
-  CancellationFlag* flag = new CancellationFlag();
-
-  TaskId id = next_id_;
-  next_id_++;  // int64 is big enough that we ignore the potential overflow.
-
-  const Closure& untrack_closure =
-      Bind(&CancelableTaskTracker::Untrack, weak_factory_.GetWeakPtr(), id);
-  bool success =
-      task_runner->PostTaskAndReply(from_here,
-                                    Bind(&RunIfNotCanceled, flag, task),
-                                    Bind(&RunIfNotCanceledThenUntrack,
-                                         base::Owned(flag),
-                                         reply,
-                                         untrack_closure));
-
-  if (!success)
-    return kBadTaskId;
-
-  Track(id, flag);
-  return id;
+  return PostDelayedTaskAndReply(task_runner, from_here, task, reply,
+                                 TimeDelta());
 }
 
 CancelableTaskTracker::TaskId CancelableTaskTracker::NewTrackedTaskId(
     IsCanceledCallback* is_canceled_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(base::MessageLoopProxy::current().get());
 
   TaskId id = next_id_;
   next_id_++;  // int64 is big enough that we ignore the potential overflow.
 
@@ skipping 56 matching lines @@
   bool success = task_flags_.insert(std::make_pair(id, flag)).second;
   DCHECK(success);
 }
 
 void CancelableTaskTracker::Untrack(TaskId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   size_t num = task_flags_.erase(id);
   DCHECK_EQ(1u, num);
 }
 
+CancelableTaskTracker::TaskId CancelableTaskTracker::PostDelayedTaskAndReply(
+    TaskRunner* task_runner,
+    const tracked_objects::Location& from_here,
+    const Closure& task,
+    const Closure& reply,
+    const TimeDelta& delay) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // We need a MessageLoop to run reply.
+  DCHECK(ThreadTaskRunnerHandle::Get());
+
+  // Owned by reply callback below.
+  CancellationFlag* flag = new CancellationFlag();
+
+  TaskId id = next_id_;
+  next_id_++;  // int64 is big enough that we ignore the potential overflow.
+
+  const Closure& untrack_closure =
+      Bind(&CancelableTaskTracker::Untrack, weak_factory_.GetWeakPtr(), id);
+  bool success = task_runner->PostDelayedTaskAndReply(
+      from_here,
+      Bind(&RunIfNotCanceled, flag, task),
+      Bind(&RunIfNotCanceledThenUntrack,
+           Owned(flag),
+           reply,
+           untrack_closure),
+      delay);
+
+  if (!success)
+    return kBadTaskId;
+
+  Track(id, flag);
+  return id;
+}
+
 }  // namespace base