[scheduler] Add TaskQueue::Observer

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.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_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 47 matching lines @@
 // delayed_work_queue.  The reason for this is we want to make sure delayed
 // tasks (normally the most common type) don't starve out immediate work.
 class BLINK_PLATFORM_EXPORT TaskQueueImpl final : public TaskQueue {
  public:
   TaskQueueImpl(TaskQueueManager* task_queue_manager,
                 TimeDomain* time_domain,
                 const Spec& spec,
                 const char* disabled_by_default_tracing_category,
                 const char* disabled_by_default_verbose_tracing_category);
 
+  // Represents a time at which a task wants to run. Tasks scheduled for the
+  // same point in time will be ordered by their sequence numbers.
+  struct DelayedWakeUp {
+    base::TimeTicks time;
+    int sequence_num;
+
+    bool operator<=(const DelayedWakeUp& other) const {
+      if (time == other.time) {
+        DCHECK_NE(sequence_num, other.sequence_num);
+        return (sequence_num - other.sequence_num) < 0;
+      }
+      return time < other.time;
+    }
+  };
+
   class BLINK_PLATFORM_EXPORT Task : public base::PendingTask {
    public:
     Task();
     Task(const tracked_objects::Location& posted_from,
          base::OnceClosure task,
          base::TimeTicks desired_run_time,
          EnqueueOrder sequence_number,
          bool nestable);
 
     Task(const tracked_objects::Location& posted_from,
          base::OnceClosure task,
          base::TimeTicks desired_run_time,
          EnqueueOrder sequence_number,
          bool nestable,
          EnqueueOrder enqueue_order);
 
+    DelayedWakeUp delayed_wake_up() const {
+      return DelayedWakeUp{delayed_run_time, sequence_num};
+    }
+
     EnqueueOrder enqueue_order() const {
 #ifndef NDEBUG
       DCHECK(enqueue_order_set_);
 #endif
       return enqueue_order_;
     }
 
     void set_enqueue_order(EnqueueOrder enqueue_order) {
 #ifndef NDEBUG
       DCHECK(!enqueue_order_set_);
@@ skipping 11 matching lines @@
     bool enqueue_order_set_;
 #endif
     // Similar to sequence number, but ultimately the |enqueue_order_| is what
     // the scheduler uses for task ordering. For immediate tasks |enqueue_order|
     // is set when posted, but for delayed tasks it's not defined until they are
     // enqueued on the |delayed_work_queue_|. This is because otherwise delayed
     // tasks could run before an immediate task posted after the delayed task.
     EnqueueOrder enqueue_order_;
   };
 
-  // Represents a time at which a task wants to run. Tasks scheduled for the
-  // same point in time will be ordered by their sequence numbers.
-  struct DelayedWakeUp {
-    base::TimeTicks time;
-    int sequence_num;
-
-    bool operator<=(const DelayedWakeUp& other) const {
-      if (time == other.time) {
-        DCHECK_NE(sequence_num, other.sequence_num);
-        return (sequence_num - other.sequence_num) < 0;
-      }
-      return time < other.time;
-    }
-  };
-
   // TaskQueue implementation.
   void UnregisterTaskQueue() override;
   bool RunsTasksOnCurrentThread() const override;
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        base::OnceClosure task,
                        base::TimeDelta delay) override;
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   base::OnceClosure task,
                                   base::TimeDelta delay) override;
   std::unique_ptr<QueueEnabledVoter> CreateQueueEnabledVoter() override;
   bool IsQueueEnabled() const override;
   bool IsEmpty() const override;
   size_t GetNumberOfPendingTasks() const override;
   bool HasPendingImmediateWork() const override;
   base::Optional<base::TimeTicks> GetNextScheduledWakeUp() override;
   void SetQueuePriority(QueuePriority priority) override;
   QueuePriority GetQueuePriority() const override;
   void AddTaskObserver(base::MessageLoop::TaskObserver* task_observer) override;
   void RemoveTaskObserver(
       base::MessageLoop::TaskObserver* task_observer) override;
   void SetTimeDomain(TimeDomain* time_domain) override;
   TimeDomain* GetTimeDomain() const override;
   void SetBlameContext(base::trace_event::BlameContext* blame_context) override;
   void InsertFence(InsertFencePosition position) override;
   void RemoveFence() override;
   bool BlockedByFence() const override;
   const char* GetName() const override;
   QueueType GetQueueType() const override;
+  void SetObserver(Observer* observer) override;
 
   // Returns true if a (potentially hypothetical) task with the specified
   // |enqueue_order| could run on the queue. Must be called from the main
   // thread.
   bool CouldTaskRun(EnqueueOrder enqueue_order) const;
 
   // Must only be called from the thread this task queue was created on.
   void ReloadImmediateWorkQueueIfEmpty();
 
   void AsValueInto(base::trace_event::TracedValue* state) const;
@@ skipping 74 matching lines @@
 
   enum class TaskType {
     NORMAL,
     NON_NESTABLE,
   };
 
   struct AnyThread {
     AnyThread(TaskQueueManager* task_queue_manager, TimeDomain* time_domain);
     ~AnyThread();
 
-    // TaskQueueManager and TimeDomain are maintained in two copies:
+    // TaskQueueManager, TimeDomain and Observer are maintained in two copies:
     // inside AnyThread and inside MainThreadOnly. They can be changed only from
     // main thread, so it should be locked before accessing from other threads.
     TaskQueueManager* task_queue_manager;
     TimeDomain* time_domain;
+    Observer* observer;
   };
 
   struct MainThreadOnly {
     MainThreadOnly(TaskQueueManager* task_queue_manager,
                    TaskQueueImpl* task_queue,
                    TimeDomain* time_domain);
     ~MainThreadOnly();
 
-    // Another copy of TaskQueueManager and TimeDomain for lock-free access from
-    // the main thread. See description inside struct AnyThread for details.
+    // Another copy of TaskQueueManager, TimeDomain and Observer
+    // for lock-free access from the main thread.
+    // See description inside struct AnyThread for details.
     TaskQueueManager* task_queue_manager;
     TimeDomain* time_domain;
+    Observer* observer;
 
     std::unique_ptr<WorkQueue> delayed_work_queue;
     std::unique_ptr<WorkQueue> immediate_work_queue;
     std::priority_queue<Task> delayed_incoming_queue;
     base::ObserverList<base::MessageLoop::TaskObserver> task_observers;
     size_t set_index;
     HeapHandle heap_handle;
     int is_enabled_refcount;
     int voter_refcount;
     base::trace_event::BlameContext* blame_context;  // Not owned.
@@ skipping 43 matching lines @@
                                base::trace_event::TracedValue* state);
   static void QueueAsValueInto(const std::priority_queue<Task>& queue,
                                base::trace_event::TracedValue* state);
   static void TaskAsValueInto(const Task& task,
                               base::trace_event::TracedValue* state);
 
   void RemoveQueueEnabledVoter(const QueueEnabledVoterImpl* voter);
   void OnQueueEnabledVoteChanged(bool enabled);
   void EnableOrDisableWithSelector(bool enable);
 
+  // Schedules delayed work on time domain and calls the observer.
+  void ScheduleDelayedWorkInTimeDomain(base::TimeTicks now);
+
+  void NotifyWakeUpChangedOnMainThread(base::TimeTicks wake_up);
+
   const base::PlatformThreadId thread_id_;
 
   mutable base::Lock any_thread_lock_;
   AnyThread any_thread_;
   struct AnyThread& any_thread() {
     any_thread_lock_.AssertAcquired();
     return any_thread_;
   }
   const struct AnyThread& any_thread() const {
     any_thread_lock_.AssertAcquired();
@@ skipping 32 matching lines @@
   const bool should_report_when_execution_blocked_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskQueueImpl);
 };
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_