[scheduler] Split lock in TaskQueueImpl.

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 <utility>
 
 #include "base/format_macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 154 matching lines @@
       set_index(0),
       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_);
+  base::AutoLock immediate_incoming_queue_lock(immediate_incoming_queue_lock_);
   if (main_thread_only().time_domain)
     main_thread_only().time_domain->UnregisterQueue(this);
   if (!any_thread().task_queue_manager)
     return;
   any_thread().time_domain = nullptr;
   main_thread_only().time_domain = nullptr;
   any_thread().task_queue_manager->UnregisterTaskQueue(this);
 
   any_thread().task_queue_manager = nullptr;
   main_thread_only().task_queue_manager = nullptr;
   main_thread_only().delayed_incoming_queue = std::priority_queue<Task>();
-  any_thread().immediate_incoming_queue.clear();
+  immediate_incoming_queue().clear();
   main_thread_only().immediate_work_queue.reset();
   main_thread_only().delayed_work_queue.reset();
 }
 
 bool TaskQueueImpl::RunsTasksOnCurrentThread() const {
   return base::PlatformThread::CurrentId() == thread_id_;
 }
 
 bool TaskQueueImpl::PostDelayedTask(const tracked_objects::Location& from_here,
                                     base::Closure task,
@@ skipping 85 matching lines @@
   // is requested if the queue is enabled.  Note we still want to schedule a
   // wakeup even if blocked by a fence, because we'd break throttling logic
   // otherwise.
   base::TimeTicks next_delayed_task =
       main_thread_only().delayed_incoming_queue.top().delayed_run_time;
   if (next_delayed_task == delayed_run_time && IsQueueEnabled()) {
     main_thread_only().time_domain->ScheduleDelayedWork(
         this, {delayed_run_time, pending_task.sequence_num}, now);
   }
 
-  TraceQueueSize(false);
+  TraceQueueSize();
 }
 
 void TaskQueueImpl::PushOntoDelayedIncomingQueueLocked(Task pending_task) {
   any_thread().task_queue_manager->DidQueueTask(pending_task);
 
   int thread_hop_task_sequence_number =
       any_thread().task_queue_manager->GetNextSequenceNumber();
   PushOntoImmediateIncomingQueueLocked(
      FROM_HERE,
      base::Bind(&TaskQueueImpl::ScheduleDelayedWorkTask, this,
@@ skipping 14 matching lines @@
     delayed_run_time = time_domain_now;
     pending_task.delayed_run_time = time_domain_now;
     main_thread_only().delayed_incoming_queue.push(std::move(pending_task));
     LazyNow lazy_now(time_domain_now);
     WakeUpForDelayedWork(&lazy_now);
   } else {
     // If |delayed_run_time| is in the future we can queue it as normal.
     PushOntoDelayedIncomingQueueFromMainThread(std::move(pending_task),
                                                time_domain_now);
   }
-  TraceQueueSize(false);
+  TraceQueueSize();
 }
 
 void TaskQueueImpl::PushOntoImmediateIncomingQueueLocked(
     const tracked_objects::Location& posted_from,
     base::Closure task,
     base::TimeTicks desired_run_time,
     EnqueueOrder sequence_number,
     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()) {
+  bool is_immediate_incoming_queue_empty;

[Sami, 2017/04/03 14:29:36]

s/is/was/

[altimin, 2017/04/03 14:47:09]

Done.

+  Task* queued_task;
+
+  {
+    base::AutoLock lock(immediate_incoming_queue_lock_);
+    is_immediate_incoming_queue_empty = immediate_incoming_queue().empty();
+    immediate_incoming_queue().emplace_back(posted_from, std::move(task),
+                                            desired_run_time, sequence_number,
+                                            nestable, sequence_number);
+    queued_task = &immediate_incoming_queue().back();
+  }
+
+  if (is_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, sequence_number, queue_is_blocked);
     any_thread().time_domain->OnQueueHasImmediateWork(this);
   }
-  any_thread().immediate_incoming_queue.emplace_back(
-      posted_from, std::move(task), desired_run_time, sequence_number, nestable,
-      sequence_number);
-  any_thread().task_queue_manager->DidQueueTask(
-      any_thread().immediate_incoming_queue.back());
-  TraceQueueSize(true);
+
+  any_thread().task_queue_manager->DidQueueTask(*queued_task);

[Sami, 2017/04/03 14:29:36]

Let's do this while holding the lock so queued_task remains valid.

[altimin, 2017/04/03 14:47:09]

Done.

+  TraceQueueSize();
 }
 
 void TaskQueueImpl::ReloadImmediateWorkQueueIfEmpty() {
   if (!main_thread_only().immediate_work_queue->Empty())
     return;
 
   main_thread_only().immediate_work_queue->ReloadEmptyImmediateQueue();
 }
 
 WTF::Deque<TaskQueueImpl::Task> TaskQueueImpl::TakeImmediateIncomingQueue() {
-  base::AutoLock lock(any_thread_lock_);
+  base::AutoLock immediate_incoming_queue_lock(immediate_incoming_queue_lock_);
   WTF::Deque<TaskQueueImpl::Task> queue;
-  queue.swap(any_thread().immediate_incoming_queue);
+  queue.swap(immediate_incoming_queue());
   return queue;
 }
 
 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();
+  base::AutoLock lock(immediate_incoming_queue_lock_);
+  return immediate_incoming_queue().empty();
 }
 
 size_t TaskQueueImpl::GetNumberOfPendingTasks() const {
   size_t task_count = 0;
   task_count += main_thread_only().delayed_work_queue->Size();
   task_count += main_thread_only().delayed_incoming_queue.size();
   task_count += main_thread_only().immediate_work_queue->Size();
 
-  base::AutoLock lock(any_thread_lock_);
-  task_count += any_thread().immediate_incoming_queue.size();
+  base::AutoLock lock(immediate_incoming_queue_lock_);
+  task_count += immediate_incoming_queue().size();
   return task_count;
 }
 
 bool TaskQueueImpl::HasPendingImmediateWork() const {
   // Any work queue tasks count as immediate work.
   if (!main_thread_only().delayed_work_queue->Empty() ||
       !main_thread_only().immediate_work_queue->Empty()) {
     return true;
   }
 
   // Tasks on |delayed_incoming_queue| that could run now, count as
   // immediate work.
   if (!main_thread_only().delayed_incoming_queue.empty() &&
       main_thread_only().delayed_incoming_queue.top().delayed_run_time <=
           main_thread_only().time_domain->CreateLazyNow().Now()) {
     return true;
   }
 
   // Finally tasks on |immediate_incoming_queue| count as immediate work.
-  base::AutoLock lock(any_thread_lock_);
-  return !any_thread().immediate_incoming_queue.empty();
+  base::AutoLock lock(immediate_incoming_queue_lock_);
+  return !immediate_incoming_queue().empty();
 }
 
 base::Optional<base::TimeTicks> TaskQueueImpl::GetNextScheduledWakeUp() {
   // Note we don't scheduled a wakeup for disabled queues.
   if (main_thread_only().delayed_incoming_queue.empty() || !IsQueueEnabled())
     return base::nullopt;
 
   return main_thread_only().delayed_incoming_queue.top().delayed_run_time;
 }
 
@@ skipping 19 matching lines @@
   // Make sure the next wake up is scheduled.
   if (!main_thread_only().delayed_incoming_queue.empty()) {
     return DelayedWakeUp{
         main_thread_only().delayed_incoming_queue.top().delayed_run_time,
         main_thread_only().delayed_incoming_queue.top().sequence_num};
   }
 
   return base::nullopt;
 }
 
-void TaskQueueImpl::TraceQueueSize(bool is_locked) const {
+void TaskQueueImpl::TraceQueueSize() const {
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(disabled_by_default_tracing_category_,
                                      &is_tracing);
   if (!is_tracing)
     return;
 
   // It's only safe to access the work queues from the main thread.
   // TODO(alexclarke): We should find another way of tracing this
   if (base::PlatformThread::CurrentId() != thread_id_)
     return;
 
-  if (!is_locked)
-    any_thread_lock_.Acquire();
-  else
-    any_thread_lock_.AssertAcquired();
+  base::AutoLock lock(immediate_incoming_queue_lock_);
   TRACE_COUNTER1(disabled_by_default_tracing_category_, GetName(),
-                 any_thread().immediate_incoming_queue.size() +
+                 immediate_incoming_queue().size() +
                      main_thread_only().immediate_work_queue->Size() +
                      main_thread_only().delayed_work_queue->Size() +
                      main_thread_only().delayed_incoming_queue.size());
-  if (!is_locked)
-    any_thread_lock_.Release();
 }
 
 const char* TaskQueueImpl::GetName() const {
   return name_;
 }
 
 TaskQueue::QueueType TaskQueueImpl::GetQueueType() const {
   return type_;
 }
 
 void TaskQueueImpl::SetQueuePriority(QueuePriority priority) {
   if (!main_thread_only().task_queue_manager || priority == GetQueuePriority())
     return;
   main_thread_only().task_queue_manager->selector_.SetQueuePriority(this,
                                                                     priority);
 }
 
 TaskQueueImpl::QueuePriority TaskQueueImpl::GetQueuePriority() const {
   size_t set_index = immediate_work_queue()->work_queue_set_index();
   DCHECK_EQ(set_index, delayed_work_queue()->work_queue_set_index());
   return static_cast<TaskQueue::QueuePriority>(set_index);
 }
 
 void TaskQueueImpl::AsValueInto(base::trace_event::TracedValue* state) const {
   base::AutoLock lock(any_thread_lock_);
+  base::AutoLock immediate_incoming_queue_lock(immediate_incoming_queue_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", 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());
+                    immediate_incoming_queue().size());
   state->SetInteger("delayed_incoming_queue_size",
                     main_thread_only().delayed_incoming_queue.size());
   state->SetInteger("immediate_work_queue_size",
                     main_thread_only().immediate_work_queue->Size());
   state->SetInteger("delayed_work_queue_size",
                     main_thread_only().delayed_work_queue->Size());
   if (!main_thread_only().delayed_incoming_queue.empty()) {
     base::TimeDelta delay_to_next_task =
         (main_thread_only().delayed_incoming_queue.top().delayed_run_time -
          main_thread_only().time_domain->CreateLazyNow().Now());
     state->SetDouble("delay_to_next_task_ms",
                      delay_to_next_task.InMillisecondsF());
   }
   if (main_thread_only().current_fence)
     state->SetInteger("current_fence", main_thread_only().current_fence);
   if (verbose_tracing_enabled) {
     state->BeginArray("immediate_incoming_queue");
-    QueueAsValueInto(any_thread().immediate_incoming_queue, state);
+    QueueAsValueInto(immediate_incoming_queue(), state);
     state->EndArray();
     state->BeginArray("delayed_work_queue");
     main_thread_only().delayed_work_queue->AsValueInto(state);
     state->EndArray();
     state->BeginArray("immediate_work_queue");
     main_thread_only().immediate_work_queue->AsValueInto(state);
     state->EndArray();
     state->BeginArray("delayed_incoming_queue");
     QueueAsValueInto(main_thread_only().delayed_incoming_queue, state);
     state->EndArray();
@@ skipping 86 matching lines @@
 
   // Tasks posted after this point will have a strictly higher enqueue order
   // and will be blocked from running.
   bool task_unblocked = main_thread_only().immediate_work_queue->InsertFence(
       main_thread_only().current_fence);
   task_unblocked |= main_thread_only().delayed_work_queue->InsertFence(
       main_thread_only().current_fence);
 
   if (!task_unblocked && previous_fence &&
       previous_fence < main_thread_only().current_fence) {
-    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() <
+    base::AutoLock lock(immediate_incoming_queue_lock_);
+    if (!immediate_incoming_queue().empty() &&
+        immediate_incoming_queue().front().enqueue_order() > previous_fence &&
+        immediate_incoming_queue().front().enqueue_order() <
             main_thread_only().current_fence) {
       task_unblocked = true;
     }
   }
 
   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) {
+    base::AutoLock lock(immediate_incoming_queue_lock_);
+    if (!immediate_incoming_queue().empty() &&
+        immediate_incoming_queue().front().enqueue_order() > previous_fence) {
       task_unblocked = true;
     }
   }
 
   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() ||
       !main_thread_only().delayed_work_queue->BlockedByFence()) {
     return false;
   }
 
-  base::AutoLock lock(any_thread_lock_);
-  if (any_thread().immediate_incoming_queue.empty())
+  base::AutoLock lock(immediate_incoming_queue_lock_);
+  if (immediate_incoming_queue().empty())
     return true;
 
-  return any_thread().immediate_incoming_queue.front().enqueue_order() >
+  return 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;
 
@@ skipping 108 matching lines @@
 
 void TaskQueueImpl::EnableOrDisableWithSelector(bool enable) {
   if (!main_thread_only().task_queue_manager)
     return;
 
   if (enable) {
     // Check if there's any immediate work on either queue.
     bool immediate_queues_empty =
         main_thread_only().immediate_work_queue->Empty();
     if (immediate_queues_empty) {
-      base::AutoLock lock(any_thread_lock_);
-      immediate_queues_empty = any_thread().immediate_incoming_queue.empty();
+      base::AutoLock lock(immediate_incoming_queue_lock_);
+      immediate_queues_empty = immediate_incoming_queue().empty();
     }
     // Avoid holding the lock while we fire the notification.
     if (!immediate_queues_empty)
       main_thread_only().time_domain->OnQueueHasImmediateWork(this);
 
     if (!main_thread_only().delayed_incoming_queue.empty()) {
       main_thread_only().time_domain->ScheduleDelayedWork(
           this,
           {main_thread_only().delayed_incoming_queue.top().delayed_run_time,
            main_thread_only().delayed_incoming_queue.top().sequence_num},
@@ skipping 45 matching lines @@
           this,
           {main_thread_only().delayed_incoming_queue.top().delayed_run_time,
            main_thread_only().delayed_incoming_queue.top().sequence_num},
           main_thread_only().time_domain->Now());
     }
   }
 }
 
 void TaskQueueImpl::PushImmediateIncomingTaskForTest(
     TaskQueueImpl::Task&& task) {
-  base::AutoLock lock(any_thread_lock_);
-  any_thread().immediate_incoming_queue.push_back(std::move(task));
+  base::AutoLock lock(immediate_incoming_queue_lock_);
+  immediate_incoming_queue().push_back(std::move(task));
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink