cc: Remove scheduler power monitoring.

Power monitoring was added to the scheduler based on the incorrect
assumption that it would allow the system to use a lower timer
resolution on windows. This is not true because the timer resolution is
always high when on AC power while DelayBasedTimeSource is used for
vsync timing. On battery power the high resolution timer is disabled by
the power monitor irrespective of the presence of high resolution timer
tasks.

BUG=448939

Review URL: https://codereview.chromium.org/974083002

Cr-Commit-Position: refs/heads/master@{#319000}

cc/scheduler/scheduler.cc

@@ -79,7 +79,6 @@ Scheduler::Scheduler(
     const SchedulerSettings& scheduler_settings,
     int layer_tree_host_id,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-    base::PowerMonitor* power_monitor,
     scoped_ptr<BeginFrameSource> external_begin_frame_source,
     SchedulerFrameSourcesConstructor* frame_sources_constructor)
     : frame_source_(),
@@ -93,7 +92,6 @@ Scheduler::Scheduler(
       client_(client),
       layer_tree_host_id_(layer_tree_host_id),
       task_runner_(task_runner),
-      power_monitor_(power_monitor),
       state_machine_(scheduler_settings),
       inside_process_scheduled_actions_(false),
       inside_action_(SchedulerStateMachine::ACTION_NONE),
@@ -132,12 +130,9 @@ Scheduler::Scheduler(
   unthrottled_frame_source_ =
       frame_sources_constructor->ConstructUnthrottledFrameSource(this);
   frame_source_->AddSource(unthrottled_frame_source_);
-
-  SetupPowerMonitoring();
 }
 
 Scheduler::~Scheduler() {
-  TeardownPowerMonitoring();
   if (frame_source_->NeedsBeginFrames())
     frame_source_->SetNeedsBeginFrames(false);
 }
@@ -151,27 +146,6 @@ base::TimeTicks Scheduler::Now() const {
   return now;
 }
 
-void Scheduler::SetupPowerMonitoring() {
-  if (settings_.disable_hi_res_timer_tasks_on_battery) {
-    DCHECK(power_monitor_);
-    power_monitor_->AddObserver(this);
-    state_machine_.SetImplLatencyTakesPriorityOnBattery(
-        power_monitor_->IsOnBatteryPower());
-  }
-}
-
-void Scheduler::TeardownPowerMonitoring() {
-  if (settings_.disable_hi_res_timer_tasks_on_battery) {
-    DCHECK(power_monitor_);
-    power_monitor_->RemoveObserver(this);
-  }
-}
-
-void Scheduler::OnPowerStateChange(bool on_battery_power) {
-  DCHECK(settings_.disable_hi_res_timer_tasks_on_battery);
-  state_machine_.SetImplLatencyTakesPriorityOnBattery(on_battery_power);
-}
-
 void Scheduler::CommitVSyncParameters(base::TimeTicks timebase,
                                       base::TimeDelta interval) {
   // TODO(brianderson): We should not be receiving 0 intervals.

cc/scheduler/scheduler.h

@@ -11,8 +11,6 @@
 #include "base/basictypes.h"
 #include "base/cancelable_callback.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/power_monitor/power_monitor.h"
-#include "base/power_monitor/power_observer.h"
 #include "base/time/time.h"
 #include "cc/base/cc_export.h"
 #include "cc/output/begin_frame_args.h"
@@ -75,22 +73,19 @@ class CC_EXPORT SchedulerFrameSourcesConstructor {
   friend class Scheduler;
 };
 
-class CC_EXPORT Scheduler : public BeginFrameObserverMixIn,
-                            public base::PowerObserver {
+class CC_EXPORT Scheduler : public BeginFrameObserverMixIn {
  public:
   static scoped_ptr<Scheduler> Create(
       SchedulerClient* client,
       const SchedulerSettings& scheduler_settings,
       int layer_tree_host_id,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-      base::PowerMonitor* power_monitor,
       scoped_ptr<BeginFrameSource> external_begin_frame_source) {
     SchedulerFrameSourcesConstructor frame_sources_constructor;
     return make_scoped_ptr(new Scheduler(client,
                                          scheduler_settings,
                                          layer_tree_host_id,
                                          task_runner,
-                                         power_monitor,
                                          external_begin_frame_source.Pass(),
                                          &frame_sources_constructor));
   }
@@ -100,9 +95,6 @@ class CC_EXPORT Scheduler : public BeginFrameObserverMixIn,
   // BeginFrameObserverMixin
   bool OnBeginFrameMixInDelegate(const BeginFrameArgs& args) override;
 
-  // base::PowerObserver method.
-  void OnPowerStateChange(bool on_battery_power) override;
-
   const SchedulerSettings& settings() const { return settings_; }
 
   void CommitVSyncParameters(base::TimeTicks timebase,
@@ -179,7 +171,6 @@ class CC_EXPORT Scheduler : public BeginFrameObserverMixIn,
             const SchedulerSettings& scheduler_settings,
             int layer_tree_host_id,
             const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-            base::PowerMonitor* power_monitor,
             scoped_ptr<BeginFrameSource> external_begin_frame_source,
             SchedulerFrameSourcesConstructor* frame_sources_constructor);
 
@@ -205,8 +196,6 @@ class CC_EXPORT Scheduler : public BeginFrameObserverMixIn,
   int layer_tree_host_id_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
-  base::PowerMonitor* power_monitor_;
-
   base::TimeDelta estimated_parent_draw_time_;
 
   std::deque<BeginFrameArgs> begin_retro_frame_args_;
@@ -243,8 +232,6 @@ class CC_EXPORT Scheduler : public BeginFrameObserverMixIn,
   void OnBeginImplFrameDeadline();
   void PollForAnticipatedDrawTriggers();
   void PollToAdvanceCommitState();
-  void SetupPowerMonitoring();
-  void TeardownPowerMonitoring();
   void UpdateActiveFrameSource();
 
   base::TimeDelta EstimatedParentDrawTime() {

cc/scheduler/scheduler_state_machine.cc

@@ -47,7 +47,6 @@ SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
       skip_next_begin_main_frame_to_reduce_latency_(false),
       skip_begin_main_frame_to_reduce_latency_(false),
       continuous_painting_(false),
-      impl_latency_takes_priority_on_battery_(false),
       children_need_begin_frames_(false),
       defer_commits_(false) {
 }
@@ -236,8 +235,6 @@ void SchedulerStateMachine::AsValueInto(base::trace_event::TracedValue* state,
   state->SetBoolean("skip_next_begin_main_frame_to_reduce_latency",
                     skip_next_begin_main_frame_to_reduce_latency_);
   state->SetBoolean("continuous_painting", continuous_painting_);
-  state->SetBoolean("impl_latency_takes_priority_on_battery",
-                    impl_latency_takes_priority_on_battery_);
   state->SetBoolean("children_need_begin_frames", children_need_begin_frames_);
   state->SetBoolean("defer_commits", defer_commits_);
   state->EndDictionary();
@@ -903,11 +900,6 @@ bool SchedulerStateMachine::ShouldTriggerBeginImplFrameDeadlineImmediately()
   if (impl_latency_takes_priority_)
     return true;
 
-  // If we are on battery power and want to prioritize impl latency because
-  // we don't trust deadline tasks to execute at the right time.
-  if (impl_latency_takes_priority_on_battery_)
-    return true;
-
   return false;
 }
 

cc/scheduler/scheduler_state_machine.h

@@ -254,12 +254,6 @@ class CC_EXPORT SchedulerStateMachine {
 
   bool CouldSendBeginMainFrame() const;
 
-  void SetImplLatencyTakesPriorityOnBattery(
-      bool impl_latency_takes_priority_on_battery) {
-    impl_latency_takes_priority_on_battery_ =
-        impl_latency_takes_priority_on_battery;
-  }
-
   void SetDeferCommits(bool defer_commits);
 
   // TODO(zmo): This is temporary for debugging crbug.com/393331.
@@ -341,7 +335,6 @@ class CC_EXPORT SchedulerStateMachine {
   bool skip_next_begin_main_frame_to_reduce_latency_;
   bool skip_begin_main_frame_to_reduce_latency_;
   bool continuous_painting_;
-  bool impl_latency_takes_priority_on_battery_;
   bool children_need_begin_frames_;
   bool defer_commits_;
 

cc/scheduler/scheduler_unittest.cc

@@ -10,8 +10,6 @@
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
-#include "base/power_monitor/power_monitor.h"
-#include "base/power_monitor/power_monitor_source.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
@@ -198,21 +196,6 @@ class FakeSchedulerClient : public SchedulerClient {
   TestScheduler* scheduler_;
 };
 
-class FakePowerMonitorSource : public base::PowerMonitorSource {
- public:
-  FakePowerMonitorSource() {}
-  ~FakePowerMonitorSource() override {}
-  void GeneratePowerStateEvent(bool on_battery_power) {
-    on_battery_power_impl_ = on_battery_power;
-    ProcessPowerEvent(POWER_STATE_EVENT);
-    base::MessageLoop::current()->RunUntilIdle();
-  }
-  bool IsOnBatteryPowerImpl() override { return on_battery_power_impl_; }
-
- private:
-  bool on_battery_power_impl_;
-};
-
 class FakeExternalBeginFrameSource : public BeginFrameSourceMixIn {
  public:
   explicit FakeExternalBeginFrameSource(FakeSchedulerClient* client)
@@ -240,10 +223,7 @@ class SchedulerTest : public testing::Test {
   SchedulerTest()
       : now_src_(TestNowSource::Create()),
         task_runner_(new OrderedSimpleTaskRunner(now_src_, true)),
-        fake_external_begin_frame_source_(nullptr),
-        fake_power_monitor_source_(new FakePowerMonitorSource),
-        power_monitor_(make_scoped_ptr<base::PowerMonitorSource>(
-            fake_power_monitor_source_)) {
+        fake_external_begin_frame_source_(nullptr) {
     // A bunch of tests require Now() to be > BeginFrameArgs::DefaultInterval()
     now_src_->AdvanceNow(base::TimeDelta::FromMilliseconds(100));
     // Fail if we need to run 100 tasks in a row.
@@ -261,9 +241,9 @@ class SchedulerTest : public testing::Test {
       fake_external_begin_frame_source_ =
           fake_external_begin_frame_source.get();
     }
-    scheduler_ = TestScheduler::Create(
-        now_src_, client_.get(), scheduler_settings_, 0, task_runner_,
-        &power_monitor_, fake_external_begin_frame_source.Pass());
+    scheduler_ = TestScheduler::Create(now_src_, client_.get(),
+                                       scheduler_settings_, 0, task_runner_,
+                                       fake_external_begin_frame_source.Pass());
     DCHECK(scheduler_);
     client_->set_scheduler(scheduler_.get());
     return scheduler_.get();
@@ -386,11 +366,6 @@ class SchedulerTest : public testing::Test {
         CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now_src()));
   }
 
-  base::PowerMonitor* PowerMonitor() { return &power_monitor_; }
-  FakePowerMonitorSource* PowerMonitorSource() {
-    return fake_power_monitor_source_;
-  }
-
   FakeExternalBeginFrameSource* fake_external_begin_frame_source() const {
     return fake_external_begin_frame_source_;
   }
@@ -412,8 +387,6 @@ class SchedulerTest : public testing::Test {
   scoped_refptr<TestNowSource> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
   FakeExternalBeginFrameSource* fake_external_begin_frame_source_;
-  FakePowerMonitorSource* fake_power_monitor_source_;
-  base::PowerMonitor power_monitor_;
   SchedulerSettings scheduler_settings_;
   scoped_ptr<FakeSchedulerClient> client_;
   scoped_ptr<TestScheduler> scheduler_;
@@ -2119,131 +2092,6 @@ TEST_F(SchedulerTest, ScheduledActionActivateAfterBecomingInvisible) {
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 1, 2);
 }
 
-TEST_F(SchedulerTest, SchedulerPowerMonitoring) {
-  scheduler_settings_.disable_hi_res_timer_tasks_on_battery = true;
-  SetUpScheduler(true);
-
-  base::TimeTicks before_deadline, after_deadline;
-
-  scheduler_->SetNeedsCommit();
-  scheduler_->SetNeedsRedraw();
-  client_->Reset();
-
-  // On non-battery power
-  EXPECT_FALSE(PowerMonitor()->IsOnBatteryPower());
-
-  EXPECT_SCOPED(AdvanceFrame());
-  client_->Reset();
-
-  before_deadline = now_src()->Now();
-  EXPECT_TRUE(
-      task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)));
-  after_deadline = now_src()->Now();
-
-  // We post a non-zero deadline task when not on battery
-  EXPECT_LT(before_deadline, after_deadline);
-
-  // Switch to battery power
-  PowerMonitorSource()->GeneratePowerStateEvent(true);
-  EXPECT_TRUE(PowerMonitor()->IsOnBatteryPower());
-
-  EXPECT_SCOPED(AdvanceFrame());
-  scheduler_->SetNeedsCommit();
-  scheduler_->SetNeedsRedraw();
-  client_->Reset();
-
-  before_deadline = now_src()->Now();
-  EXPECT_TRUE(
-      task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)));
-  after_deadline = now_src()->Now();
-
-  // We post a zero deadline task when on battery
-  EXPECT_EQ(before_deadline, after_deadline);
-
-  // Switch to non-battery power
-  PowerMonitorSource()->GeneratePowerStateEvent(false);
-  EXPECT_FALSE(PowerMonitor()->IsOnBatteryPower());
-
-  EXPECT_SCOPED(AdvanceFrame());
-  scheduler_->SetNeedsCommit();
-  scheduler_->SetNeedsRedraw();
-  client_->Reset();
-
-  // Same as before
-  before_deadline = now_src()->Now();
-  EXPECT_TRUE(
-      task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true)));
-  after_deadline = now_src()->Now();
-}
-
-TEST_F(SchedulerTest,
-       SimulateWindowsLowResolutionTimerOnBattery_PrioritizeImplLatencyOff) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
-
-  // Set needs commit so that the scheduler tries to wait for the main thread
-  scheduler_->SetNeedsCommit();
-  // Set needs redraw so that the scheduler doesn't wait too long
-  scheduler_->SetNeedsRedraw();
-  client_->Reset();
-
-  // Switch to battery power
-  PowerMonitorSource()->GeneratePowerStateEvent(true);
-  EXPECT_TRUE(PowerMonitor()->IsOnBatteryPower());
-
-  EXPECT_SCOPED(AdvanceFrame());
-  scheduler_->SetNeedsCommit();
-  scheduler_->SetNeedsRedraw();
-  client_->Reset();
-
-  // Disable auto-advancing of now_src
-  task_runner().SetAutoAdvanceNowToPendingTasks(false);
-
-  // Deadline task is pending
-  EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
-  task_runner().RunPendingTasks();
-  // Deadline task is still pending
-  EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
-
-  // Advance now by 15 ms - same as windows low res timer
-  now_src()->AdvanceNowMicroseconds(15000);
-  EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
-  task_runner().RunPendingTasks();
-  // Deadline task finally completes
-  EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
-}
-
-TEST_F(SchedulerTest,
-       SimulateWindowsLowResolutionTimerOnBattery_PrioritizeImplLatencyOn) {
-  scheduler_settings_.disable_hi_res_timer_tasks_on_battery = true;
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
-
-  // Set needs commit so that the scheduler tries to wait for the main thread
-  scheduler_->SetNeedsCommit();
-  // Set needs redraw so that the scheduler doesn't wait too long
-  scheduler_->SetNeedsRedraw();
-  client_->Reset();
-
-  // Switch to battery power
-  PowerMonitorSource()->GeneratePowerStateEvent(true);
-  EXPECT_TRUE(PowerMonitor()->IsOnBatteryPower());
-
-  EXPECT_SCOPED(AdvanceFrame());
-  scheduler_->SetNeedsCommit();
-  scheduler_->SetNeedsRedraw();
-  client_->Reset();
-
-  // Disable auto-advancing of now_src
-  task_runner().SetAutoAdvanceNowToPendingTasks(false);
-
-  // Deadline task is pending
-  EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
-  task_runner().RunPendingTasks();
-  // Deadline task runs immediately
-  EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
-}
-
 // Tests to ensure frame sources can be successfully changed while drawing.
 TEST_F(SchedulerTest, SwitchFrameSourceToUnthrottled) {
   scheduler_settings_.use_external_begin_frame_source = true;

cc/test/scheduler_test_common.cc

@@ -131,14 +131,12 @@ TestScheduler::TestScheduler(
     const SchedulerSettings& scheduler_settings,
     int layer_tree_host_id,
     const scoped_refptr<OrderedSimpleTaskRunner>& test_task_runner,
-    base::PowerMonitor* power_monitor,
     TestSchedulerFrameSourcesConstructor* frame_sources_constructor,
     scoped_ptr<BeginFrameSource> external_begin_frame_source)
     : Scheduler(client,
                 scheduler_settings,
                 layer_tree_host_id,
                 test_task_runner,
-                power_monitor,
                 external_begin_frame_source.Pass(),
                 frame_sources_constructor),
       now_src_(now_src) {

cc/test/scheduler_test_common.h

@@ -164,7 +164,6 @@ class TestScheduler : public Scheduler {
       const SchedulerSettings& scheduler_settings,
       int layer_tree_host_id,
       const scoped_refptr<OrderedSimpleTaskRunner>& task_runner,
-      base::PowerMonitor* power_monitor,
       scoped_ptr<BeginFrameSource> external_begin_frame_source) {
     TestSchedulerFrameSourcesConstructor frame_sources_constructor(
         task_runner.get(), now_src.get());
@@ -174,7 +173,6 @@ class TestScheduler : public Scheduler {
                                    scheduler_settings,
                                    layer_tree_host_id,
                                    task_runner,
-                                   power_monitor,
                                    &frame_sources_constructor,
                                    external_begin_frame_source.Pass()));
   }
@@ -209,7 +207,6 @@ class TestScheduler : public Scheduler {
       const SchedulerSettings& scheduler_settings,
       int layer_tree_host_id,
       const scoped_refptr<OrderedSimpleTaskRunner>& test_task_runner,
-      base::PowerMonitor* power_monitor,
       TestSchedulerFrameSourcesConstructor* frame_sources_constructor,
       scoped_ptr<BeginFrameSource> external_begin_frame_source);
 

cc/trees/single_thread_proxy.cc

@@ -104,7 +104,6 @@ void SingleThreadProxy::SetLayerTreeHostClientReady() {
                           scheduler_settings,
                           layer_tree_host_->id(),
                           MainThreadTaskRunner(),
-                          base::PowerMonitor::Get(),
                           external_begin_frame_source_.Pass());
     scheduler_on_impl_thread_->SetCanStart();
     scheduler_on_impl_thread_->SetVisible(layer_tree_host_impl_->visible());

cc/trees/thread_proxy.cc

@@ -1171,7 +1171,6 @@ void ThreadProxy::InitializeImplOnImplThread(CompletionEvent* completion) {
                          scheduler_settings,
                          impl().layer_tree_host_id,
                          ImplThreadTaskRunner(),
-                         base::PowerMonitor::Get(),
                          impl().external_begin_frame_source.Pass());
   impl().scheduler->SetVisible(impl().layer_tree_host_impl->visible());
   impl_thread_weak_ptr_ = impl().weak_factory.GetWeakPtr();