Move blink scheduler implementation into a component

components/scheduler/renderer/renderer_scheduler_impl.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 "content/renderer/scheduler/renderer_scheduler_impl.h"
+#include "components/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/output/begin_frame_args.h"
-#include "content/child/scheduler/nestable_single_thread_task_runner.h"
-#include "content/child/scheduler/prioritizing_task_queue_selector.h"
+#include "components/scheduler/child/nestable_single_thread_task_runner.h"
+#include "components/scheduler/child/prioritizing_task_queue_selector.h"
 #include "ui/gfx/frame_time.h"
 
-namespace content {
+namespace scheduler {
 
 RendererSchedulerImpl::RendererSchedulerImpl(
     scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner)
     : helper_(main_task_runner,
               this,
               "renderer.scheduler",
               TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
               "RendererSchedulerIdlePeriod",
               TASK_QUEUE_COUNT,
               base::TimeDelta()),
@@ skipping 11 matching lines @@
       last_input_type_(blink::WebInputEvent::Undefined),
       input_stream_state_(InputStreamState::INACTIVE),
       policy_may_need_update_(&incoming_signals_lock_),
       timer_queue_suspend_count_(0),
       weak_factory_(this) {
   update_policy_closure_ = base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                                       weak_factory_.GetWeakPtr());
   end_renderer_hidden_idle_period_closure_.Reset(base::Bind(
       &RendererSchedulerImpl::EndIdlePeriod, weak_factory_.GetWeakPtr()));
 
-  for (size_t i = SchedulerHelper::TASK_QUEUE_COUNT;
-       i < TASK_QUEUE_COUNT;
+  for (size_t i = SchedulerHelper::TASK_QUEUE_COUNT; i < TASK_QUEUE_COUNT;
        i++) {
     helper_.SetQueueName(i, TaskQueueIdToString(static_cast<QueueId>(i)));
   }
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
 }
 
 RendererSchedulerImpl::~RendererSchedulerImpl() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
@@ skipping 66 matching lines @@
                "RendererSchedulerImpl::DidCommitFrameToCompositor");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return;
 
   base::TimeTicks now(helper_.Now());
   if (now < estimated_next_frame_begin_) {
     // TODO(rmcilroy): Consider reducing the idle period based on the runtime of
     // the next pending delayed tasks (as currently done in for long idle times)
     helper_.StartIdlePeriod(
-        SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD,
-        now,
-        estimated_next_frame_begin_,
-        true);
+        SchedulerHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, now,
+        estimated_next_frame_begin_, true);
   }
 }
 
 void RendererSchedulerImpl::BeginFrameNotExpectedSoon() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::BeginFrameNotExpectedSoon");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return;
 
@@ skipping 11 matching lines @@
   if (helper_.IsShutdown() || renderer_hidden_)
     return;
 
   helper_.EnableLongIdlePeriod();
 
   // Ensure that we stop running idle tasks after a few seconds of being hidden.
   end_renderer_hidden_idle_period_closure_.Cancel();
   base::TimeDelta end_idle_when_hidden_delay =
       base::TimeDelta::FromMilliseconds(kEndIdleWhenHiddenDelayMillis);
   control_task_runner_->PostDelayedTask(
-      FROM_HERE,
-      end_renderer_hidden_idle_period_closure_.callback(),
+      FROM_HERE, end_renderer_hidden_idle_period_closure_.callback(),
       end_idle_when_hidden_delay);
   renderer_hidden_ = true;
 
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this, AsValueLocked(helper_.Now()));
 }
 
 void RendererSchedulerImpl::OnRendererVisible() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
@@ skipping 113 matching lines @@
 
     case Policy::TOUCHSTART_PRIORITY:
       return true;
 
     default:
       NOTREACHED();
       return false;
   }
 }
 
-base::TimeTicks
-RendererSchedulerImpl::CurrentIdleTaskDeadlineForTesting() const {
+base::TimeTicks RendererSchedulerImpl::CurrentIdleTaskDeadlineForTesting()
+    const {
   base::TimeTicks deadline;
   helper_.CurrentIdleTaskDeadlineCallback(&deadline);
   return deadline;
 }
 
 RendererSchedulerImpl::Policy RendererSchedulerImpl::SchedulerPolicy() const {
   helper_.CheckOnValidThread();
   return current_policy_;
 }
 
@@ skipping 164 matching lines @@
     *next_long_idle_period_delay_out = current_policy_expiration_time_ - now;
     return false;
   }
   return true;
 }
 
 SchedulerHelper* RendererSchedulerImpl::GetSchedulerHelperForTesting() {
   return &helper_;
 }
 
-void RendererSchedulerImpl::SetWorkBatchSizeForTesting(size_t work_batch_size) {
-  helper_.SetWorkBatchSizeForTesting(work_batch_size);
-}
-
 RendererSchedulerImpl::PollableNeedsUpdateFlag::PollableNeedsUpdateFlag(
     base::Lock* write_lock_)
     : flag_(false), write_lock_(write_lock_) {
 }
 
 RendererSchedulerImpl::PollableNeedsUpdateFlag::~PollableNeedsUpdateFlag() {
 }
 
 void RendererSchedulerImpl::PollableNeedsUpdateFlag::SetWhileLocked(
     bool value) {
   write_lock_->AssertAcquired();
   base::subtle::Release_Store(&flag_, value);
 }
 
 bool RendererSchedulerImpl::PollableNeedsUpdateFlag::IsSet() const {
   return base::subtle::Acquire_Load(&flag_) != 0;
 }
 
 void RendererSchedulerImpl::SuspendTimerQueue() {
   helper_.CheckOnValidThread();
   timer_queue_suspend_count_++;
   ForceUpdatePolicy();
-  DCHECK(!helper_.SchedulerTaskQueueSelector()->IsQueueEnabled(
-      TIMER_TASK_QUEUE));
+  DCHECK(
+      !helper_.SchedulerTaskQueueSelector()->IsQueueEnabled(TIMER_TASK_QUEUE));
 }
 
 void RendererSchedulerImpl::ResumeTimerQueue() {
   helper_.CheckOnValidThread();
   timer_queue_suspend_count_--;
   DCHECK_GE(timer_queue_suspend_count_, 0);
   ForceUpdatePolicy();
 }
 
 // static
@@ skipping 101 matching lines @@
       // With no observable effect, these meta events do not indicate a
       // meaningful touchstart response and should not impact task priority.
       return current_state;
 
     default:
       break;
   }
   return InputStreamState::ACTIVE;
 }
 
-}  // namespace content
+}  // namespace scheduler