scheduler: Move the Blink scheduler into Blink

third_party/WebKit/Source/platform/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 "components/scheduler/renderer/renderer_scheduler_impl.h"
+#include "platform/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/output/begin_frame_args.h"
-#include "components/scheduler/base/task_queue_impl.h"
-#include "components/scheduler/base/task_queue_selector.h"
-#include "components/scheduler/base/virtual_time_domain.h"
-#include "components/scheduler/child/scheduler_tqm_delegate.h"
-#include "components/scheduler/renderer/auto_advancing_virtual_time_domain.h"
-#include "components/scheduler/renderer/web_view_scheduler_impl.h"
-#include "components/scheduler/renderer/webthread_impl_for_renderer_scheduler.h"
+#include "platform/scheduler/base/task_queue_impl.h"
+#include "platform/scheduler/base/task_queue_selector.h"
+#include "platform/scheduler/base/virtual_time_domain.h"
+#include "platform/scheduler/child/scheduler_tqm_delegate.h"
+#include "platform/scheduler/renderer/auto_advancing_virtual_time_domain.h"
+#include "platform/scheduler/renderer/web_view_scheduler_impl.h"
+#include "platform/scheduler/renderer/webthread_impl_for_renderer_scheduler.h"
 
+namespace blink {
 namespace scheduler {
 namespace {
 // The run time of loading tasks is strongly bimodal.  The vast majority are
 // very cheap, but there are usually a handful of very expensive tasks (e.g ~1
 // second on a mobile device) so we take a very pessimistic view when estimating
 // the cost of loading tasks.
 const int kLoadingTaskEstimationSampleCount = 1000;
 const double kLoadingTaskEstimationPercentile = 99;
 const int kTimerTaskEstimationSampleCount = 1000;
 const double kTimerTaskEstimationPercentile = 99;
@@ skipping 624 matching lines @@
 
 base::TimeTicks RendererSchedulerImpl::CurrentIdleTaskDeadlineForTesting()
     const {
   return idle_helper_.CurrentIdleTaskDeadline();
 }
 
 void RendererSchedulerImpl::RunIdleTasksForTesting(
     const base::Closure& callback) {
   MainThreadOnly().in_idle_period_for_testing = true;
   IdleTaskRunner()->PostIdleTask(
-      FROM_HERE,
-      base::Bind(&RendererSchedulerImpl::EndIdlePeriodForTesting,
-                 weak_factory_.GetWeakPtr(), callback));
+      FROM_HERE, base::Bind(&RendererSchedulerImpl::EndIdlePeriodForTesting,
+                            weak_factory_.GetWeakPtr(), callback));
   idle_helper_.EnableLongIdlePeriod();
 }
 
 void RendererSchedulerImpl::MaybeUpdatePolicy() {
   helper_.CheckOnValidThread();
   if (policy_may_need_update_.IsSet()) {
     UpdatePolicy();
   }
 }
 
@@ skipping 417 matching lines @@
 IdleTimeEstimator* RendererSchedulerImpl::GetIdleTimeEstimatorForTesting() {
   return &MainThreadOnly().idle_time_estimator;
 }
 
 void RendererSchedulerImpl::SuspendTimerQueue() {
   MainThreadOnly().timer_queue_suspend_count++;
   ForceUpdatePolicy();
 #ifndef NDEBUG
   DCHECK(!default_timer_task_runner_->IsQueueEnabled());
   for (const auto& runner : timer_task_runners_) {
-     DCHECK(!runner->IsQueueEnabled());
+    DCHECK(!runner->IsQueueEnabled());
   }
 #endif
 }
 
 void RendererSchedulerImpl::ResumeTimerQueue() {
   MainThreadOnly().timer_queue_suspend_count--;
   DCHECK_GE(MainThreadOnly().timer_queue_suspend_count, 0);
   ForceUpdatePolicy();
 }
 
@@ skipping 130 matching lines @@
 
 void RendererSchedulerImpl::OnIdlePeriodEnded() {
   base::AutoLock lock(any_thread_lock_);
   AnyThread().last_idle_period_end_time =
       helper_.scheduler_tqm_delegate()->NowTicks();
   AnyThread().in_idle_period = false;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 void RendererSchedulerImpl::AddPendingNavigation(
-      blink::WebScheduler::NavigatingFrameType type) {
+    WebScheduler::NavigatingFrameType type) {
   helper_.CheckOnValidThread();
   if (type == blink::WebScheduler::NavigatingFrameType::kMainFrame) {
     MainThreadOnly().navigation_task_expected_count++;
     UpdatePolicy();
   }
 }
 
 void RendererSchedulerImpl::RemovePendingNavigation(
-      blink::WebScheduler::NavigatingFrameType type) {
+    WebScheduler::NavigatingFrameType type) {
   helper_.CheckOnValidThread();
   DCHECK_GT(MainThreadOnly().navigation_task_expected_count, 0);
   if (type == blink::WebScheduler::NavigatingFrameType::kMainFrame &&
       MainThreadOnly().navigation_task_expected_count > 0) {
     MainThreadOnly().navigation_task_expected_count--;
     UpdatePolicy();
   }
 }
 
 void RendererSchedulerImpl::OnNavigationStarted() {
@@ skipping 85 matching lines @@
   MainThreadOnly().web_view_schedulers.insert(web_view_scheduler);
 }
 
 void RendererSchedulerImpl::RemoveWebViewScheduler(
     WebViewSchedulerImpl* web_view_scheduler) {
   DCHECK(MainThreadOnly().web_view_schedulers.find(web_view_scheduler) !=
          MainThreadOnly().web_view_schedulers.end());
   MainThreadOnly().web_view_schedulers.erase(web_view_scheduler);
 }
 
-void RendererSchedulerImpl::BroadcastConsoleWarning(
-    const std::string& message) {
+void RendererSchedulerImpl::BroadcastIntervention(const std::string& message) {
   helper_.CheckOnValidThread();
   for (auto* web_view_scheduler : MainThreadOnly().web_view_schedulers)
-    web_view_scheduler->AddConsoleWarning(message);
+    web_view_scheduler->ReportIntervention(message);
 }
 
 void RendererSchedulerImpl::OnTriedToExecuteBlockedTask(
     const TaskQueue& queue,
     const base::PendingTask& task) {
   if (!MainThreadOnly().expensive_task_blocking_allowed ||
       MainThreadOnly().current_use_case == UseCase::TOUCHSTART ||
       MainThreadOnly().longest_jank_free_task_duration <
           base::TimeDelta::FromMilliseconds(kRailsResponseTimeMillis) ||
       MainThreadOnly().timer_queue_suspend_count ||
@@ skipping 13 matching lines @@
   }
 
   if (!MainThreadOnly().have_reported_blocking_intervention_since_navigation) {
     {
       base::AutoLock lock(any_thread_lock_);
       if (!AnyThread().have_seen_touchstart)
         return;
     }
     MainThreadOnly().have_reported_blocking_intervention_since_navigation =
         true;
-    BroadcastConsoleWarning(
+    BroadcastIntervention(
         "Blink deferred a task in order to make scrolling smoother. "
         "Your timer and network tasks should take less than 50ms to run "
         "to avoid this. Please see "
         "https://developers.google.com/web/tools/chrome-devtools/profile/evaluate-performance/rail"
         " and https://crbug.com/574343#c40 for more information.");
   }
 }
 
 void RendererSchedulerImpl::ReportTaskTime(base::TimeTicks start_time,
                                            base::TimeTicks end_time) {
   MainThreadOnly().queueing_time_estimator.OnToplevelTaskCompleted(start_time,
                                                                    end_time);
-  MainThreadOnly().long_task_tracker.RecordLongTask(
-      start_time, end_time - start_time);
+  MainThreadOnly().long_task_tracker.RecordLongTask(start_time,
+                                                    end_time - start_time);
 }
 
 LongTaskTracker::LongTaskTiming RendererSchedulerImpl::GetLongTaskTiming() {
   return MainThreadOnly().long_task_tracker.GetLongTaskTiming();
 }
 
 void RendererSchedulerImpl::OnQueueingTimeForWindowEstimated(
     base::TimeDelta queueing_time) {
   UMA_HISTOGRAM_TIMES("RendererScheduler.ExpectedTaskQueueingDuration",
                       queueing_time);
@@ skipping 58 matching lines @@
       return "idle";
     case v8::PERFORMANCE_LOAD:
       return "load";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
+}  // namespace blink