Adds TaskQueueManager::AnyThread

third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc

 // Copyright 2014 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_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 40 matching lines @@
 }
 
 TaskQueueManager::TaskQueueManager(
     scoped_refptr<TaskQueueManagerDelegate> delegate,
     const char* tracing_category,
     const char* disabled_by_default_tracing_category,
     const char* disabled_by_default_verbose_tracing_category)
     : real_time_domain_(new RealTimeDomain(tracing_category)),
       delegate_(delegate),
       task_was_run_on_quiescence_monitored_queue_(false),
-      other_thread_pending_wakeup_(false),
       record_task_delay_histograms_(true),
       work_batch_size_(1),
       task_count_(0),
       tracing_category_(tracing_category),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category),
       disabled_by_default_verbose_tracing_category_(
           disabled_by_default_verbose_tracing_category),
       currently_executing_task_queue_(nullptr),
       observer_(nullptr),
@@ skipping 22 matching lines @@
                                      "TaskQueueManager", this);
 
   while (!queues_.empty())
     (*queues_.begin())->UnregisterTaskQueue();
 
   selector_.SetTaskQueueSelectorObserver(nullptr);
 
   delegate_->RemoveNestingObserver(this);
 }
 
+TaskQueueManager::AnyThread::AnyThread() : other_thread_pending_wakeup(false) {}
+
 void TaskQueueManager::RegisterTimeDomain(TimeDomain* time_domain) {
   time_domains_.insert(time_domain);
   time_domain->OnRegisterWithTaskQueueManager(this);
 }
 
 void TaskQueueManager::UnregisterTimeDomain(TimeDomain* time_domain) {
   time_domains_.erase(time_domain);
 }
 
 scoped_refptr<internal::TaskQueueImpl> TaskQueueManager::NewTaskQueue(
@@ skipping 58 matching lines @@
     const tracked_objects::Location& from_here) {
   bool on_main_thread = delegate_->BelongsToCurrentThread();
   // De-duplicate DoWork posts.
   if (on_main_thread) {
     if (!main_thread_pending_wakeups_.insert(base::TimeTicks()).second) {
       return;
     }
     delegate_->PostTask(from_here, from_main_thread_immediate_do_work_closure_);
   } else {
     {
-      base::AutoLock lock(other_thread_lock_);
-      if (other_thread_pending_wakeup_)
+      base::AutoLock lock(any_thread_lock_);
+      if (any_thread().other_thread_pending_wakeup)
         return;
-      other_thread_pending_wakeup_ = true;
+      any_thread().other_thread_pending_wakeup = true;
     }
     delegate_->PostTask(from_here,
                         from_other_thread_immediate_do_work_closure_);
   }
 }
 
 void TaskQueueManager::MaybeScheduleDelayedWork(
     const tracked_objects::Location& from_here,
     base::TimeTicks now,
     base::TimeDelta delay) {
@@ skipping 21 matching lines @@
 }
 
 void TaskQueueManager::DoWork(base::TimeTicks run_time, bool from_main_thread) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   TRACE_EVENT1(tracing_category_, "TaskQueueManager::DoWork",
                "from_main_thread", from_main_thread);
 
   if (from_main_thread) {
     main_thread_pending_wakeups_.erase(run_time);
   } else {
-    base::AutoLock lock(other_thread_lock_);
-    other_thread_pending_wakeup_ = false;
+    base::AutoLock lock(any_thread_lock_);
+    any_thread().other_thread_pending_wakeup = false;
   }
 
   // Posting a DoWork while a DoWork is running leads to spurious DoWorks.
   main_thread_pending_wakeups_.insert(base::TimeTicks());
 
   if (!delegate_->IsNested())
     queues_to_delete_.clear();
 
   LazyNow lazy_now(real_time_domain()->CreateLazyNow());
   UpdateWorkQueues(&lazy_now);
@@ skipping 297 matching lines @@
   for (const scoped_refptr<internal::TaskQueueImpl>& queue : queues_) {
     TimeDomain* time_domain = queue->GetTimeDomain();
     if (time_domain_now.find(time_domain) == time_domain_now.end())
       time_domain_now.insert(std::make_pair(time_domain, time_domain->Now()));
     queue->SweepCanceledDelayedTasks(time_domain_now[time_domain]);
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink