scheduler: Add a base directory

components/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/child/task_queue_manager.h"
+#include "components/scheduler/base/task_queue_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
 #include "base/time/default_tick_clock.h"
-#include "components/scheduler/child/lazy_now.h"
-#include "components/scheduler/child/nestable_single_thread_task_runner.h"
-#include "components/scheduler/child/task_queue_impl.h"
-#include "components/scheduler/child/task_queue_selector.h"
-#include "components/scheduler/child/task_queue_sets.h"
+#include "components/scheduler/base/lazy_now.h"
+#include "components/scheduler/base/nestable_single_thread_task_runner.h"
+#include "components/scheduler/base/task_queue_impl.h"
+#include "components/scheduler/base/task_queue_selector.h"
+#include "components/scheduler/base/task_queue_sets.h"
 
 namespace {
 const int64_t kMaxTimeTicks = std::numeric_limits<int64>::max();
 }
 
 namespace scheduler {
 
 TaskQueueManager::TaskQueueManager(
     scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner,
     const char* disabled_by_default_tracing_category,
@@ skipping 48 matching lines @@
 }
 
 void TaskQueueManager::SetObserver(Observer* observer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   observer_ = observer;
 }
 
 void TaskQueueManager::UnregisterTaskQueue(
     scoped_refptr<internal::TaskQueueImpl> task_queue) {
   TRACE_EVENT1(disabled_by_default_tracing_category_,
-              "TaskQueueManager::UnregisterTaskQueue",
-              "queue_name", task_queue->GetName());
+               "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 80 matching lines @@
     }
   }
 
   auto iter = updatable_queue_set_.begin();
   while (iter != updatable_queue_set_.end()) {
     internal::TaskQueueImpl* queue = *iter++;
     // NOTE Update work queue may erase itself from |updatable_queue_set_|.
     // This is fine, erasing an element won't invalidate any interator, as long
     // as the iterator isn't the element being delated.
     if (queue->work_queue().empty())
-        queue->UpdateWorkQueue(&lazy_now, should_trigger_wakeup, previous_task);
+      queue->UpdateWorkQueue(&lazy_now, should_trigger_wakeup, previous_task);
   }
 }
 
 void TaskQueueManager::ScheduleDelayedWorkTask(
     scoped_refptr<internal::TaskQueueImpl> queue,
     base::TimeTicks delayed_run_time) {
   internal::LazyNow lazy_now(this);
   ScheduleDelayedWork(queue.get(), delayed_run_time, &lazy_now);
 }
 
@@ skipping 257 matching lines @@
 }
 
 void TaskQueueManager::OnTaskQueueEnabled(internal::TaskQueueImpl* queue) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   // Only schedule DoWork if there's something to do.
   if (!queue->work_queue().empty())
     MaybePostDoWorkOnMainRunner();
 }
 
 }  // namespace scheduler