Fix potential DCHECK in TaskQueueThrottler::IncreaseThrottleRefCount

third_party/WebKit/Source/platform/scheduler/renderer/task_queue_throttler.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/renderer/task_queue_throttler.h"
 
 #include <cstdint>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 317 matching lines @@
                "task_queue", task_queue);
 
   if (!allow_throttling_)
     return;
 
   task_queue->SetTimeDomain(time_domain_.get());
   // This blocks any tasks from |task_queue| until PumpThrottledTasks() to
   // enforce task alignment.
   task_queue->InsertFence(TaskQueue::InsertFencePosition::BEGINNING_OF_TIME);
 
+  if (!task_queue->IsQueueEnabled())
+    return;
+
   if (!task_queue->IsEmpty()) {
     if (task_queue->HasPendingImmediateWork()) {
       OnTimeDomainHasImmediateWork(task_queue);
     } else {
       OnTimeDomainHasDelayedWork(task_queue);
     }
   }
 }
 
 void TaskQueueThrottler::DecreaseThrottleRefCount(TaskQueue* task_queue) {
@@ skipping 42 matching lines @@
 void TaskQueueThrottler::OnTimeDomainHasImmediateWork(TaskQueue* queue) {
   // Forward to the main thread if called from another thread
   if (!task_runner_->RunsTasksOnCurrentThread()) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(forward_immediate_work_callback_, queue));
     return;
   }
   TRACE_EVENT0(tracing_category_,
                "TaskQueueThrottler::OnTimeDomainHasImmediateWork");
 
+  // We don't expect this to get called for disabled queues, but we can't DCHECK
+  // because of the above thread hop.  Just bail out if the queue is disabled.
+  if (!queue->IsQueueEnabled())
+    return;
+
   base::TimeTicks now = tick_clock_->NowTicks();
   base::TimeTicks next_allowed_run_time = GetNextAllowedRunTime(now, queue);
   MaybeSchedulePumpThrottledTasks(FROM_HERE, now, next_allowed_run_time);
 }
 
 void TaskQueueThrottler::OnTimeDomainHasDelayedWork(TaskQueue* queue) {
   TRACE_EVENT0(tracing_category_,
                "TaskQueueThrottler::OnTimeDomainHasDelayedWork");
+  DCHECK(queue->IsQueueEnabled());
   base::TimeTicks now = tick_clock_->NowTicks();
   LazyNow lazy_now(now);
 
   base::Optional<base::TimeTicks> next_scheduled_delayed_task =
       NextTaskRunTime(&lazy_now, queue);
   DCHECK(next_scheduled_delayed_task);
   MaybeSchedulePumpThrottledTasks(FROM_HERE, now,
                                   next_scheduled_delayed_task.value());
 }
 
@@ skipping 222 matching lines @@
     queue->SetTimeDomain(time_domain_.get());
     MaybeSchedulePumpQueue(FROM_HERE, lazy_now.Now(), queue,
                            GetNextAllowedRunTime(lazy_now.Now(), queue));
   }
 
   TRACE_EVENT0(tracing_category_, "TaskQueueThrottler_EnableThrottling");
 }
 
 }  // namespace scheduler
 }  // namespace blink