[scheduler] Make any thread lock in TaskQueueImpl reentrable.

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.h

 // 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.
 
 #ifndef THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 261 matching lines @@
     std::unique_ptr<WorkQueue> immediate_work_queue;
     std::priority_queue<Task> delayed_incoming_queue;
     base::ObserverList<base::MessageLoop::TaskObserver> task_observers;
     size_t set_index;
     HeapHandle heap_handle;
     int is_enabled_refcount;
     int voter_refcount;
     base::trace_event::BlameContext* blame_context;  // Not owned.
     EnqueueOrder current_fence;
     base::TimeTicks scheduled_time_domain_wakeup;
+
+    // Number of times any thread lock was acquired from main thread to
+    // allow any thread lock be reentrable from main thread.
+    mutable size_t any_thread_lock_acquired_count;
+  };
+
+  // Helper class to make any_thread_lock reentrable from main thread.
+  // When |acquired_count| pointer is non-null, class uses is to
+  // allow for reentrability. When |acquired_count| is nullptr,
+  // this helper class behaves as a normal base::AutoLock.
+  class AnyThreadAutoLock {
+   public:
+    AnyThreadAutoLock(base::Lock& lock, size_t* acquired_count);
+    AnyThreadAutoLock(AnyThreadAutoLock&& auto_lock) = default;
+    ~AnyThreadAutoLock();
+
+   private:
+    base::Lock& lock_;
+    size_t* acquired_count_;
+    DISALLOW_COPY_AND_ASSIGN(AnyThreadAutoLock);
   };
 
   ~TaskQueueImpl() override;
 
   bool PostImmediateTaskImpl(const tracked_objects::Location& from_here,
                              const base::Closure& task,
                              TaskType task_type);
   bool PostDelayedTaskImpl(const tracked_objects::Location& from_here,
                            const base::Closure& task,
                            base::TimeDelta delay,
@@ skipping 31 matching lines @@
                                base::trace_event::TracedValue* state);
   static void QueueAsValueInto(const std::priority_queue<Task>& queue,
                                base::trace_event::TracedValue* state);
   static void TaskAsValueInto(const Task& task,
                               base::trace_event::TracedValue* state);
 
   void RemoveQueueEnabledVoter(const QueueEnabledVoterImpl* voter);
   void OnQueueEnabledVoteChanged(bool enabled);
   void EnableOrDisableWithSelector(bool enable);
 
+  AnyThreadAutoLock AcquireAnyThreadLock() const;
+
   const base::PlatformThreadId thread_id_;
 
   mutable base::Lock any_thread_lock_;
   AnyThread any_thread_;
   struct AnyThread& any_thread() {
     any_thread_lock_.AssertAcquired();
     return any_thread_;
   }
   const struct AnyThread& any_thread() const {
     any_thread_lock_.AssertAcquired();
@@ skipping 21 matching lines @@
   const bool should_report_when_execution_blocked_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskQueueImpl);
 };
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_