scheduler: Move the Blink scheduler into Blink

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 "components/scheduler/base/task_queue_manager.h"
+#include "platform/scheduler/base/task_queue_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
-#include "components/scheduler/base/real_time_domain.h"
-#include "components/scheduler/base/task_queue_impl.h"
-#include "components/scheduler/base/task_queue_manager_delegate.h"
-#include "components/scheduler/base/task_queue_selector.h"
-#include "components/scheduler/base/task_time_tracker.h"
-#include "components/scheduler/base/work_queue.h"
-#include "components/scheduler/base/work_queue_sets.h"
+#include "platform/scheduler/base/real_time_domain.h"
+#include "platform/scheduler/base/task_queue_impl.h"
+#include "platform/scheduler/base/task_queue_manager_delegate.h"
+#include "platform/scheduler/base/task_queue_selector.h"
+#include "platform/scheduler/base/task_time_tracker.h"
+#include "platform/scheduler/base/work_queue.h"
+#include "platform/scheduler/base/work_queue_sets.h"
 
+namespace blink {
 namespace scheduler {
 
 namespace {
 const size_t kRecordRecordTaskDelayHistogramsEveryNTasks = 10;
 
 void RecordDelayedTaskLateness(base::TimeDelta lateness) {
   UMA_HISTOGRAM_TIMES("RendererScheduler.TaskQueueManager.DelayedTaskLateness",
                       lateness);
 }
 
@@ skipping 54 matching lines @@
   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(
     const TaskQueue::Spec& spec) {
-  TRACE_EVENT1(tracing_category_,
-               "TaskQueueManager::NewTaskQueue", "queue_name", spec.name);
+  TRACE_EVENT1(tracing_category_, "TaskQueueManager::NewTaskQueue",
+               "queue_name", spec.name);
   DCHECK(main_thread_checker_.CalledOnValidThread());
   TimeDomain* time_domain =
       spec.time_domain ? spec.time_domain : real_time_domain_.get();
   DCHECK(time_domains_.find(time_domain) != time_domains_.end());
   scoped_refptr<internal::TaskQueueImpl> queue(
       make_scoped_refptr(new internal::TaskQueueImpl(
           this, time_domain, spec, disabled_by_default_tracing_category_,
           disabled_by_default_verbose_tracing_category_)));
   queues_.insert(queue);
   selector_.AddQueue(queue.get());
   return queue;
 }
 
 void TaskQueueManager::SetObserver(Observer* observer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   observer_ = observer;
 }
 
 void TaskQueueManager::UnregisterTaskQueue(
     scoped_refptr<internal::TaskQueueImpl> task_queue) {
-  TRACE_EVENT1(tracing_category_,
-               "TaskQueueManager::UnregisterTaskQueue", "queue_name",
-               task_queue->GetName());
+  TRACE_EVENT1(tracing_category_, "TaskQueueManager::UnregisterTaskQueue",
+               "queue_name", task_queue->GetName());
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (observer_)
     observer_->OnUnregisterTaskQueue(task_queue);
 
   // Add |task_queue| to |queues_to_delete_| so we can prevent it from being
   // freed while any of our structures hold hold a raw pointer to it.
   queues_to_delete_.insert(task_queue);
   queues_.erase(task_queue);
   selector_.RemoveQueue(task_queue.get());
 }
@@ skipping 98 matching lines @@
     }
 
     lazy_now = real_time_domain()->CreateLazyNow();
     if (!delegate_->IsNested() && task_time_tracker_) {
       // Only report top level task durations.
       base::TimeTicks task_end_time = lazy_now.Now();
       task_time_tracker_->ReportTaskTime(task_start_time, task_end_time);
       task_start_time = task_end_time;
     }
 
-    work_queue = nullptr; // The queue may have been unregistered.
+    work_queue = nullptr;  // The queue may have been unregistered.
 
     UpdateWorkQueues(should_trigger_wakeup, &previous_task, lazy_now);
 
     // Only run a single task per batch in nested run loops so that we can
     // properly exit the nested loop when someone calls RunLoop::Quit().
     if (delegate_->IsNested())
       break;
   }
 
   // TODO(alexclarke): Consider refactoring the above loop to terminate only
@@ skipping 48 matching lines @@
 
   MaybeRecordTaskDelayHistograms(pending_task, queue);
 
   TRACE_TASK_EXECUTION("TaskQueueManager::ProcessTaskFromWorkQueue",
                        pending_task);
   if (queue->GetShouldNotifyObservers()) {
     FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver, task_observers_,
                       WillProcessTask(pending_task));
     queue->NotifyWillProcessTask(pending_task);
   }
-  TRACE_EVENT1(tracing_category_,
-               "TaskQueueManager::RunTask", "queue", queue->GetName());
+  TRACE_EVENT1(tracing_category_, "TaskQueueManager::RunTask", "queue",
+               queue->GetName());
   // NOTE when TaskQueues get unregistered a reference ends up getting retained
   // by |queues_to_delete_| which is cleared at the top of |DoWork|. This means
   // we are OK to use raw pointers here.
   internal::TaskQueueImpl* prev_executing_task_queue =
       currently_executing_task_queue_;
   currently_executing_task_queue_ = queue;
   task_annotator_.RunTask("TaskQueueManager::PostTask", pending_task);
 
   // Detect if the TaskQueueManager just got deleted.  If this happens we must
   // not access any member variables after this point.
@@ skipping 114 matching lines @@
     internal::WorkQueue* work_queue) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(!work_queue->Empty());
   if (observer_) {
     observer_->OnTriedToExecuteBlockedTask(*work_queue->task_queue(),
                                            *work_queue->GetFrontTask());
   }
 }
 
 }  // namespace scheduler
+}  // namespace blink