[scheduler] Make any thread lock in TaskQueueImpl reentrable.

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 75 matching lines @@
       should_monitor_quiescence_(spec.should_monitor_quiescence),
       should_notify_observers_(spec.should_notify_observers),
       should_report_when_execution_blocked_(
           spec.should_report_when_execution_blocked) {
   DCHECK(time_domain);
   time_domain->RegisterQueue(this);
 }
 
 TaskQueueImpl::~TaskQueueImpl() {
 #if DCHECK_IS_ON()
-  base::AutoLock lock(any_thread_lock_);
+  AnyThreadAutoLock lock = AcquireAnyThreadLock();
   // NOTE this check shouldn't fire because |TaskQueueManager::queues_|
   // contains a strong reference to this TaskQueueImpl and the TaskQueueManager
   // destructor calls UnregisterTaskQueue on all task queues.
   DCHECK(any_thread().task_queue_manager == nullptr)
       << "UnregisterTaskQueue must be called first!";
 
 #endif
 }
 
 TaskQueueImpl::Task::Task()
@@ skipping 49 matching lines @@
       time_domain(time_domain),
       delayed_work_queue(
           new WorkQueue(task_queue, "delayed", WorkQueue::QueueType::DELAYED)),
       immediate_work_queue(new WorkQueue(task_queue,
                                          "immediate",
                                          WorkQueue::QueueType::IMMEDIATE)),
       set_index(0),
       is_enabled_refcount(0),
       voter_refcount(0),
       blame_context(nullptr),
-      current_fence(0) {}
+      current_fence(0),
+      any_thread_lock_acquired_count(0) {}
 
 TaskQueueImpl::MainThreadOnly::~MainThreadOnly() {}
 
 void TaskQueueImpl::UnregisterTaskQueue() {
-  base::AutoLock lock(any_thread_lock_);
+  AnyThreadAutoLock lock = AcquireAnyThreadLock();
   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;
@@ skipping 23 matching lines @@
   if (delay.is_zero())
     return PostImmediateTaskImpl(from_here, task, TaskType::NON_NESTABLE);
 
   return PostDelayedTaskImpl(from_here, task, delay, TaskType::NON_NESTABLE);
 }
 
 bool TaskQueueImpl::PostImmediateTaskImpl(
     const tracked_objects::Location& from_here,
     const base::Closure& task,
     TaskType task_type) {
-  base::AutoLock lock(any_thread_lock_);
+  AnyThreadAutoLock lock = AcquireAnyThreadLock();
   if (!any_thread().task_queue_manager)
     return false;
 
   EnqueueOrder sequence_number =
       any_thread().task_queue_manager->GetNextSequenceNumber();
 
   PushOntoImmediateIncomingQueueLocked(
       from_here,
       task,
       base::TimeTicks(),
@@ skipping 20 matching lines @@
     base::TimeTicks time_domain_delayed_run_time = time_domain_now + delay;
     PushOntoDelayedIncomingQueueFromMainThread(
         Task(from_here, task, time_domain_delayed_run_time, sequence_number,
              task_type != TaskType::NON_NESTABLE),
         time_domain_now);
   } else {
     // NOTE posting a delayed task from a different thread is not expected to
     // be common. This pathway is less optimal than perhaps it could be
     // because it causes two main thread tasks to be run.  Should this
     // assumption prove to be false in future, we may need to revisit this.
-    base::AutoLock lock(any_thread_lock_);
+    AnyThreadAutoLock lock = AcquireAnyThreadLock();
     if (!any_thread().task_queue_manager)
       return false;
 
     EnqueueOrder sequence_number =
         any_thread().task_queue_manager->GetNextSequenceNumber();
 
     base::TimeTicks time_domain_now = any_thread().time_domain->Now();
     base::TimeTicks time_domain_delayed_run_time = time_domain_now + delay;
     PushOntoDelayedIncomingQueueLocked(
         Task(from_here, task, time_domain_delayed_run_time, sequence_number,
@@ skipping 84 matching lines @@
 }
 
 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_);
+  AnyThreadAutoLock lock = AcquireAnyThreadLock();
   WTF::Deque<TaskQueueImpl::Task> queue;
   queue.swap(any_thread().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_);
+  AnyThreadAutoLock lock = AcquireAnyThreadLock();
   return any_thread().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_);
+  AnyThreadAutoLock lock = AcquireAnyThreadLock();
   task_count += any_thread().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_);
+  AnyThreadAutoLock lock = AcquireAnyThreadLock();
   return !any_thread().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 67 matching lines @@
                                                                     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_);
+  AnyThreadAutoLock lock = AcquireAnyThreadLock();
   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;
@@ skipping 57 matching lines @@
     const base::PendingTask& pending_task) {
   DCHECK(should_notify_observers_);
   for (auto& observer : main_thread_only().task_observers)
     observer.DidProcessTask(pending_task);
   if (main_thread_only().blame_context)
     main_thread_only().blame_context->Leave();
 }
 
 void TaskQueueImpl::SetTimeDomain(TimeDomain* time_domain) {
   {
-    base::AutoLock lock(any_thread_lock_);
+    AnyThreadAutoLock lock = AcquireAnyThreadLock();
     DCHECK(time_domain);
     // NOTE this is similar to checking |any_thread().task_queue_manager| but
     // the TaskQueueSelectorTests constructs TaskQueueImpl directly with a null
     // task_queue_manager.  Instead we check |any_thread().time_domain| which is
     // another way of asserting that UnregisterTaskQueue has not been called.
     DCHECK(any_thread().time_domain);
     if (!any_thread().time_domain)
       return;
     DCHECK(main_thread_checker_.CalledOnValidThread());
     if (time_domain == main_thread_only().time_domain)
@@ skipping 12 matching lines @@
         {main_thread_only().delayed_incoming_queue.top().delayed_run_time,
          main_thread_only().delayed_incoming_queue.top().sequence_num},
         time_domain->Now());
   }
 }
 
 TimeDomain* TaskQueueImpl::GetTimeDomain() const {
   if (base::PlatformThread::CurrentId() == thread_id_)
     return main_thread_only().time_domain;
 
-  base::AutoLock lock(any_thread_lock_);
+  AnyThreadAutoLock lock = AcquireAnyThreadLock();
   return any_thread().time_domain;
 }
 
 void TaskQueueImpl::SetBlameContext(
     base::trace_event::BlameContext* blame_context) {
   main_thread_only().blame_context = blame_context;
 }
 
 void TaskQueueImpl::InsertFence(TaskQueue::InsertFencePosition position) {
   if (!main_thread_only().task_queue_manager)
     return;
 
   EnqueueOrder previous_fence = main_thread_only().current_fence;
   main_thread_only().current_fence =
       position == TaskQueue::InsertFencePosition::NOW
           ? main_thread_only().task_queue_manager->GetNextSequenceNumber()
           : static_cast<EnqueueOrder>(EnqueueOrderValues::BLOCKING_FENCE);
 
   // 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_);
+    AnyThreadAutoLock lock = AcquireAnyThreadLock();
     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() <
             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_);
+    AnyThreadAutoLock lock = AcquireAnyThreadLock();
     if (!any_thread().immediate_incoming_queue.empty() &&
         any_thread().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_);
+  AnyThreadAutoLock lock = AcquireAnyThreadLock();
   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;
@@ skipping 112 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_);
+      AnyThreadAutoLock lock = AcquireAnyThreadLock();
       immediate_queues_empty = any_thread().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,
@@ skipping 46 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_);
+  AnyThreadAutoLock lock = AcquireAnyThreadLock();
   any_thread().immediate_incoming_queue.push_back(std::move(task));
 }
 
+TaskQueueImpl::AnyThreadAutoLock TaskQueueImpl::AcquireAnyThreadLock() const {
+  size_t* any_thread_lock_acquired_from_main_thread_count = nullptr;
+  if (thread_id_ == base::PlatformThread::CurrentId())
+    any_thread_lock_acquired_from_main_thread_count =
+        &main_thread_only().any_thread_lock_acquired_count;
+  return AnyThreadAutoLock(any_thread_lock_,
+                           any_thread_lock_acquired_from_main_thread_count);
+}
+
+TaskQueueImpl::AnyThreadAutoLock::AnyThreadAutoLock(base::Lock& lock,
+                                                    size_t* acquired_count)
+    : lock_(lock), acquired_count_(acquired_count) {
+  if (!acquired_count_ || *acquired_count_ == 0) {
+    lock_.Acquire();
+  }
+  if (acquired_count_)
+    ++*acquired_count_;
+  lock_.AssertAcquired();
+}
+
+TaskQueueImpl::AnyThreadAutoLock::~AnyThreadAutoLock() {
+  lock_.AssertAcquired();
+  if (acquired_count_)
+    --*acquired_count_;
+  if (!acquired_count_ || *acquired_count_ == 0)
+    lock_.Release();
+}
+
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink