Add the concept of QueueEnabledVoters to blink scheduler TaskQueue

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 101 matching lines @@
 
   // TaskQueue implementation.
   void UnregisterTaskQueue() override;
   bool RunsTasksOnCurrentThread() const override;
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const base::Closure& task,
                        base::TimeDelta delay) override;
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   const base::Closure& task,
                                   base::TimeDelta delay) override;
-  void SetQueueEnabled(bool enabled) 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;
 
   // If this returns false then future updates for this queue are not needed
   // unless requested.
   bool MaybeUpdateImmediateWorkQueues();
 
-  const char* GetName() const override;
-  QueueType GetQueueType() const override;
-
   void AsValueInto(base::trace_event::TracedValue* state) const;
 
   bool GetQuiescenceMonitored() const { return should_monitor_quiescence_; }
   bool GetShouldNotifyObservers() const { return should_notify_observers_; }
 
   void NotifyWillProcessTask(const base::PendingTask& pending_task);
   void NotifyDidProcessTask(const base::PendingTask& pending_task);
 
   WorkQueue* delayed_work_queue() {
     return main_thread_only().delayed_work_queue.get();
@@ skipping 31 matching lines @@
   }
 
   HeapHandle heap_handle() const { return main_thread_only().heap_handle; }
 
   void set_heap_handle(HeapHandle heap_handle) {
     main_thread_only().heap_handle = heap_handle;
   }
 
   EnqueueOrder GetFenceForTest() const;
 
+  class QueueEnabledVoterImpl : public QueueEnabledVoter {
+   public:
+    explicit QueueEnabledVoterImpl(TaskQueueImpl* task_queue);
+    ~QueueEnabledVoterImpl() override;
+
+    // QueueEnabledVoter implementation.
+    void SetQueueEnabled(bool enabled) override;
+
+    TaskQueueImpl* GetTaskQueueForTest() const { return task_queue_.get(); }
+
+   private:
+    friend class TaskQueueImpl;
+
+    scoped_refptr<TaskQueueImpl> task_queue_;
+    bool enabled_;
+  };
+
  private:
   friend class WorkQueue;
   friend class WorkQueueTest;
 
   enum class TaskType {
     NORMAL,
     NON_NESTABLE,
   };
 
   struct AnyThread {
@@ skipping 19 matching lines @@
     // the main thread. See description inside struct AnyThread for details.
     TaskQueueManager* task_queue_manager;
     TimeDomain* time_domain;
 
     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;
-    bool is_enabled;
+    int is_enabled_refcount;
+    int voter_refcount;
     base::trace_event::BlameContext* blame_context;  // Not owned.
     EnqueueOrder current_fence;
     base::TimeTicks scheduled_time_domain_wakeup;
   };
 
   ~TaskQueueImpl() override;
 
   bool PostImmediateTaskImpl(const tracked_objects::Location& from_here,
                              const base::Closure& task,
                              TaskType task_type);
@@ skipping 29 matching lines @@
   bool BlockedByFenceLocked() const;
 
   void TraceQueueSize(bool is_locked) const;
   static void QueueAsValueInto(const std::queue<Task>& queue,
                                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);
+
   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 21 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_