[scheduler] Add TaskQueue::Observer

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 148 matching lines @@
     const IncomingImmediateWorkMap& queues_to_reload) const {
   // There are two cases where a queue needs reloading.  First, it might be
   // completely empty and we've just posted a task (this method handles that
   // case). Secondly if the work queue becomes empty in when calling
   // WorkQueue::TakeTaskFromWorkQueue (handled there).
   for (const auto& pair : queues_to_reload) {
     pair.first->ReloadImmediateWorkQueueIfEmpty();
   }
 }
 
-void TaskQueueManager::WakeupReadyDelayedQueues(LazyNow* lazy_now) {
+void TaskQueueManager::WakeUpReadyDelayedQueues(LazyNow* lazy_now) {
   TRACE_EVENT0(disabled_by_default_tracing_category_,
-               "TaskQueueManager::WakeupReadyDelayedQueues");
+               "TaskQueueManager::WakeUpReadyDelayedQueues");
 
   for (TimeDomain* time_domain : time_domains_) {
     if (time_domain == real_time_domain_.get()) {
-      time_domain->WakeupReadyDelayedQueues(lazy_now);
+      time_domain->WakeUpReadyDelayedQueues(lazy_now);
     } else {
       LazyNow time_domain_lazy_now = time_domain->CreateLazyNow();
-      time_domain->WakeupReadyDelayedQueues(&time_domain_lazy_now);
+      time_domain->WakeUpReadyDelayedQueues(&time_domain_lazy_now);
     }
   }
 }
 
 void TaskQueueManager::OnBeginNestedMessageLoop() {
   // We just entered a nested message loop, make sure there's a DoWork posted or
   // the system will grind to a halt.
   {
     base::AutoLock lock(any_thread_lock_);
     any_thread().immediate_do_work_posted_count++;
@@ skipping 44 matching lines @@
                "TaskQueueManager::MaybeScheduleImmediateWorkLocked::PostTask");
   delegate_->PostTask(from_here, immediate_do_work_closure_);
 }
 
 void TaskQueueManager::MaybeScheduleDelayedWork(
     const tracked_objects::Location& from_here,
     TimeDomain* requesting_time_domain,
     base::TimeTicks now,
     base::TimeTicks run_time) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
-  // Make sure we don't cancel another TimeDomain's wakeup.
+  // Make sure we don't cancel another TimeDomain's wake_up.
   DCHECK(!next_delayed_do_work_ ||
          next_delayed_do_work_.time_domain() == requesting_time_domain);
   {
     base::AutoLock lock(any_thread_lock_);
 
     // Unless we're nested, don't post a delayed DoWork if there's an immediate
     // DoWork in flight or we're inside a DoWork. We can rely on DoWork posting
     // a delayed continuation as needed.
     if (!any_thread().is_nested &&
         (any_thread().immediate_do_work_posted_count > 0 ||
@@ skipping 65 matching lines @@
         any_thread().is_nested = is_nested;
       }
       DCHECK_EQ(any_thread().is_nested, delegate_->IsNested());
       std::swap(queues_to_reload, any_thread().has_incoming_immediate_work);
     }
 
     // It's important we call ReloadEmptyWorkQueues out side of the lock to
     // avoid a lock order inversion.
     ReloadEmptyWorkQueues(queues_to_reload);
 
-    WakeupReadyDelayedQueues(&lazy_now);
+    WakeUpReadyDelayedQueues(&lazy_now);
 
     internal::WorkQueue* work_queue = nullptr;
     if (!SelectWorkQueueToService(&work_queue))
       break;
 
     // NB this may unregister |work_queue|.
     base::TimeTicks time_after_task;
     switch (ProcessTaskFromWorkQueue(work_queue, is_nested, lazy_now,
                                      &time_after_task)) {
       case ProcessTaskResult::DEFERRED:
@@ skipping 97 matching lines @@
     if (pair.first->CouldTaskRun(pair.second))
       return NextTaskDelay();
   }
 
   // If the selector has non-empty queues we trivially know there is immediate
   // work to be done.
   if (!selector_.EnabledWorkQueuesEmpty())
     return NextTaskDelay();
 
   // Otherwise we need to find the shortest delay, if any.  NB we don't need to
-  // call WakeupReadyDelayedQueues because it's assumed DelayTillNextTask will
+  // call WakeUpReadyDelayedQueues because it's assumed DelayTillNextTask will
   // return base::TimeDelta>() if the delayed task is due to run now.
   base::Optional<NextTaskDelay> delay_till_next_task;
   for (TimeDomain* time_domain : time_domains_) {
     base::Optional<base::TimeDelta> delay =
         time_domain->DelayTillNextTask(lazy_now);
     if (!delay)
       continue;
 
     NextTaskDelay task_delay = (delay.value() == base::TimeDelta())
                                    ? NextTaskDelay()
@@ skipping 253 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