Resuming from suspend should stop backlights forced off if they are

ash/system/chromeos/power/tablet_power_button_controller_unittest.cc

 // Copyright 2016 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 "ash/system/chromeos/power/tablet_power_button_controller.h"
 
 #include <memory>
 
 #include "ash/common/ash_switches.h"
 #include "ash/common/session/session_state_delegate.h"
@@ skipping 43 matching lines @@
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kAshEnableTabletPowerButton);
     AshTestBase::SetUp();
 
     lock_state_controller_ = Shell::GetInstance()->lock_state_controller();
     tablet_controller_ = Shell::GetInstance()
                              ->power_button_controller()
                              ->tablet_power_button_controller_for_test();
     test_api_ = base::MakeUnique<TabletPowerButtonController::TestApi>(
         tablet_controller_);
+    tick_clock_ = new base::SimpleTestTickClock;
+    tablet_controller_->SetTickClockForTesting(
+        std::unique_ptr<base::TickClock>(tick_clock_));
     generator_ = &AshTestBase::GetEventGenerator();
     power_manager_client_->SendBrightnessChanged(kNonZeroBrightness, false);
     EXPECT_FALSE(GetBacklightsForcedOff());
   }
 
   void TearDown() override {
     generator_ = nullptr;
     AshTestBase::TearDown();
     chromeos::DBusThreadManager::Shutdown();
   }
@@ skipping 34 matching lines @@
     base::RunLoop().RunUntilIdle();
     return forced_off;
   }
 
   // Ownership is passed on to chromeos::DBusThreadManager.
   chromeos::FakePowerManagerClient* power_manager_client_;
 
   LockStateController* lock_state_controller_;      // Not owned.
   TabletPowerButtonController* tablet_controller_;  // Not owned.
   std::unique_ptr<TabletPowerButtonController::TestApi> test_api_;
+  base::SimpleTestTickClock* tick_clock_;  // Not owned.
   ui::test::EventGenerator* generator_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(TabletPowerButtonControllerTest);
 };
 
 TEST_F(TabletPowerButtonControllerTest, LockScreenIfRequired) {
   Initialize(LoginStatus::USER);
   SetShouldLockScreenAutomatically(true);
   EXPECT_FALSE(GetLockedState());
 
@@ skipping 75 matching lines @@
 // Tests tapping power button when screen is idle off.
 TEST_F(TabletPowerButtonControllerTest, TappingPowerButtonWhenScreenIsIdleOff) {
   power_manager_client_->SendBrightnessChanged(0, false);
   PressPowerButton();
   EXPECT_FALSE(GetBacklightsForcedOff());
   power_manager_client_->SendBrightnessChanged(kNonZeroBrightness, false);
   ReleasePowerButton();
   EXPECT_FALSE(GetBacklightsForcedOff());
 }
 
-// Tests tapping power button when device is suspended.
-TEST_F(TabletPowerButtonControllerTest, TappingPowerButtonWhenSuspended) {
-  base::SimpleTestTickClock* tick_clock = new base::SimpleTestTickClock;
-  // |tick_clock| owned by |tablet_controller_|.
-  tablet_controller_->SetTickClockForTesting(
-      std::unique_ptr<base::TickClock>(tick_clock));
-
+// Tests tapping power button when device is suspended without backlights forced
+// off.
+TEST_F(TabletPowerButtonControllerTest,
+       TappingPowerButtonWhenSuspendedWithoutBacklightsForcedOff) {
   power_manager_client_->SendSuspendImminent();
   power_manager_client_->SendBrightnessChanged(0, false);
   // There is a power button pressed here, but PowerButtonEvent is sent later.
   power_manager_client_->SendSuspendDone();
   power_manager_client_->SendBrightnessChanged(kNonZeroBrightness, false);
 
   // Send the power button event after a short delay and check that it is
   // ignored.
-  tick_clock->Advance(base::TimeDelta::FromMilliseconds(500));
-  power_manager_client_->SendPowerButtonEvent(true, tick_clock->NowTicks());
-  power_manager_client_->SendPowerButtonEvent(false, tick_clock->NowTicks());
+  tick_clock_->Advance(base::TimeDelta::FromMilliseconds(500));
+  power_manager_client_->SendPowerButtonEvent(true, tick_clock_->NowTicks());
+  power_manager_client_->SendPowerButtonEvent(false, tick_clock_->NowTicks());
   EXPECT_FALSE(GetBacklightsForcedOff());
 
   // Send the power button event after a longer delay and check that it is not
   // ignored.
-  tick_clock->Advance(base::TimeDelta::FromMilliseconds(1600));
-  power_manager_client_->SendPowerButtonEvent(true, tick_clock->NowTicks());
-  power_manager_client_->SendPowerButtonEvent(false, tick_clock->NowTicks());
+  tick_clock_->Advance(base::TimeDelta::FromMilliseconds(1600));
+  power_manager_client_->SendPowerButtonEvent(true, tick_clock_->NowTicks());
+  power_manager_client_->SendPowerButtonEvent(false, tick_clock_->NowTicks());
+  power_manager_client_->SendBrightnessChanged(0, false);
   EXPECT_TRUE(GetBacklightsForcedOff());
 }
 
+// Tests tapping power button when device is suspended with backlights forced
+// off.
+TEST_F(TabletPowerButtonControllerTest,
+       TappingPowerButtonWhenSuspendedWithBacklightsForcedOff) {
+  PressPowerButton();
+  ReleasePowerButton();
+  power_manager_client_->SendBrightnessChanged(0, false);
+  EXPECT_TRUE(GetBacklightsForcedOff());
+  power_manager_client_->SendSuspendImminent();
+  // There is a power button pressed here, but PowerButtonEvent is sent later.
+  // Because of backlights forced off, resuming system will not restore
+  // brightness.
+  power_manager_client_->SendSuspendDone();
+
+  // Send the power button event after a short delay and check that it is
+  // ignored. But if backlights are forced off, stop forcing off.
+  tick_clock_->Advance(base::TimeDelta::FromMilliseconds(500));
+  power_manager_client_->SendPowerButtonEvent(true, tick_clock_->NowTicks());
+  power_manager_client_->SendBrightnessChanged(kNonZeroBrightness, false);
+  power_manager_client_->SendPowerButtonEvent(false, tick_clock_->NowTicks());
+  EXPECT_FALSE(GetBacklightsForcedOff());
+
+  // Send the power button event after a longer delay and check that it is not
+  // ignored.
+  tick_clock_->Advance(base::TimeDelta::FromMilliseconds(1600));
+  power_manager_client_->SendPowerButtonEvent(true, tick_clock_->NowTicks());
+  power_manager_client_->SendPowerButtonEvent(false, tick_clock_->NowTicks());
+  power_manager_client_->SendBrightnessChanged(0, false);
+  EXPECT_TRUE(GetBacklightsForcedOff());
+}
+
 // For convertible device working on laptop mode, tests keyboard/mouse event
 // when screen is off.
 TEST_F(TabletPowerButtonControllerTest, ConvertibleOnLaptopMode) {
   EnableMaximizeMode(false);
 
   // KeyEvent should SetBacklightsForcedOff(false).
   PressPowerButton();
   ReleasePowerButton();
   power_manager_client_->SendBrightnessChanged(0, false);
   EXPECT_TRUE(GetBacklightsForcedOff());
@@ skipping 67 matching lines @@
   tablet_controller_->OnKeyEvent(&power_key_pressed);
   tablet_controller_->OnKeyEvent(&power_key_pressed);
   ReleasePowerButton();
   tablet_controller_->OnKeyEvent(&power_key_released);
   tablet_controller_->OnKeyEvent(&power_key_released);
   EXPECT_EQ(1, power_manager_client_->num_set_backlights_forced_off_calls());
 }
 
 }  // namespace test
 }  // namespace ash