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

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"
@@ skipping 318 matching lines @@
     bool nestable) {
   // If the |immediate_incoming_queue| is empty we need a DoWork posted to make
   // it run.
   if (any_thread().immediate_incoming_queue.empty()) {
     // However there's no point posting a DoWork for a blocked queue. NB we can
     // only tell if it's disabled from the main thread.
     bool queue_is_blocked =
         RunsTasksOnCurrentThread() &&
         (!IsQueueEnabled() || main_thread_only().current_fence);
     any_thread().task_queue_manager->OnQueueHasIncomingImmediateWork(
-        this, queue_is_blocked);
+        this, sequence_number, queue_is_blocked);
     any_thread().time_domain->OnQueueHasImmediateWork(this);
   }
   any_thread().immediate_incoming_queue.emplace_back(
       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);
 }
 
@@ skipping 321 matching lines @@
   }
 
   base::AutoLock lock(any_thread_lock_);
   if (any_thread().immediate_incoming_queue.empty())
     return true;
 
   return any_thread().immediate_incoming_queue.front().enqueue_order() >
          main_thread_only().current_fence;
 }
 
+bool TaskQueueImpl::CouldTaskRun(EnqueueOrder enqueue_order) const {
+  if (!IsQueueEnabled())
+    return false;
+
+  if (!main_thread_only().current_fence)
+    return true;
+
+  return enqueue_order < main_thread_only().current_fence;
+}
+
 EnqueueOrder TaskQueueImpl::GetFenceForTest() const {
   return main_thread_only().current_fence;
 }
 
 // static
 void TaskQueueImpl::QueueAsValueInto(const WTF::Deque<Task>& queue,
                                      base::trace_event::TracedValue* state) {
   for (const Task& task : queue) {
     TaskAsValueInto(task, state);
   }
@@ skipping 145 matching lines @@
 
 void TaskQueueImpl::PushImmediateIncomingTaskForTest(
     TaskQueueImpl::Task&& task) {
   base::AutoLock lock(any_thread_lock_);
   any_thread().immediate_incoming_queue.push_back(std::move(task));
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink