Tablet-like power button behavior on Convertible/Tablet ChromeOS devices

ash/wm/power_button_controller.cc

 // Copyright (c) 2012 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/wm/power_button_controller.h"
 
 #include "ash/common/accelerators/accelerator_controller.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/system/audio/tray_audio.h"
@@ skipping 10 matching lines @@
 #include "ui/events/event_handler.h"
 #include "ui/wm/core/compound_event_filter.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/audio/cras_audio_handler.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #endif
 
 namespace ash {
 
+namespace {
+
+// Amount of time the power button must be held to start the pre-shutdown
+// animation when in tablet mode.
+constexpr int kTabletShutdownTimeoutMs = 1000;
+
+}  // namespace
+
+PowerButtonController::TestApi::TestApi(PowerButtonController* controller)
+    : controller_(controller) {}
+
+PowerButtonController::TestApi::~TestApi() {}
+
+bool PowerButtonController::TestApi::TabletPowerButtonTimerIsRunning() const {
+  return controller_->tablet_power_button_timer_.IsRunning();
+}
+
+void PowerButtonController::TestApi::TriggerTabletPowerButtonTimeout() {
+  controller_->OnTabletPowerButtonTimeout();
+  controller_->tablet_power_button_timer_.Stop();
+}
+
 PowerButtonController::PowerButtonController(LockStateController* controller)
     : power_button_down_(false),
       lock_button_down_(false),
       volume_down_pressed_(false),
 #if defined(OS_CHROMEOS)
       volume_percent_before_screenshot_(0),
 #endif
       brightness_is_zero_(false),
       internal_display_off_and_external_display_on_(false),
       has_legacy_power_button_(
           base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kAuraLegacyPowerButton)),
 #if defined(OS_CHROMEOS)
       enable_quick_lock_(base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshEnableTouchView)),
 #else
       enable_quick_lock_(false),
 #endif
-      controller_(controller) {
+      controller_(controller),
+      power_button_down_while_screen_off_(false),
+      backlights_forced_off_(false) {
 #if defined(OS_CHROMEOS)
   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->AddObserver(
       this);
   Shell::GetInstance()->display_configurator()->AddObserver(this);
 #endif
   Shell::GetInstance()->PrependPreTargetHandler(this);
+
+  GetInitialBacklightsForcedOff();
 }
 
 PowerButtonController::~PowerButtonController() {
   Shell::GetInstance()->RemovePreTargetHandler(this);
 #if defined(OS_CHROMEOS)
   Shell::GetInstance()->display_configurator()->RemoveObserver(this);
   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(
       this);
 #endif
 }
 
 void PowerButtonController::OnScreenBrightnessChanged(double percent) {
   brightness_is_zero_ = percent <= 0.001;
 }
 
 void PowerButtonController::OnPowerButtonEvent(
     bool down,
     const base::TimeTicks& timestamp) {
   power_button_down_ = down;
 
   if (controller_->ShutdownRequested())
     return;
 
+  bool should_take_screenshot =
+      down && volume_down_pressed_ && IsTabletModeActive();
+
+  if (down)
+    power_button_down_while_screen_off_ = brightness_is_zero_;
+
+  if (!has_legacy_power_button_ && !should_take_screenshot &&
+      IsTabletModeSupported()) {
+    OnTabletPowerButtonEvent(down, timestamp);
+    return;
+  }
+
   // Avoid starting the lock/shutdown sequence if the power button is pressed
   // while the screen is off (http://crbug.com/128451), unless an external
   // display is still on (http://crosbug.com/p/24912).
   if (brightness_is_zero_ && !internal_display_off_and_external_display_on_)
     return;
 
-  if (volume_down_pressed_ && down &&
-      WmShell::Get()
-          ->maximize_mode_controller()
-          ->IsMaximizeModeWindowManagerEnabled()) {
+  if (should_take_screenshot) {
     SystemTray* system_tray = Shell::GetInstance()->GetPrimarySystemTray();
     if (system_tray && system_tray->GetTrayAudio())
       system_tray->GetTrayAudio()->HideDetailedView(false);
 
     WmShell::Get()->accelerator_controller()->PerformActionIfEnabled(
         TAKE_SCREENSHOT);
 
 #if defined(OS_CHROMEOS)
     // Restore volume.
     chromeos::CrasAudioHandler* audio_handler =
@@ skipping 21 matching lines @@
       }
     }
   } else {  // !has_legacy_power_button_
     if (down) {
       // If we already have a pending request to lock the screen, wait.
       if (controller_->LockRequested())
         return;
 
       if (session_state_delegate->CanLockScreen() &&
           !session_state_delegate->IsUserSessionBlocked()) {
-        if (WmShell::Get()
-                ->maximize_mode_controller()
-                ->IsMaximizeModeWindowManagerEnabled() &&
-            enable_quick_lock_)
+        if (IsTabletModeActive() && enable_quick_lock_)
           controller_->StartLockAnimationAndLockImmediately(true);
         else
           controller_->StartLockAnimation(true);
       } else {
         controller_->StartShutdownAnimation();
       }
     } else {  // Button is up.
       if (controller_->CanCancelLockAnimation())
         controller_->CancelLockAnimation();
       else if (controller_->CanCancelShutdownAnimation())
@@ skipping 19 matching lines @@
   if (power_button_down_)
     return;
 
   if (down)
     controller_->StartLockAnimation(false);
   else
     controller_->CancelLockAnimation();
 }
 
 void PowerButtonController::OnKeyEvent(ui::KeyEvent* event) {
+  if (!IsTabletModeActive() && backlights_forced_off_) {
+    SetBacklightsForcedOff(false);
+    return;
+  }
+
   if (event->key_code() == ui::VKEY_VOLUME_DOWN) {
     volume_down_pressed_ = event->type() == ui::ET_KEY_PRESSED;
 #if defined(OS_CHROMEOS)
     if (!event->is_repeat()) {
       chromeos::CrasAudioHandler* audio_handler =
           chromeos::CrasAudioHandler::Get();
       volume_percent_before_screenshot_ =
           audio_handler->GetOutputVolumePercent();
     }
 #endif
   }
 }
 
+void PowerButtonController::OnMouseEvent(ui::MouseEvent* event) {
+  if (!IsTabletModeActive() && backlights_forced_off_) {
+    SetBacklightsForcedOff(false);
+  }
+}
+
 #if defined(OS_CHROMEOS)
 void PowerButtonController::OnDisplayModeChanged(
     const ui::DisplayConfigurator::DisplayStateList& display_states) {
   bool internal_display_off = false;
   bool external_display_on = false;
   for (const ui::DisplaySnapshot* display : display_states) {
     if (display->type() == ui::DISPLAY_CONNECTION_TYPE_INTERNAL) {
       if (!display->current_mode())
         internal_display_off = true;
     } else if (display->current_mode()) {
       external_display_on = true;
     }
   }
   internal_display_off_and_external_display_on_ =
       internal_display_off && external_display_on;
 }
 
 void PowerButtonController::PowerButtonEventReceived(
     bool down,
     const base::TimeTicks& timestamp) {
   OnPowerButtonEvent(down, timestamp);
 }
 #endif  // defined(OS_CHROMEOS)
 
+void PowerButtonController::OnTabletPowerButtonEvent(

[Daniel Erat, 2016/11/04 20:18:34]

hmm... so i've noticed that the tablet power button code seems to be completely
disjoint from the regular power button code now. would it make sense to move it
into its own class in a different file after all, and have it be chrome-os-only?
PowerButtonController would instantiate TabletPowerButtonController only when
OS_CHROMEOS is defined.

i feel like that might be cleaner, since it feels completely separate from the
regular code.

  class TabletPowerButtonController {
   public:
    // Returns true if power button events should be handled by
    // this class instead of PowerButtonController.
    bool ShouldHandlePowerButtonEvents() const;

    // Handles a power button event.
    void OnPowerButtonEvent(bool down, base::TimeTicks timestamp);

   private:
    // all of your new methods go here
    // also members like power_button_down_while_screen_off_
  }

then in PowerButtonController::OnPowerButtonEvent:

#if defined(OS_CHROMEOS)
  if (!has_legacy_power_button_ && !should_take_screenshot &&
      tablet_controller_->ShouldHandlePowerButtonEvents()) {
    tablet_controller_->OnPowerButtonEvent(down, timestamp);
    return;
  }

[Qiang(Joe) Xu, 2016/11/04 23:18:21]

Actually there are some overlaps. Like TabletPowerButtonController needs the
access to brightness_is_zero_ (but we can pass it as parameter).

In this way, TabletPowerButtonController only needs to subclass
ui::EventHandler.

+    bool down,
+    const base::TimeTicks& timestamp) {
+  if (down) {
+    SetBacklightsForcedOff(false);
+    StartTabletPowerButtonTimer();
+  } else {
+    if (tablet_power_button_timer_.IsRunning()) {
+      tablet_power_button_timer_.Stop();
+      if (!power_button_down_while_screen_off_) {
+        SetBacklightsForcedOff(true);
+        LockScreenIfRequired();
+      }
+    }
+    power_button_down_while_screen_off_ = false;
+
+    // When power button is released, Cancel Shutdown animation whenever it is
+    // still cancellable.
+    if (controller_->CanCancelShutdownAnimation())
+      controller_->CancelShutdownAnimation();
+  }
+}
+
+void PowerButtonController::SetBacklightsForcedOff(bool forced_off) {
+  if (backlights_forced_off_ == forced_off)
+    return;
+
+#if defined(OS_CHROMEOS)
+  chromeos::DBusThreadManager::Get()
+      ->GetPowerManagerClient()
+      ->SetBacklightsForcedOff(forced_off);
+  backlights_forced_off_ = forced_off;
+#endif
+}
+
+void PowerButtonController::GetInitialBacklightsForcedOff() {
+#if defined(OS_CHROMEOS)
+  chromeos::DBusThreadManager::Get()
+      ->GetPowerManagerClient()
+      ->GetBacklightsForcedOff(
+          base::Bind(&PowerButtonController::OnGotInitialBacklightsForcedOff,
+                     base::Unretained(this)));
+#endif
+}
+
+void PowerButtonController::OnGotInitialBacklightsForcedOff(
+    bool is_forced_off) {
+  backlights_forced_off_ = is_forced_off;
+}
+
+void PowerButtonController::StartTabletPowerButtonTimer() {
+  tablet_power_button_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromMilliseconds(kTabletShutdownTimeoutMs),
+      this, &PowerButtonController::OnTabletPowerButtonTimeout);
+}
+
+void PowerButtonController::OnTabletPowerButtonTimeout() {
+  controller_->StartShutdownAnimation();
+}
+
+void PowerButtonController::LockScreenIfRequired() {
+  SessionStateDelegate* session_state_delegate =
+      WmShell::Get()->GetSessionStateDelegate();
+  if (session_state_delegate->ShouldLockScreenAutomatically() &&
+      session_state_delegate->CanLockScreen() &&
+      !session_state_delegate->IsUserSessionBlocked() &&
+      !controller_->LockRequested()) {
+    session_state_delegate->LockScreen();
+  }
+}
+
+bool PowerButtonController::IsTabletModeSupported() const {
+  MaximizeModeController* maximize_mode_controller =
+      WmShell::Get()->maximize_mode_controller();
+  return maximize_mode_controller &&
+         maximize_mode_controller->CanEnterMaximizeMode();
+}
+
+bool PowerButtonController::IsTabletModeActive() const {
+  MaximizeModeController* maximize_mode_controller =
+      WmShell::Get()->maximize_mode_controller();
+  return maximize_mode_controller &&
+         maximize_mode_controller->IsMaximizeModeWindowManagerEnabled();
+}
+
 }  // namespace ash