Disable scheduler deadline task on battery power in Windows

cc/scheduler/scheduler_unittest.cc

 // Copyright 2011 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 "cc/scheduler/scheduler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #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 "cc/test/begin_frame_args_test.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "cc/test/scheduler_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #define EXPECT_ACTION(action, client, action_index, expected_num_actions) \
   do {                                                                    \
@@ skipping 1939 matching lines @@
   scheduler->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
 
   client.Reset();
   scheduler->SetVisible(false);
   // Sync tree should be forced to activate.
   EXPECT_ACTION("SetNeedsBeginFrames(false)", client, 0, 2);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client, 1, 2);
 }
 
+class FakePowerMonitorSource : public base::PowerMonitorSource {
+ public:
+  FakePowerMonitorSource() {}
+  virtual ~FakePowerMonitorSource() {}
+  void GeneratePowerStateEvent(bool on_battery_power) {
+    on_battery_power_impl_ = on_battery_power;
+    ProcessPowerEvent(POWER_STATE_EVENT);
+    base::MessageLoop::current()->RunUntilIdle();
+  }
+  virtual bool IsOnBatteryPowerImpl() override {
+    return on_battery_power_impl_;
+  }
+
+ private:
+  bool on_battery_power_impl_;
+};
+
+TEST(SchedulerTest, SchedulerPowerMonitoring) {
+  FakePowerMonitorSource* power_monitor_source = new FakePowerMonitorSource;
+  base::PowerMonitor power_monitor(
+      (scoped_ptr<base::PowerMonitorSource>(power_monitor_source)));
+
+  FakeSchedulerClient client;
+  SchedulerSettings settings;
+  settings.prioritize_impl_latency_on_battery = true;
+  TestScheduler* scheduler = client.CreateScheduler(settings);
+
+  base::TimeTicks before_deadline, after_deadline;
+
+  scheduler->SetCanStart();
+  scheduler->SetVisible(true);
+  scheduler->SetCanDraw(true);
+
+  InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
+
+  scheduler->SetNeedsCommit();
+  client.Reset();
+
+  // On non-battery power
+  EXPECT_FALSE(power_monitor.IsOnBatteryPower());
+
+  client.AdvanceFrame();
+  client.Reset();
+
+  before_deadline = client.now_src()->Now();
+  EXPECT_TRUE(client.task_runner().RunTasksWhile(
+      client.ImplFrameDeadlinePending(true)));
+  after_deadline = client.now_src()->Now();
+
+  // We post a non-zero deadline task when not on battery
+  EXPECT_LT(before_deadline, after_deadline);
+
+  // Switch to battery power
+  power_monitor_source->GeneratePowerStateEvent(true);
+  EXPECT_TRUE(power_monitor.IsOnBatteryPower());
+
+  client.AdvanceFrame();
+  client.Reset();
+
+  before_deadline = client.now_src()->Now();
+  EXPECT_TRUE(client.task_runner().RunTasksWhile(
+      client.ImplFrameDeadlinePending(true)));
+  after_deadline = client.now_src()->Now();
+
+  // We post a zero deadline task when on battery
+  EXPECT_EQ(before_deadline, after_deadline);
+
+  // Switch to non-battery power
+  power_monitor_source->GeneratePowerStateEvent(false);
+  EXPECT_FALSE(power_monitor.IsOnBatteryPower());
+
+  client.AdvanceFrame();
+  client.Reset();
+
+  // Same as before
+  before_deadline = client.now_src()->Now();
+  EXPECT_TRUE(client.task_runner().RunTasksWhile(
+      client.ImplFrameDeadlinePending(true)));
+  after_deadline = client.now_src()->Now();
+}
+
+TEST(SchedulerTest,
+     SimulateWindowsLowResolutionTimerOnBattery_PrioritizeImplLatencyOff) {
+  FakePowerMonitorSource* power_monitor_source = new FakePowerMonitorSource;
+  base::PowerMonitor power_monitor(
+      (scoped_ptr<base::PowerMonitorSource>(power_monitor_source)));
+
+  FakeSchedulerClient client;
+  SchedulerSettings settings;
+  TestScheduler* scheduler = client.CreateScheduler(settings);
+
+  scheduler->SetCanStart();
+  scheduler->SetVisible(true);
+  scheduler->SetCanDraw(true);
+
+  InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
+
+  // 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
+  power_monitor_source->GeneratePowerStateEvent(true);
+  EXPECT_TRUE(power_monitor.IsOnBatteryPower());
+
+  client.AdvanceFrame();
+  client.Reset();
+
+  // Disable auto-advancing of now_src
+  client.task_runner().SetAutoAdvanceNowToPendingTasks(false);
+
+  // Deadline task is pending
+  EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+  client.task_runner().RunPendingTasks();
+  // Deadline task is still pending
+  EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+
+  // Advance now by 15 ms - same as windows low res timer
+  client.now_src()->AdvanceNowMicroseconds(15000);
+  EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+  client.task_runner().RunUntilTime(client.now_src()->Now());
+  // Deadline task finally completes
+  EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
+}
+
+TEST(SchedulerTest,
+     SimulateWindowsLowResolutionTimerOnBattery_PrioritizeImplLatencyOn) {
+  FakePowerMonitorSource* power_monitor_source = new FakePowerMonitorSource;
+  base::PowerMonitor power_monitor(
+      (scoped_ptr<base::PowerMonitorSource>(power_monitor_source)));
+
+  FakeSchedulerClient client;
+  SchedulerSettings settings;
+  settings.prioritize_impl_latency_on_battery = true;
+  TestScheduler* scheduler = client.CreateScheduler(settings);
+
+  scheduler->SetCanStart();
+  scheduler->SetVisible(true);
+  scheduler->SetCanDraw(true);
+
+  InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
+
+  // 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
+  power_monitor_source->GeneratePowerStateEvent(true);
+  EXPECT_TRUE(power_monitor.IsOnBatteryPower());
+
+  client.AdvanceFrame();
+  client.Reset();
+
+  // Disable auto-advancing of now_src
+  client.task_runner().SetAutoAdvanceNowToPendingTasks(false);
+
+  // Deadline task is pending
+  EXPECT_TRUE(scheduler->BeginImplFrameDeadlinePending());
+  client.task_runner().RunPendingTasks();
+  // Deadline task runs immediately
+  EXPECT_FALSE(scheduler->BeginImplFrameDeadlinePending());
+}
+
 }  // namespace
 }  // namespace cc