Report expected task queueing time via UMA

components/scheduler/renderer/idle_time_estimator_unittest.cc

 // Copyright 2015 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/idle_time_estimator.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "components/scheduler/base/task_queue_manager.h"
+#include "components/scheduler/base/task_time_tracker.h"
 #include "components/scheduler/base/test_time_source.h"
 #include "components/scheduler/child/scheduler_tqm_delegate_for_test.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace scheduler {
 
 class IdleTimeEstimatorForTest : public IdleTimeEstimator {
  public:
   IdleTimeEstimatorForTest(
       const scoped_refptr<TaskQueue>& compositor_task_runner,
       TestTimeSource* test_time_source,
       int sample_count,
       double estimation_percentile)
       : IdleTimeEstimator(compositor_task_runner,
                           test_time_source,
                           sample_count,
                           estimation_percentile) {}
 };
 
 class IdleTimeEstimatorTest : public testing::Test {
  public:
   IdleTimeEstimatorTest()
-      : frame_length_(base::TimeDelta::FromMilliseconds(16)) {}
+      : frame_length_(base::TimeDelta::FromMilliseconds(16)),
+        task_time_tracker_(nullptr) {}
 
   ~IdleTimeEstimatorTest() override {}
 
   void SetUp() override {
     clock_.reset(new base::SimpleTestTickClock());
     clock_->Advance(base::TimeDelta::FromMicroseconds(5000));
     test_time_source_.reset(new TestTimeSource(clock_.get()));
     mock_task_runner_ = make_scoped_refptr(
         new cc::OrderedSimpleTaskRunner(clock_.get(), false));
     main_task_runner_ = SchedulerTqmDelegateForTest::Create(
         mock_task_runner_, base::WrapUnique(new TestTimeSource(clock_.get())));
-    manager_ = base::WrapUnique(
-        new TaskQueueManager(main_task_runner_, "test.scheduler",
-                             "test.scheduler", "test.scheduler.debug"));
+    manager_ = base::WrapUnique(new TaskQueueManager(
+        main_task_runner_, "test.scheduler", "test.scheduler",
+        "test.scheduler.debug"));
     compositor_task_runner_ =
         manager_->NewTaskQueue(TaskQueue::Spec("compositor_tq"));
     estimator_.reset(new IdleTimeEstimatorForTest(
         compositor_task_runner_, test_time_source_.get(), 10, 50));
   }
 
   void SimulateFrameWithOneCompositorTask(int compositor_time) {
     base::TimeDelta non_idle_time =
         base::TimeDelta::FromMilliseconds(compositor_time);
     base::PendingTask task(FROM_HERE, base::Closure());
@@ skipping 26 matching lines @@
   }
 
   std::unique_ptr<base::SimpleTestTickClock> clock_;
   std::unique_ptr<TestTimeSource> test_time_source_;
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
   scoped_refptr<SchedulerTqmDelegate> main_task_runner_;
   std::unique_ptr<TaskQueueManager> manager_;
   scoped_refptr<TaskQueue> compositor_task_runner_;
   std::unique_ptr<IdleTimeEstimatorForTest> estimator_;
   const base::TimeDelta frame_length_;
+  TaskTimeTracker task_time_tracker_;
 };
 
 TEST_F(IdleTimeEstimatorTest, InitialTimeEstimateWithNoData) {
   EXPECT_EQ(frame_length_, estimator_->GetExpectedIdleDuration(frame_length_));
 }
 
 TEST_F(IdleTimeEstimatorTest, BasicEstimation_SteadyState) {
   SimulateFrameWithOneCompositorTask(5);
   SimulateFrameWithOneCompositorTask(5);
 
@@ skipping 53 matching lines @@
   SimulateFrameWithTwoCompositorTasks(4, 4);
   estimator_->DidCommitFrameToCompositor();
   estimator_->DidProcessTask(task);
 
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(11),
             estimator_->GetExpectedIdleDuration(frame_length_));
 }
 
 
 }  // namespace scheduler