Add the concept of QueueEnabledVoters to blink scheduler TaskQueue

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc

 // 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.
 
 #include "platform/scheduler/base/task_queue_impl.h"
 
 #include "base/format_macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/blame_context.h"
 #include "platform/scheduler/base/task_queue_manager.h"
 #include "platform/scheduler/base/task_queue_manager_delegate.h"
 #include "platform/scheduler/base/time_domain.h"
 #include "platform/scheduler/base/work_queue.h"
 
 namespace blink {
 namespace scheduler {
 
@@ skipping 131 matching lines @@
 
 TaskQueueImpl::MainThreadOnly::MainThreadOnly(
     TaskQueueManager* task_queue_manager,
     TaskQueueImpl* task_queue,
     TimeDomain* time_domain)
     : task_queue_manager(task_queue_manager),
       time_domain(time_domain),
       delayed_work_queue(new WorkQueue(task_queue, "delayed")),
       immediate_work_queue(new WorkQueue(task_queue, "immediate")),
       set_index(0),
-      is_enabled(true),
+      is_enabled_refcount(0),
+      voter_refcount(0),
       blame_context(nullptr),
       current_fence(0) {}
 
 TaskQueueImpl::MainThreadOnly::~MainThreadOnly() {}
 
 void TaskQueueImpl::UnregisterTaskQueue() {
   base::AutoLock lock(any_thread_lock_);
   if (main_thread_only().time_domain)
     main_thread_only().time_domain->UnregisterQueue(this);
   if (!any_thread().task_queue_manager)
@@ skipping 155 matching lines @@
     EnqueueOrder sequence_number,
     bool nestable) {
   if (any_thread().immediate_incoming_queue.empty())
     any_thread().time_domain->RegisterAsUpdatableTaskQueue(this);
   // If the |immediate_incoming_queue| is empty we need a DoWork posted to make
   // it run.
   if (any_thread().immediate_incoming_queue.empty()) {
     // There's no point posting a DoWork for a disabled queue, however we can
     // only tell if it's disabled from the main thread.
     if (base::PlatformThread::CurrentId() == thread_id_) {
-      if (main_thread_only().is_enabled && !BlockedByFenceLocked())
+      if (IsQueueEnabled() && !BlockedByFenceLocked())
         any_thread().task_queue_manager->MaybeScheduleImmediateWork(FROM_HERE);
     } else {
       any_thread().task_queue_manager->MaybeScheduleImmediateWork(FROM_HERE);
     }
   }
   any_thread().immediate_incoming_queue.emplace(
       posted_from, task, desired_run_time, sequence_number, nestable, sequence_number);
   any_thread().task_queue_manager->DidQueueTask( any_thread().immediate_incoming_queue.back());
   TraceQueueSize(true);
 }
 
-void TaskQueueImpl::SetQueueEnabled(bool enabled) {
-  if (main_thread_only().is_enabled == enabled)
-    return;
-  main_thread_only().is_enabled = enabled;
-  if (!main_thread_only().task_queue_manager)
-    return;
-  if (enabled) {
-    // Note it's the job of the selector to tell the TaskQueueManager if
-    // a DoWork needs posting.
-    main_thread_only().task_queue_manager->selector_.EnableQueue(this);
-  } else {
-    main_thread_only().task_queue_manager->selector_.DisableQueue(this);
-  }
-}
-
-bool TaskQueueImpl::IsQueueEnabled() const {
-  return main_thread_only().is_enabled;
-}
-
 bool TaskQueueImpl::IsEmpty() const {
   if (!main_thread_only().delayed_work_queue->Empty() ||
       !main_thread_only().delayed_incoming_queue.empty() ||
       !main_thread_only().immediate_work_queue->Empty()) {
     return false;
   }
 
   base::AutoLock lock(any_thread_lock_);
   return any_thread().immediate_incoming_queue.empty();
 }
@@ skipping 123 matching lines @@
 }
 
 void TaskQueueImpl::AsValueInto(base::trace_event::TracedValue* state) const {
   base::AutoLock lock(any_thread_lock_);
   state->BeginDictionary();
   state->SetString("name", GetName());
   state->SetString(
       "task_queue_id",
       base::StringPrintf("%" PRIx64, static_cast<uint64_t>(
                                          reinterpret_cast<uintptr_t>(this))));
-  state->SetBoolean("enabled", main_thread_only().is_enabled);
+  state->SetBoolean("enabled", IsQueueEnabled());
   state->SetString("time_domain_name",
                    main_thread_only().time_domain->GetName());
   bool verbose_tracing_enabled = false;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(
       disabled_by_default_verbose_tracing_category_, &verbose_tracing_enabled);
   state->SetInteger("immediate_incoming_queue_size",
                     any_thread().immediate_incoming_queue.size());
   state->SetInteger("delayed_incoming_queue_size",
                     main_thread_only().delayed_incoming_queue.size());
   state->SetInteger("immediate_work_queue_size",
@@ skipping 113 matching lines @@
     base::AutoLock lock(any_thread_lock_);
     if (!any_thread().immediate_incoming_queue.empty() &&
         any_thread().immediate_incoming_queue.front().enqueue_order() >
             previous_fence &&
         any_thread().immediate_incoming_queue.front().enqueue_order() <
             main_thread_only().current_fence) {
       task_unblocked = true;
     }
   }
 
-  if (main_thread_only().is_enabled && task_unblocked) {
+  if (IsQueueEnabled() && task_unblocked) {
     main_thread_only().task_queue_manager->MaybeScheduleImmediateWork(
         FROM_HERE);
   }
 }
 
 void TaskQueueImpl::RemoveFence() {
   if (!main_thread_only().task_queue_manager)
     return;
 
   EnqueueOrder previous_fence = main_thread_only().current_fence;
   main_thread_only().current_fence = 0;
 
   bool task_unblocked = main_thread_only().immediate_work_queue->RemoveFence();
   task_unblocked |= main_thread_only().delayed_work_queue->RemoveFence();
 
   if (!task_unblocked && previous_fence) {
     base::AutoLock lock(any_thread_lock_);
     if (!any_thread().immediate_incoming_queue.empty() &&
         any_thread().immediate_incoming_queue.front().enqueue_order() >
             previous_fence) {
       task_unblocked = true;
     }
   }
 
-  if (main_thread_only().is_enabled && task_unblocked) {
+  if (IsQueueEnabled() && task_unblocked) {
     main_thread_only().task_queue_manager->MaybeScheduleImmediateWork(
         FROM_HERE);
   }
 }
 
 bool TaskQueueImpl::BlockedByFence() const {
   if (!main_thread_only().current_fence)
     return false;
 
   if (!main_thread_only().immediate_work_queue->BlockedByFence() ||
@@ skipping 74 matching lines @@
   state->SetInteger("sequence_num", task.sequence_num);
   state->SetBoolean("nestable", task.nestable);
   state->SetBoolean("is_high_res", task.is_high_res);
   state->SetBoolean("is_cancelled", task.task.IsCancelled());
   state->SetDouble(
       "delayed_run_time",
       (task.delayed_run_time - base::TimeTicks()).InMicroseconds() / 1000.0L);
   state->EndDictionary();
 }
 
+TaskQueueImpl::QueueEnabledVoterImpl::QueueEnabledVoterImpl(
+    TaskQueueImpl* task_queue)
+    : task_queue_(task_queue), enabled_(true) {}
+
+TaskQueueImpl::QueueEnabledVoterImpl::~QueueEnabledVoterImpl() {
+  task_queue_->RemoveQueueEnabledVoter(this);
+}
+
+TaskQueue* TaskQueueImpl::QueueEnabledVoterImpl::GetTaskQueue() const {
+  return task_queue_.get();
+}
+
+void TaskQueueImpl::QueueEnabledVoterImpl::SetQueueEnabled(bool enabled) {
+  if (enabled_ == enabled)
+    return;
+
+  task_queue_->QueueEnabledVoteChanged(enabled);
+  enabled_ = enabled;
+}
+
+void TaskQueueImpl::RemoveQueueEnabledVoter(
+    const QueueEnabledVoterImpl* voter) {
+  bool was_enabled = IsQueueEnabled();
+  if (voter->enabled_) {
+    main_thread_only().is_enabled_refcount--;
+    DCHECK_GE(main_thread_only().is_enabled_refcount, 0);
+  }
+
+  main_thread_only().voter_refcount--;
+  DCHECK_GE(main_thread_only().voter_refcount, 0);
+
+  bool is_enabled = IsQueueEnabled();
+  if (was_enabled != is_enabled)
+    EnableOrDisableWithSelector(is_enabled);
+}
+
+bool TaskQueueImpl::IsQueueEnabled() const {
+  return main_thread_only().is_enabled_refcount ==
+         main_thread_only().voter_refcount;
+}
+
+void TaskQueueImpl::QueueEnabledVoteChanged(bool enabled) {
+  bool was_enabled = IsQueueEnabled();
+  if (enabled) {
+    main_thread_only().is_enabled_refcount++;
+    DCHECK_LE(main_thread_only().is_enabled_refcount,
+              main_thread_only().voter_refcount);
+  } else {
+    main_thread_only().is_enabled_refcount--;
+    DCHECK_GE(main_thread_only().is_enabled_refcount, 0);
+  }
+
+  bool is_enabled = IsQueueEnabled();
+  if (was_enabled != is_enabled)
+    EnableOrDisableWithSelector(is_enabled);
+}
+
+void TaskQueueImpl::EnableOrDisableWithSelector(bool enable) {
+  if (!main_thread_only().task_queue_manager)
+    return;
+
+  if (enable) {
+    // Note it's the job of the selector to tell the TaskQueueManager if
+    // a DoWork needs posting.
+    main_thread_only().task_queue_manager->selector_.EnableQueue(this);
+  } else {
+    main_thread_only().task_queue_manager->selector_.DisableQueue(this);
+  }
+}
+
+std::unique_ptr<TaskQueueImpl::QueueEnabledVoter>
+TaskQueueImpl::GetQueueEnabledVoter() {
+  main_thread_only().voter_refcount++;
+  main_thread_only().is_enabled_refcount++;
+  return base::MakeUnique<QueueEnabledVoterImpl>(this);
+}
+
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink