Revert of Adds TimeDomains to the TaskQueueManager

components/scheduler/child/idle_helper.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/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.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/child/scheduler_helper.h"
 #include "components/scheduler/child/scheduler_tqm_delegate.h"
 
 namespace scheduler {
 
 IdleHelper::IdleHelper(
     SchedulerHelper* helper,
     Delegate* delegate,
@@ skipping 49 matching lines @@
 IdleHelper::IdlePeriodState IdleHelper::ComputeNewLongIdlePeriodState(
     const base::TimeTicks now,
     base::TimeDelta* next_long_idle_period_delay_out) {
   helper_->CheckOnValidThread();
 
   if (!delegate_->CanEnterLongIdlePeriod(now,
                                          next_long_idle_period_delay_out)) {
     return IdlePeriodState::NOT_IN_IDLE_PERIOD;
   }
 
-  base::TimeTicks next_pending_delayed_task;
+  base::TimeTicks next_pending_delayed_task =
+      helper_->NextPendingDelayedTaskRunTime();
   base::TimeDelta max_long_idle_period_duration =
       base::TimeDelta::FromMilliseconds(kMaximumIdlePeriodMillis);
   base::TimeDelta long_idle_period_duration;
-  if (helper_->real_time_domain()->NextScheduledRunTime(
-          &next_pending_delayed_task)) {
+  if (next_pending_delayed_task.is_null()) {
+    long_idle_period_duration = max_long_idle_period_duration;
+  } else {
     // Limit the idle period duration to be before the next pending task.
     long_idle_period_duration = std::min(next_pending_delayed_task - now,
                                          max_long_idle_period_duration);
-  } else {
-    long_idle_period_duration = max_long_idle_period_duration;
   }
 
   if (long_idle_period_duration >=
       base::TimeDelta::FromMilliseconds(kMinimumIdlePeriodDurationMillis)) {
     *next_long_idle_period_delay_out = long_idle_period_duration;
     if (idle_queue_->IsQueueEmpty()) {
       return IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED;
     } else if (long_idle_period_duration == max_long_idle_period_duration) {
       return IdlePeriodState::IN_LONG_IDLE_PERIOD_WITH_MAX_DEADLINE;
     } else {
@@ skipping 374 matching lines @@
       return "in_long_idle_period_with_max_deadline";
     case IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED:
       return "in_long_idle_period_paused";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler