Make tasks cancellable inside the blink scheduler.

third_party/WebKit/public/platform/scheduler/base/task_queue.h

 // Copyright 2015 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.
 
 #ifndef THIRD_PARTY_WEBKIT_PUBLIC_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_H_
 #define THIRD_PARTY_WEBKIT_PUBLIC_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_H_
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
-#include "base/trace_event/trace_event.h"
 #include "public/platform/WebCommon.h"
 
 namespace base {
 namespace trace_event {
 class BlameContext;
 }
 }
 
 namespace blink {
 namespace scheduler {
+namespace internal {
+class TaskQueueImpl;
+}  // namespace internal
+class FakeWebTaskRunner;
 class LazyNow;
 class TimeDomain;
 
 class BLINK_PLATFORM_EXPORT TaskQueue : public base::SingleThreadTaskRunner {
  public:
   TaskQueue() {}
 
   // Unregisters the task queue after which no tasks posted to it will run and
   // the TaskQueueManager's reference to it will be released soon.
   virtual void UnregisterTaskQueue() = 0;
@@ skipping 97 matching lines @@
 
     const char* name;
     bool should_monitor_quiescence;
     TaskQueue::PumpPolicy pump_policy;
     TaskQueue::WakeupPolicy wakeup_policy;
     TimeDomain* time_domain;
     bool should_notify_observers;
     bool should_report_when_execution_blocked;
   };
 
+  // Intended to be used as an opaque handle to a task posted by
+  // PostCancellableDelayedTask.
+  class BLINK_PLATFORM_EXPORT TaskHandle {
+   public:
+    TaskHandle();
+
+    // Returns false if the handle is equivalent to TaskHandle(), i.e. the
+    // handle doesn't represent a task that got posted.
+    operator bool() const;
+
+   private:
+    friend internal::TaskQueueImpl;
+    friend FakeWebTaskRunner;
+
+    // For immediate tasks.
+    TaskHandle(TaskQueue* task_queue, uint64_t enqueue_order);
+
+    // For delayed tasks.
+    TaskHandle(TaskQueue* task_queue,
+               base::TimeTicks scheduled_run_time,
+               int sequence_number);
+
+    uint64_t enqueue_order_;
+    base::TimeTicks scheduled_run_time_;
+#if DCHECK_IS_ON()
+    TaskQueue* task_queue_;
+#endif
+    int sequence_number_;
+  };
+
+  // Posts the given task to be run after |delay| has passed. Returns a handle
+  // which can be passed to CancelTask to cancel the task before it has run.
+  // NOTE this must be called on the thread this TaskQueue was created by.
+  virtual TaskHandle PostCancellableDelayedTask(
+      const tracked_objects::Location& from_here,
+      const base::Closure& task,
+      base::TimeDelta delay) = 0;
+
+  // Attempts to cancel a task posted by PostCancellableDelayedTask. Returns
+  // true on success or false otherwise. NOTE this must be called on the thread
+  // this TaskQueue was created by.
+  virtual bool CancelTask(const TaskHandle& handle) = 0;
+
   // Enable or disable task execution for this queue. NOTE this must be called
   // on the thread this TaskQueue was created by.
   virtual void SetQueueEnabled(bool enabled) = 0;
 
   // NOTE this must be called on the thread this TaskQueue was created by.
   virtual bool IsQueueEnabled() const = 0;
 
   // Returns true if the queue is completely empty.
   virtual bool IsEmpty() const = 0;
 
@@ skipping 60 matching lines @@
  protected:
   ~TaskQueue() override {}
 
   DISALLOW_COPY_AND_ASSIGN(TaskQueue);
 };
 
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_PUBLIC_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_H_