Move has_incoming_immediate_work to the TaskQueueManager

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 309 matching lines @@
   }
   TraceQueueSize(false);
 }
 
 void TaskQueueImpl::PushOntoImmediateIncomingQueueLocked(
     const tracked_objects::Location& posted_from,
     const base::Closure& task,
     base::TimeTicks desired_run_time,
     EnqueueOrder sequence_number,
     bool nestable) {
-  if (any_thread().immediate_incoming_queue.empty())
-    any_thread().time_domain->OnQueueHasIncomingImmediateWork(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
+    // However there's no point posting a DoWork for a disabled queue. NB we can
     // only tell if it's disabled from the main thread.
-    if (base::PlatformThread::CurrentId() == thread_id_) {
-      if (IsQueueEnabled() && !BlockedByFenceLocked())
-        any_thread().task_queue_manager->MaybeScheduleImmediateWork(FROM_HERE);
-    } else {
-      any_thread().task_queue_manager->MaybeScheduleImmediateWork(FROM_HERE);
-    }
+    bool ensure_do_work_posted =

[Sami, 2017/01/24 14:52:40]

To separate the concerns a bit, how about calling this something like
|can_run_immediately|? (Alternatively the inverse of that since that's really
the only thing we can guarantee here, but I can't think of a good name for it.)

Should we also DCHECK() that ImmediateTaskCouldRun is consistent with what we
compute here?

[alex clarke (OOO till 29th), 2017/01/24 15:28:14]

I suppose task_currently_blocked?
Well ImmediateTaskCouldRun has gone away so a DCHECK doesn't make sense.

+        !RunsTasksOnCurrentThread() ||
+        (IsQueueEnabled() && !main_thread_only().current_fence);
+    any_thread().task_queue_manager->OnQueueHasIncomingImmediateWork(
+        this, ensure_do_work_posted);
+    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);
 }
 
 void TaskQueueImpl::ReloadImmediateWorkQueueIfEmpty() {
@@ skipping 314 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::BlockedByFenceLocked() const {
-  if (!main_thread_only().current_fence)
+bool TaskQueueImpl::ImmediateTaskCouldRun() const {
+  if (!IsQueueEnabled())
     return false;
 
-  if (!main_thread_only().immediate_work_queue->BlockedByFence() ||
-      !main_thread_only().delayed_work_queue->BlockedByFence()) {
-    return false;
-  }
-
-  if (any_thread().immediate_incoming_queue.empty())
+  if (!main_thread_only().current_fence)
     return true;
 
-  return any_thread().immediate_incoming_queue.front().enqueue_order() >
+  if (!main_thread_only().immediate_work_queue->Empty())
+    return !main_thread_only().immediate_work_queue->BlockedByFence();
+
+  base::AutoLock lock(any_thread_lock_);
+  // If |immediate_incoming_queue| and |immediate_work_queue| are empty then any
+  // task posted is guaranteed to be blocked by the fence.
+  if (any_thread().immediate_incoming_queue.empty())
+    return false;
+
+  return any_thread().immediate_incoming_queue.front().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) {
@@ skipping 148 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