[Try # 3] Scheduler refactoring to virtually eliminate redundant DoWorks

third_party/WebKit/Source/platform/scheduler/base/work_queue.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/work_queue.h"
 
 #include "platform/scheduler/base/work_queue_sets.h"
 
 namespace blink {
 namespace scheduler {
 namespace internal {
 
-WorkQueue::WorkQueue(TaskQueueImpl* task_queue, const char* name)
+WorkQueue::WorkQueue(TaskQueueImpl* task_queue,
+                     const char* name,
+                     QueueType queue_type)
     : work_queue_sets_(nullptr),
       task_queue_(task_queue),
       work_queue_set_index_(0),
       name_(name),
-      fence_(0) {}
+      fence_(0),
+      queue_type_(queue_type) {}
 
 void WorkQueue::AsValueInto(base::trace_event::TracedValue* state) const {
   // Remove const to search |work_queue_| in the destructive manner. Restore the
   // content from |visited| later.
   std::queue<TaskQueueImpl::Task>* mutable_queue =
       const_cast<std::queue<TaskQueueImpl::Task>*>(&work_queue_);
   std::queue<TaskQueueImpl::Task> visited;
   while (!mutable_queue->empty()) {
     TaskQueueImpl::TaskAsValueInto(mutable_queue->front(), state);
     visited.push(std::move(mutable_queue->front()));
@@ skipping 80 matching lines @@
 
   // Skip over canceled tasks, except for the last one since we always return
   // something.
   while (work_queue_.size() > 1u && work_queue_.front().task.IsCancelled()) {
     work_queue_.pop();
   }
 
   TaskQueueImpl::Task pending_task =
       std::move(const_cast<TaskQueueImpl::Task&>(work_queue_.front()));
   work_queue_.pop();
+  if (queue_type_ == QueueType::IMMEDIATE && work_queue_.empty())
+    task_queue_->OnImmediateWorkQueueHasBecomeEmpty(&work_queue_);
+  // OnPopQueue checks BlockedByFence() so we don't need to here.
   work_queue_sets_->OnPopQueue(this);
   task_queue_->TraceQueueSize(false);
   return pending_task;
 }
 
 void WorkQueue::AssignToWorkQueueSets(WorkQueueSets* work_queue_sets) {
   work_queue_sets_ = work_queue_sets;
 }
 
 void WorkQueue::AssignSetIndex(size_t work_queue_set_index) {
@@ skipping 36 matching lines @@
   bool have_other_task =
       other_queue->GetFrontTaskEnqueueOrder(&other_enqueue_order);
   DCHECK(have_task);
   DCHECK(have_other_task);
   return enqueue_order < other_enqueue_order;
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink