mash: Migrate [Keyboard]Brightness code to ash/common.

ash/accelerators/accelerator_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/accelerators/accelerator_controller.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <utility>
 
 #include "ash/accelerators/accelerator_commands.h"
 #include "ash/accelerators/debug_commands.h"
 #include "ash/common/accessibility_delegate.h"
 #include "ash/common/accessibility_types.h"
 #include "ash/common/ash_switches.h"
 #include "ash/common/focus_cycler.h"
 #include "ash/common/media_delegate.h"
 #include "ash/common/multi_profile_uma.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shell_delegate.h"
 #include "ash/common/shell_window_ids.h"
+#include "ash/common/system/brightness_control_delegate.h"
+#include "ash/common/system/keyboard_brightness_control_delegate.h"
 #include "ash/common/system/system_notifier.h"
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/system/tray/system_tray_notifier.h"
 #include "ash/common/system/volume_control_delegate.h"
 #include "ash/common/system/web_notification/web_notification_tray.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/overview/window_selector_controller.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_event.h"
 #include "ash/common/wm_shell.h"
 #include "ash/debug.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/gpu_support.h"
 #include "ash/ime_control_delegate.h"
 #include "ash/magnifier/magnification_controller.h"
 #include "ash/magnifier/partial_magnification_controller.h"
 #include "ash/new_window_delegate.h"
 #include "ash/root_window_controller.h"
 #include "ash/rotator/screen_rotation_animator.h"
 #include "ash/rotator/window_rotation.h"
 #include "ash/screen_util.h"
 #include "ash/screenshot_delegate.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_delegate.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
-#include "ash/system/brightness_control_delegate.h"
-#include "ash/system/keyboard_brightness/keyboard_brightness_control_delegate.h"
 #include "ash/system/status_area_widget.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/touch/touch_hud_debug.h"
 #include "ash/utility/screenshot_controller.h"
 #include "ash/wm/power_button_controller.h"
 #include "ash/wm/window_cycle_controller.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 11 matching lines @@
 #include "ui/compositor/layer_animator.h"
 #include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/message_center/message_center.h"
 #include "ui/message_center/notification.h"
 #include "ui/message_center/notifier_settings.h"
 
 #if defined(OS_CHROMEOS)
 #include "ash/display/display_configuration_controller.h"
-#include "ash/system/chromeos/keyboard_brightness_controller.h"
 #include "base/sys_info.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager_client.h"
 #include "ui/base/ime/chromeos/ime_keyboard.h"
 #include "ui/base/ime/chromeos/input_method_manager.h"
 #endif  // defined(OS_CHROMEOS)
 
 namespace ash {
 namespace {
 
@@ skipping 452 matching lines @@
 bool CanHandleUnpin() {
   wm::WindowState* window_state = wm::GetActiveWindowState();
   return window_state && window_state->IsPinned();
 }
 
 void HandleUnpin() {
   accelerators::Unpin();
 }
 
 #if defined(OS_CHROMEOS)
-void HandleBrightnessDown(BrightnessControlDelegate* delegate,
-                          const ui::Accelerator& accelerator) {
-  if (delegate)
-    delegate->HandleBrightnessDown(accelerator);
-}
-
-void HandleBrightnessUp(BrightnessControlDelegate* delegate,
-                        const ui::Accelerator& accelerator) {
-  if (delegate)
-    delegate->HandleBrightnessUp(accelerator);
-}
-
 bool CanHandleDisableCapsLock(const ui::Accelerator& previous_accelerator) {
   ui::KeyboardCode previous_key_code = previous_accelerator.key_code();
   if (previous_accelerator.type() == ui::ET_KEY_RELEASED ||
       (previous_key_code != ui::VKEY_LSHIFT &&
        previous_key_code != ui::VKEY_SHIFT &&
        previous_key_code != ui::VKEY_RSHIFT)) {
     // If something else was pressed between the Shift key being pressed
     // and released, then ignore the release of the Shift key.
     return false;
   }
   chromeos::input_method::InputMethodManager* ime =
       chromeos::input_method::InputMethodManager::Get();
   chromeos::input_method::ImeKeyboard* keyboard =
       ime ? ime->GetImeKeyboard() : NULL;
   return (keyboard && keyboard->CapsLockIsEnabled());
 }
 
 void HandleDisableCapsLock() {
   base::RecordAction(UserMetricsAction("Accel_Disable_Caps_Lock"));
   chromeos::input_method::InputMethodManager* ime =
       chromeos::input_method::InputMethodManager::Get();
   ime->GetImeKeyboard()->SetCapsLockEnabled(false);
 }
 
-void HandleKeyboardBrightnessDown(KeyboardBrightnessControlDelegate* delegate,
-                                  const ui::Accelerator& accelerator) {
-  if (delegate)
-    delegate->HandleKeyboardBrightnessDown(accelerator);
-}
-
-void HandleKeyboardBrightnessUp(KeyboardBrightnessControlDelegate* delegate,
-                                const ui::Accelerator& accelerator) {
-  if (delegate)
-    delegate->HandleKeyboardBrightnessUp(accelerator);
-}
-
 bool CanHandleLock() {
   return WmShell::Get()->GetSessionStateDelegate()->CanLockScreen();
 }
 
 void HandleLock() {
   base::RecordAction(UserMetricsAction("Accel_LockScreen_L"));
   WmShell::Get()->GetSessionStateDelegate()->LockScreen();
 }
 
 void HandleSuspend() {
@@ skipping 185 matching lines @@
     return true;
   }
   return false;
 }
 
 AcceleratorController::AcceleratorProcessingRestriction
 AcceleratorController::GetCurrentAcceleratorRestriction() {
   return GetAcceleratorProcessingRestriction(-1);
 }
 
-void AcceleratorController::SetBrightnessControlDelegate(
-    std::unique_ptr<BrightnessControlDelegate> brightness_control_delegate) {
-  brightness_control_delegate_ = std::move(brightness_control_delegate);
-}
-
 void AcceleratorController::SetImeControlDelegate(
     std::unique_ptr<ImeControlDelegate> ime_control_delegate) {
   ime_control_delegate_ = std::move(ime_control_delegate);
 }
 
 void AcceleratorController::SetScreenshotDelegate(
     std::unique_ptr<ScreenshotDelegate> screenshot_delegate) {
   screenshot_delegate_ = std::move(screenshot_delegate);
 }
 
@@ skipping 96 matching lines @@
   RegisterAccelerators(kAcceleratorData, kAcceleratorDataLength);
 
   RegisterDeprecatedAccelerators();
 
   if (debug::DebugAcceleratorsEnabled()) {
     RegisterAccelerators(kDebugAcceleratorData, kDebugAcceleratorDataLength);
     // All debug accelerators are reserved.
     for (size_t i = 0; i < kDebugAcceleratorDataLength; ++i)
       reserved_actions_.insert(kDebugAcceleratorData[i].action);
   }
-
-#if defined(OS_CHROMEOS)
-  keyboard_brightness_control_delegate_.reset(
-      new KeyboardBrightnessController());
-#endif
 }
 
 void AcceleratorController::RegisterAccelerators(
     const AcceleratorData accelerators[],
     size_t accelerators_length) {
   for (size_t i = 0; i < accelerators_length; ++i) {
     ui::Accelerator accelerator =
         CreateAccelerator(accelerators[i].keycode, accelerators[i].modifiers,
                           accelerators[i].trigger_on_press);
     Register(accelerator, this);
@@ skipping 327 matching lines @@
     case WINDOW_MINIMIZE:
       HandleWindowMinimize();
       break;
     case WINDOW_POSITION_CENTER:
       HandlePositionCenter();
       break;
     case UNPIN:
       HandleUnpin();
       break;
 #if defined(OS_CHROMEOS)
-    case BRIGHTNESS_DOWN:
-      HandleBrightnessDown(brightness_control_delegate_.get(), accelerator);
+    case BRIGHTNESS_DOWN: {
+      BrightnessControlDelegate* delegate =
+          WmShell::Get()->brightness_control_delegate();
+      if (delegate)
+        delegate->HandleBrightnessDown(accelerator);
       break;
-    case BRIGHTNESS_UP:
-      HandleBrightnessUp(brightness_control_delegate_.get(), accelerator);
+    }
+    case BRIGHTNESS_UP: {
+      BrightnessControlDelegate* delegate =
+          WmShell::Get()->brightness_control_delegate();
+      if (delegate)
+        delegate->HandleBrightnessUp(accelerator);
       break;
+    }
     case DEBUG_ADD_REMOVE_DISPLAY:
     case DEBUG_SHOW_TOAST:
     case DEBUG_TOGGLE_TOUCH_PAD:
     case DEBUG_TOGGLE_TOUCH_SCREEN:
     case DEBUG_TOGGLE_TOUCH_VIEW:
     case DEBUG_TOGGLE_UNIFIED_DESKTOP:
       debug::PerformDebugActionIfEnabled(action);
       break;
     case DISABLE_CAPS_LOCK:
       HandleDisableCapsLock();
       break;
     case DISABLE_GPU_WATCHDOG:
       Shell::GetInstance()->gpu_support()->DisableGpuWatchdog();
       break;
-    case KEYBOARD_BRIGHTNESS_DOWN:
-      HandleKeyboardBrightnessDown(keyboard_brightness_control_delegate_.get(),
-                                   accelerator);
+    case KEYBOARD_BRIGHTNESS_DOWN: {
+      KeyboardBrightnessControlDelegate* delegate =
+          WmShell::Get()->keyboard_brightness_control_delegate();
+      if (delegate)
+        delegate->HandleKeyboardBrightnessDown(accelerator);
       break;
-    case KEYBOARD_BRIGHTNESS_UP:
-      HandleKeyboardBrightnessUp(keyboard_brightness_control_delegate_.get(),
-                                 accelerator);
+    }
+    case KEYBOARD_BRIGHTNESS_UP: {
+      KeyboardBrightnessControlDelegate* delegate =
+          WmShell::Get()->keyboard_brightness_control_delegate();
+      if (delegate)
+        delegate->HandleKeyboardBrightnessUp(accelerator);
       break;
+    }
     case LOCK_PRESSED:
     case LOCK_RELEASED:
       Shell::GetInstance()->power_button_controller()->OnLockButtonEvent(
           action == LOCK_PRESSED, base::TimeTicks());
       break;
     case LOCK_SCREEN:
       HandleLock();
       break;
     case OPEN_CROSH:
       HandleCrosh();
@@ skipping 107 matching lines @@
   }
   if (wm_shell->mru_window_tracker()->BuildMruWindowList().empty() &&
       actions_needing_window_.find(action) != actions_needing_window_.end()) {
     wm_shell->GetAccessibilityDelegate()->TriggerAccessibilityAlert(
         A11Y_ALERT_WINDOW_NEEDED);
     return RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
   }
   return RESTRICTION_NONE;
 }
 
-void AcceleratorController::SetKeyboardBrightnessControlDelegate(
-    std::unique_ptr<KeyboardBrightnessControlDelegate>
-        keyboard_brightness_control_delegate) {
-  keyboard_brightness_control_delegate_ =
-      std::move(keyboard_brightness_control_delegate);
-}
-
 }  // namespace ash