Move and rename TaskTimeTracker to public interface exposed to WebThread, use in WebPerf Agent.

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 "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"
@@ skipping 18 matching lines @@
 // the cost of loading tasks.
 const int kLoadingTaskEstimationSampleCount = 1000;
 const double kLoadingTaskEstimationPercentile = 99;
 const int kTimerTaskEstimationSampleCount = 1000;
 const double kTimerTaskEstimationPercentile = 99;
 const int kShortIdlePeriodDurationSampleCount = 10;
 const double kShortIdlePeriodDurationPercentile = 50;
 // Amount of idle time left in a frame (as a ratio of the vsync interval) above
 // which main thread compositing can be considered fast.
 const double kFastCompositingIdleTimeThreshold = .2;
+
+base::TimeTicks MonotonicTimeInSecondsToTimeTicks(
+    double monotonicTimeInSeconds) {
+  return base::TimeTicks::FromInternalValue(monotonicTimeInSeconds *
+                                            base::Time::kMicrosecondsPerSecond);
+}
+
 }  // namespace
 
 RendererSchedulerImpl::RendererSchedulerImpl(
     scoped_refptr<SchedulerTqmDelegate> main_task_runner)
     : helper_(main_task_runner,
               "renderer.scheduler",
               TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
               TRACE_DISABLED_BY_DEFAULT("renderer.scheduler.debug")),
       idle_helper_(&helper_,
                    this,
@@ skipping 25 matching lines @@
                  weak_factory_.GetWeakPtr()));
 
   default_loading_task_runner_ = NewLoadingTaskRunner("default_loading_tq");
   default_timer_task_runner_ = NewTimerTaskRunner("default_timer_tq");
 
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
 
   helper_.SetObserver(this);
-  helper_.SetTaskTimeTracker(this);
+  helper_.AddTaskTimeTracker(this);
 }
 
 RendererSchedulerImpl::~RendererSchedulerImpl() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
 
   for (const scoped_refptr<TaskQueue>& loading_queue : loading_task_runners_) {
     loading_queue->RemoveTaskObserver(
         &MainThreadOnly().loading_task_cost_estimator);
   }
   for (const scoped_refptr<TaskQueue>& timer_queue : timer_task_runners_) {
     timer_queue->RemoveTaskObserver(
         &MainThreadOnly().timer_task_cost_estimator);
   }
 
   if (virtual_time_domain_)
     UnregisterTimeDomain(virtual_time_domain_.get());
 
+  helper_.RemoveTaskTimeTracker(this);
+
   // Ensure the renderer scheduler was shut down explicitly, because otherwise
   // we could end up having stale pointers to the Blink heap which has been
   // terminated by this point.
   DCHECK(MainThreadOnly().was_shutdown);
 }
 
 RendererSchedulerImpl::MainThreadOnly::MainThreadOnly(
     RendererSchedulerImpl* renderer_scheduler_impl,
     const scoped_refptr<TaskQueue>& compositor_task_runner,
     base::TickClock* time_source)
@@ skipping 1294 matching lines @@
         true;
     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);
-  UMA_HISTOGRAM_CUSTOM_COUNTS("RendererScheduler.TaskTime",
-                              (end_time - start_time).InMicroseconds(), 1,
-                              1000000, 50);
+void RendererSchedulerImpl::ReportTaskTime(double start_time, double end_time) {
+  base::TimeTicks start_time_ticks =
+      MonotonicTimeInSecondsToTimeTicks(start_time);
+  base::TimeTicks end_time_ticks = MonotonicTimeInSecondsToTimeTicks(end_time);
+
+  MainThreadOnly().queueing_time_estimator.OnToplevelTaskCompleted(
+      start_time_ticks, end_time_ticks);
+  UMA_HISTOGRAM_CUSTOM_COUNTS(
+      "RendererScheduler.TaskTime",
+      (end_time_ticks - start_time_ticks).InMicroseconds(), 1, 1000000, 50);
 }
 
-LongTaskTracker::LongTaskTiming RendererSchedulerImpl::GetLongTaskTiming() {
-  return MainThreadOnly().long_task_tracker.GetLongTaskTiming();
+void RendererSchedulerImpl::AddTaskTimeTracker(
+    TaskTimeTracker* task_time_tracker) {
+  helper_.AddTaskTimeTracker(task_time_tracker);
+}
+
+void RendererSchedulerImpl::RemoveTaskTimeTracker(
+    TaskTimeTracker* task_time_tracker) {
+  helper_.RemoveTaskTimeTracker(task_time_tracker);
 }
 
 void RendererSchedulerImpl::OnQueueingTimeForWindowEstimated(
     base::TimeDelta queueing_time) {
   UMA_HISTOGRAM_TIMES("RendererScheduler.ExpectedTaskQueueingDuration",
                       queueing_time);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "estimated_queueing_time_for_window",
                  queueing_time.InMillisecondsF());
 }
@@ skipping 55 matching lines @@
     case v8::PERFORMANCE_LOAD:
       return "load";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink