clang-format all of //ash

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>
@@ skipping 222 matching lines @@
 }
 
 void HandleLaunchLastApp() {
   base::RecordAction(UserMetricsAction("Accel_Launch_Last_App"));
   Shelf::ForPrimaryDisplay()->LaunchAppIndexAt(-1);
 }
 
 bool CanHandleMagnifyScreen() {
   Shell* shell = Shell::GetInstance();
   return shell->magnification_controller()->IsEnabled() ||
-      shell->partial_magnification_controller()->is_enabled();
+         shell->partial_magnification_controller()->is_enabled();
 }
 
 // Magnify the screen
 void HandleMagnifyScreen(int delta_index) {
   if (ash::Shell::GetInstance()->magnification_controller()->IsEnabled()) {
     // TODO(yoshiki): Move the following logic to MagnificationController.
     float scale =
         ash::Shell::GetInstance()->magnification_controller()->GetScale();
     // Calculate rounded logarithm (base kMagnificationScaleFactor) of scale.
     int scale_index =
         std::floor(std::log(scale) / std::log(kMagnificationScaleFactor) + 0.5);
 
     int new_scale_index = std::max(0, std::min(8, scale_index + delta_index));
 
     ash::Shell::GetInstance()->magnification_controller()->SetScale(
         std::pow(kMagnificationScaleFactor, new_scale_index), true);
-  } else if (ash::Shell::GetInstance()->
-             partial_magnification_controller()->is_enabled()) {
+  } else if (ash::Shell::GetInstance()
+                 ->partial_magnification_controller()
+                 ->is_enabled()) {
     float scale = delta_index > 0 ? kDefaultPartialMagnifiedScale : 1;
-    ash::Shell::GetInstance()->partial_magnification_controller()->
-        SetScale(scale);
+    ash::Shell::GetInstance()->partial_magnification_controller()->SetScale(
+        scale);
   }
 }
 
 void HandleMediaNextTrack() {
   Shell::GetInstance()->media_delegate()->HandleMediaNextTrack();
 }
 
 void HandleMediaPlayPause() {
   Shell::GetInstance()->media_delegate()->HandleMediaPlayPause();
 }
@@ skipping 108 matching lines @@
 
 // Rotate the active window.
 void HandleRotateActiveWindow() {
   base::RecordAction(UserMetricsAction("Accel_Rotate_Window"));
   aura::Window* active_window = wm::GetActiveWindow();
   if (active_window) {
     // The rotation animation bases its target transform on the current
     // rotation and position. Since there could be an animation in progress
     // right now, queue this animation so when it starts it picks up a neutral
     // rotation and position. Use replace so we only enqueue one at a time.
-    active_window->layer()->GetAnimator()->
-        set_preemption_strategy(ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
+    active_window->layer()->GetAnimator()->set_preemption_strategy(
+        ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
     active_window->layer()->GetAnimator()->StartAnimation(
         new ui::LayerAnimationSequence(
             new ash::WindowRotation(360, active_window->layer())));
   }
 }
 
 void HandleShowKeyboardOverlay() {
   base::RecordAction(UserMetricsAction("Accel_Show_Keyboard_Overlay"));
   ash::Shell::GetInstance()->new_window_delegate()->ShowKeyboardOverlay();
 }
@@ skipping 30 matching lines @@
 }
 
 void HandleShowTaskManager() {
   base::RecordAction(UserMetricsAction("Accel_Show_Task_Manager"));
   Shell::GetInstance()->new_window_delegate()->ShowTaskManager();
 }
 
 bool CanHandleSwitchIme(ImeControlDelegate* ime_control_delegate,
                         const ui::Accelerator& accelerator) {
   return ime_control_delegate &&
-      ime_control_delegate->CanSwitchIme(accelerator);
+         ime_control_delegate->CanSwitchIme(accelerator);
 }
 
 void HandleSwitchIme(ImeControlDelegate* ime_control_delegate,
                      const ui::Accelerator& accelerator) {
   base::RecordAction(UserMetricsAction("Accel_Switch_Ime"));
   ime_control_delegate->HandleSwitchIme(accelerator);
 }
 
 void HandleTakeWindowScreenshot(ScreenshotDelegate* screenshot_delegate) {
   base::RecordAction(UserMetricsAction("Accel_Take_Window_Screenshot"));
@@ skipping 63 matching lines @@
   return (window_state && window_state->IsUserPositionable() &&
           !window_state->IsFullscreen());
 }
 
 void HandleWindowSnapOrDock(AcceleratorAction action) {
   if (action == WINDOW_CYCLE_SNAP_DOCK_LEFT)
     base::RecordAction(UserMetricsAction("Accel_Window_Snap_Left"));
   else
     base::RecordAction(UserMetricsAction("Accel_Window_Snap_Right"));
 
-  const wm::WMEvent event(action == WINDOW_CYCLE_SNAP_DOCK_LEFT ?
-                          wm::WM_EVENT_CYCLE_SNAP_DOCK_LEFT :
-                          wm::WM_EVENT_CYCLE_SNAP_DOCK_RIGHT);
+  const wm::WMEvent event(action == WINDOW_CYCLE_SNAP_DOCK_LEFT
+                              ? wm::WM_EVENT_CYCLE_SNAP_DOCK_LEFT
+                              : wm::WM_EVENT_CYCLE_SNAP_DOCK_RIGHT);
   wm::GetActiveWindowState()->OnWMEvent(&event);
 }
 
 void HandleWindowMinimize() {
-  base::RecordAction(
-      base::UserMetricsAction("Accel_Toggle_Minimized_Minus"));
+  base::RecordAction(base::UserMetricsAction("Accel_Toggle_Minimized_Minus"));
   accelerators::ToggleMinimized();
 }
 
 bool CanHandlePositionCenter() {
   // Docked windows do not support centering.
   wm::WindowState* window_state = wm::GetActiveWindowState();
   return (window_state && !window_state->IsDocked());
 }
 
 void HandlePositionCenter() {
@@ skipping 91 matching lines @@
 
 void HandleSwapPrimaryDisplay() {
   base::RecordAction(UserMetricsAction("Accel_Swap_Primary_Display"));
   Shell::GetInstance()->display_configuration_controller()->SetPrimaryDisplayId(
       ScreenUtil::GetSecondaryDisplay().id(), true /* user_action */);
 }
 
 bool CanHandleCycleUser() {
   Shell* shell = Shell::GetInstance();
   return shell->delegate()->IsMultiProfilesEnabled() &&
-      shell->session_state_delegate()->NumberOfLoggedInUsers() > 1;
+         shell->session_state_delegate()->NumberOfLoggedInUsers() > 1;
 }
 
 void HandleCycleUser(SessionStateDelegate::CycleUser cycle_user) {
   MultiProfileUMA::RecordSwitchActiveUser(
       MultiProfileUMA::SWITCH_ACTIVE_USER_BY_ACCELERATOR);
   switch (cycle_user) {
     case SessionStateDelegate::CYCLE_TO_NEXT_USER:
       base::RecordAction(UserMetricsAction("Accel_Switch_To_Next_User"));
       break;
     case SessionStateDelegate::CYCLE_TO_PREVIOUS_USER:
@@ skipping 82 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // AcceleratorController, public:
 
 AcceleratorController::AcceleratorController()
     : accelerator_manager_(new ui::AcceleratorManager),
       accelerator_history_(new ui::AcceleratorHistory) {
   Init();
 }
 
-AcceleratorController::~AcceleratorController() {
-}
+AcceleratorController::~AcceleratorController() {}
 
 void AcceleratorController::Register(const ui::Accelerator& accelerator,
                                      ui::AcceleratorTarget* target) {
-  accelerator_manager_->Register(accelerator,
-                                 ui::AcceleratorManager::kNormalPriority,
-                                 target);
+  accelerator_manager_->Register(
+      accelerator, ui::AcceleratorManager::kNormalPriority, target);
 }
 
 void AcceleratorController::Unregister(const ui::Accelerator& accelerator,
                                        ui::AcceleratorTarget* target) {
   accelerator_manager_->Unregister(accelerator, target);
 }
 
 void AcceleratorController::UnregisterAll(ui::AcceleratorTarget* target) {
   accelerator_manager_->UnregisterAll(target);
 }
@@ skipping 174 matching lines @@
 }
 
 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);
-    accelerators_.insert(
-        std::make_pair(accelerator, accelerators[i].action));
+    accelerators_.insert(std::make_pair(accelerator, accelerators[i].action));
   }
 }
 
 void AcceleratorController::RegisterDeprecatedAccelerators() {
 #if defined(OS_CHROMEOS)
   for (size_t i = 0; i < kDeprecatedAcceleratorsDataLength; ++i) {
     const DeprecatedAcceleratorData* data = &kDeprecatedAcceleratorsData[i];
     actions_with_deprecations_[data->action] = data;
   }
 
@@ skipping 348 matching lines @@
     case KEYBOARD_BRIGHTNESS_DOWN:
       HandleKeyboardBrightnessDown(keyboard_brightness_control_delegate_.get(),
                                    accelerator);
       break;
     case KEYBOARD_BRIGHTNESS_UP:
       HandleKeyboardBrightnessUp(keyboard_brightness_control_delegate_.get(),
                                  accelerator);
       break;
     case LOCK_PRESSED:
     case LOCK_RELEASED:
-      Shell::GetInstance()->power_button_controller()->
-          OnLockButtonEvent(action == LOCK_PRESSED, base::TimeTicks());
+      Shell::GetInstance()->power_button_controller()->OnLockButtonEvent(
+          action == LOCK_PRESSED, base::TimeTicks());
       break;
     case LOCK_SCREEN:
       HandleLock();
       break;
     case OPEN_CROSH:
       HandleCrosh();
       break;
     case OPEN_FILE_MANAGER:
       HandleFileManager();
       break;
     case OPEN_GET_HELP:
       HandleGetHelp();
       break;
     case POWER_PRESSED:  // fallthrough
     case POWER_RELEASED:
       if (!base::SysInfo::IsRunningOnChromeOS()) {
         // There is no powerd, the Chrome OS power manager, in linux desktop,
         // so call the PowerButtonController here.
-        Shell::GetInstance()->power_button_controller()->
-            OnPowerButtonEvent(action == POWER_PRESSED, base::TimeTicks());
+        Shell::GetInstance()->power_button_controller()->OnPowerButtonEvent(
+            action == POWER_PRESSED, base::TimeTicks());
       }
       // We don't do anything with these at present on the device,
       // (power button events are reported to us from powerm via
       // D-BUS), but we consume them to prevent them from getting
       // passed to apps -- see http://crbug.com/146609.
       break;
     case SUSPEND:
       HandleSuspend();
       break;
     case SWAP_PRIMARY_DISPLAY:
@@ skipping 91 matching lines @@
 }
 
 void AcceleratorController::SetKeyboardBrightnessControlDelegate(
     std::unique_ptr<KeyboardBrightnessControlDelegate>
         keyboard_brightness_control_delegate) {
   keyboard_brightness_control_delegate_ =
       std::move(keyboard_brightness_control_delegate);
 }
 
 }  // namespace ash