(reland) Adds TimeDomains to the TaskQueueManager

components/scheduler/child/idle_helper_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/child/idle_helper.h"
 
 #include "base/callback.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "cc/test/ordered_simple_task_runner.h"
+#include "components/scheduler/base/real_time_domain.h"
 #include "components/scheduler/base/task_queue.h"
 #include "components/scheduler/base/task_queue_manager.h"
 #include "components/scheduler/base/test_time_source.h"
 #include "components/scheduler/child/scheduler_helper.h"
 #include "components/scheduler/child/scheduler_tqm_delegate_for_test.h"
 #include "components/scheduler/child/scheduler_tqm_delegate_impl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
@@ skipping 817 matching lines @@
 
 TEST_F(IdleHelperTest, TestLongIdlePeriodPaused) {
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
   std::vector<base::TimeTicks> actual_deadlines;
   int run_count = 0;
 
   // If there are no idle tasks posted we should start in the paused state.
   idle_helper_->EnableLongIdlePeriod();
   CheckIdlePeriodStateIs("in_long_idle_period_paused");
   // There shouldn't be any delayed tasks posted by the idle helper when paused.
-  EXPECT_EQ(base::TimeTicks(),
-            scheduler_helper_->NextPendingDelayedTaskRunTime());
+  base::TimeTicks next_pending_delayed_task;
+  EXPECT_FALSE(scheduler_helper_->real_time_domain()->NextScheduledRunTime(
+      &next_pending_delayed_task));
 
   // Posting a task should transition us to the an active state.
   max_idle_task_reposts = 2;
   base::TimeTicks clock_before(clock_->NowTicks());
   base::TimeDelta idle_task_runtime(base::TimeDelta::FromMilliseconds(10));
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&RepostingUpdateClockIdleTestTask,
                             idle_task_runner_, &run_count, clock_.get(),
                             idle_task_runtime, &actual_deadlines));
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
   EXPECT_THAT(
       actual_deadlines,
       testing::ElementsAre(
           clock_before + maximum_idle_period_duration(),
           clock_before + idle_task_runtime + maximum_idle_period_duration()));
 
   // Once all task have been run we should go back to the paused state.
   CheckIdlePeriodStateIs("in_long_idle_period_paused");
-  EXPECT_EQ(base::TimeTicks(),
-            scheduler_helper_->NextPendingDelayedTaskRunTime());
+  EXPECT_FALSE(scheduler_helper_->real_time_domain()->NextScheduledRunTime(
+      &next_pending_delayed_task));
 
   idle_helper_->EndIdlePeriod();
   CheckIdlePeriodStateIs("not_in_idle_period");
 }
 
 TEST_F(IdleHelperTest, TestLongIdlePeriodWhenShutdown) {
   base::TimeTicks deadline_in_task;
   int run_count = 0;
 
   idle_task_runner_->PostIdleTask(
@@ skipping 256 matching lines @@
   EXPECT_EQ(0, run_count);
 
   default_task_runner_->PostDelayedTask(FROM_HERE, base::Bind(&NullTask),
                                         more_than_min_deadline_duration);
   idle_helper_->EnableLongIdlePeriod();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 }
 
 }  // namespace scheduler