Record user actions for Ash accelerators.

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 <iostream>
 #include <string>
@@ skipping 74 matching lines @@
 
 bool DebugShortcutsEnabled() {
 #if defined(NDEBUG)
   return CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshDebugShortcuts);
 #else
   return true;
 #endif
 }
 
+void HandleAddRemoveDisplay() {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Add_Remove_Display"));
+  Shell::GetInstance()->display_manager()->AddRemoveDisplay();
+}
+
 void HandleCycleBackwardMRU(const ui::Accelerator& accelerator) {
   Shell* shell = Shell::GetInstance();
 
   if (accelerator.key_code() == ui::VKEY_TAB)
     content::RecordAction(content::UserMetricsAction("Accel_PrevWindow_Tab"));
 
   if (switches::UseOverviewMode()) {
     shell->window_selector_controller()->HandleCycleWindow(
         WindowSelector::BACKWARD);
     return;
@@ skipping 25 matching lines @@
   if (switches::UseOverviewMode()) {
     content::RecordAction(content::UserMetricsAction("Accel_Overview_F5"));
     shell->window_selector_controller()->ToggleOverview();
     return;
   }
   if (accelerator.key_code() == ui::VKEY_MEDIA_LAUNCH_APP1)
     content::RecordAction(content::UserMetricsAction("Accel_NextWindow_F5"));
   shell->window_cycle_controller()->HandleLinearCycleWindow();
 }
 
+bool HandleDisableCapsLock(ui::KeyboardCode key_code,
+                           ui::EventType previous_event_type,
+                           ui::KeyboardCode previous_key_code) {
+  Shell* shell = Shell::GetInstance();
+
+  if (previous_event_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;
+  }
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Disable_Caps_Lock"));
+  if (shell->caps_lock_delegate()->IsCapsLockEnabled()) {
+    shell->caps_lock_delegate()->SetCapsLockEnabled(false);
+    return true;
+  }
+  return false;
+}
+
 bool HandleAccessibleFocusCycle(bool reverse) {
+  if (reverse) {
+    content::RecordAction(
+        content::UserMetricsAction("Accel_Accessible_Focus_Previous"));
+  } else {
+    content::RecordAction(
+        content::UserMetricsAction("Accel_Accessible_Focus_Next"));
+  }
+
   if (!Shell::GetInstance()->accessibility_delegate()->
       IsSpokenFeedbackEnabled()) {
     return false;
   }
   aura::Window* active_window = ash::wm::GetActiveWindow();
   if (!active_window)
     return false;
   views::Widget* widget =
       views::Widget::GetWidgetForNativeWindow(active_window);
   if (!widget)
     return false;
   views::FocusManager* focus_manager = widget->GetFocusManager();
   if (!focus_manager)
     return false;
   views::View* view = focus_manager->GetFocusedView();
   if (!view)
     return false;
   if (!strcmp(view->GetClassName(), views::WebView::kViewClassName))
     return false;
 
   focus_manager->AdvanceFocus(reverse);
   return true;
 }
 
+void HandleShowKeyboardOverlay() {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Show_Keyboard_Overlay"));
+  ash::Shell::GetInstance()->new_window_delegate()->ShowKeyboardOverlay();
+}
+
+void HandleShowMessageCenterBubble() {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Show_Message_Center_Bubble"));
+  internal::RootWindowController* controller =
+    internal::RootWindowController::ForTargetRootWindow();
+  internal::StatusAreaWidget* status_area_widget =
+    controller->shelf()->status_area_widget();
+  if (status_area_widget) {
+    WebNotificationTray* notification_tray =
+      status_area_widget->web_notification_tray();
+    if (notification_tray->visible())
+      notification_tray->ShowMessageCenterBubble();
+  }
+}
+
+bool HandleShowOak() {
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+        switches::kAshEnableOak)) {
+    oak::ShowOakWindowWithContext(Shell::GetPrimaryRootWindow());
+    return true;
+  }
+  return false;
+}
+
+bool HandleShowSystemTrayBubble() {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Show_System_Tray_Bubble"));
+  internal::RootWindowController* controller =
+    internal::RootWindowController::ForTargetRootWindow();
+  if (!controller->GetSystemTray()->HasSystemBubble()) {
+    controller->GetSystemTray()->ShowDefaultView(BUBBLE_CREATE_NEW);
+    return true;
+  }
+  return false;
+}
+
+void HandleShowTaskManager() {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Show_Task_Manager"));
+  Shell::GetInstance()->new_window_delegate()->ShowTaskManager();
+}
+
 void HandleSilenceSpokenFeedback() {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Silence_Spoken_Feedback"));
+
   AccessibilityDelegate* delegate =
       Shell::GetInstance()->accessibility_delegate();
   if (!delegate->IsSpokenFeedbackEnabled())
     return;
   delegate->SilenceSpokenFeedback();
 }
 
 #if defined(OS_CHROMEOS)
-bool HandleLock() {
+bool HandleLock(ui::KeyboardCode key_code) {
   Shell::GetInstance()->session_state_delegate()->LockScreen();
   return true;
 }
 
 bool HandleFileManager() {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Open_File_Manager"));
+
   Shell::GetInstance()->new_window_delegate()->OpenFileManager();
   return true;
 }
 
+bool HandleFocusLauncher() {
+  Shell* shell = Shell::GetInstance();
+  content::RecordAction(content::UserMetricsAction("Accel_Focus_Launcher"));
+  return shell->focus_cycler()->FocusWidget(
+      Launcher::ForPrimaryDisplay()->shelf_widget());
+}
+
 bool HandleCrosh() {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Open_Crosh"));
+
   Shell::GetInstance()->new_window_delegate()->OpenCrosh();
   return true;
 }
 
+void HandleTakePartialScreenshot(ScreenshotDelegate* screenshot_delegate) {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Take_Partial_Screenshot"));
+  if (screenshot_delegate) {
+    ash::PartialScreenshotView::StartPartialScreenshot(
+        screenshot_delegate);
+  }
+}
+
+void HandleTakeScreenshot(ScreenshotDelegate* screenshot_delegate) {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Take_Screenshot"));
+  if (screenshot_delegate &&
+      screenshot_delegate->CanTakeScreenshot()) {
+    screenshot_delegate->HandleTakeScreenshotForAllRootWindows();
+  }
+}
+
+bool HandleToggleAppList(ui::KeyboardCode key_code,
+                         ui::EventType previous_event_type,
+                         ui::KeyboardCode previous_key_code,
+                         const ui::Accelerator& accelerator) {
+  // If something else was pressed between the Search key (LWIN)
+  // being pressed and released, then ignore the release of the
+  // Search key.
+  if (key_code == ui::VKEY_LWIN &&
+      (previous_event_type == ui::ET_KEY_RELEASED ||
+       previous_key_code != ui::VKEY_LWIN))
+    return false;
+  if (key_code == ui::VKEY_LWIN)
+    content::RecordAction(content::UserMetricsAction("Accel_Search_LWin"));
+  // When spoken feedback is enabled, we should neither toggle the list nor
+  // consume the key since Search+Shift is one of the shortcuts the a11y
+  // feature uses. crbug.com/132296
+  DCHECK_EQ(ui::VKEY_LWIN, accelerator.key_code());
+  if (Shell::GetInstance()->accessibility_delegate()->
+      IsSpokenFeedbackEnabled())
+    return false;
+  ash::Shell::GetInstance()->ToggleAppList(NULL);
+  return true;
+}
+
+bool HandleToggleCapsLock(ui::KeyboardCode key_code,
+                          ui::EventType previous_event_type,
+                          ui::KeyboardCode previous_key_code) {
+  Shell* shell = Shell::GetInstance();
+  if (key_code == ui::VKEY_LWIN) {
+    // If something else was pressed between the Search key (LWIN)
+    // being pressed and released, then ignore the release of the
+    // Search key.
+    // TODO(danakj): Releasing Alt first breaks this: crbug.com/166495
+    if (previous_event_type == ui::ET_KEY_RELEASED ||
+        previous_key_code != ui::VKEY_LWIN)
+      return false;
+  }
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Toggle_Caps_Lock"));
+  shell->caps_lock_delegate()->ToggleCapsLock();
+  return true;
+}
+
+void HandleToggleMirrorMode() {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Toggle_Mirror_Mode"));
+  Shell::GetInstance()->display_controller()->ToggleMirrorMode();
+}
+
 bool HandleToggleSpokenFeedback() {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Toggle_Spoken_Feedback"));
+
   Shell::GetInstance()->accessibility_delegate()->
       ToggleSpokenFeedback(A11Y_NOTIFICATION_SHOW);
   return true;
 }
 
-bool SwitchToNextUser() {
+bool HandleTouchHudClear() {
+  internal::RootWindowController* controller =
+      internal::RootWindowController::ForTargetRootWindow();
+  if (controller->touch_hud_debug()) {
+    controller->touch_hud_debug()->Clear();
+    return true;
+  }
+  return false;
+}
+
+bool HandleTouchHudModeChange() {
+  internal::RootWindowController* controller =
+      internal::RootWindowController::ForTargetRootWindow();
+  if (controller->touch_hud_debug()) {
+    controller->touch_hud_debug()->ChangeToNextMode();
+    return true;
+  }
+  return false;
+}
+
+void HandleTouchHudProjectToggle() {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Touch_Hud_Clear"));
+  bool enabled = Shell::GetInstance()->is_touch_hud_projection_enabled();
+  Shell::GetInstance()->SetTouchHudProjectionEnabled(!enabled);
+}
+
+bool HandleSwitchToNextUser() {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Switch_To_Next_User"));
+
   if (!Shell::GetInstance()->delegate()->IsMultiProfilesEnabled())
     return false;
   ash::SessionStateDelegate* delegate =
       ash::Shell::GetInstance()->session_state_delegate();
   if (delegate->NumberOfLoggedInUsers() <= 1)
     return false;
   MultiProfileUMA::RecordSwitchActiveUser(
       MultiProfileUMA::SWITCH_ACTIVE_USER_BY_ACCELERATOR);
   delegate->SwitchActiveUserToNext();
   return true;
 }
 
 #endif  // defined(OS_CHROMEOS)
 
 bool HandleRotatePaneFocus(Shell::Direction direction) {
   Shell* shell = Shell::GetInstance();
   switch (direction) {
-    case Shell::FORWARD:
+    // TODO(stevet): Not sure if this is the same as IDC_FOCUS_NEXT_PANE.
+    case Shell::FORWARD: {
+      content::RecordAction(
+          content::UserMetricsAction("Accel_Focus_Next_Pane"));
       shell->focus_cycler()->RotateFocus(internal::FocusCycler::FORWARD);
       break;
-    case Shell::BACKWARD:
+    }
+    case Shell::BACKWARD: {
+      content::RecordAction(
+          content::UserMetricsAction("Accel_Focus_Previous_Pane"));
       shell->focus_cycler()->RotateFocus(internal::FocusCycler::BACKWARD);
       break;
+    }
   }
   return true;
 }
 
 // Rotate the active window.
 bool HandleRotateActiveWindow() {
+  content::RecordAction(
+      content::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()->StartAnimation(
         new ui::LayerAnimationSequence(
@@ skipping 16 matching lines @@
   NOTREACHED() << "Unknown rotation:" << current;
   return gfx::Display::ROTATE_0;
 }
 
 bool HandleScaleUI(bool up) {
   internal::DisplayManager* display_manager =
       Shell::GetInstance()->display_manager();
   int64 display_id = display_manager->GetDisplayIdForUIScaling();
   if (display_id == gfx::Display::kInvalidDisplayID)
     return false;
+
+  if (up) {
+    content::RecordAction(
+        content::UserMetricsAction("Accel_Scale_Ui_Up"));
+  } else {
+      content::RecordAction(
+          content::UserMetricsAction("Accel_Scale_Ui_Down"));
+  }
+
   const DisplayInfo& display_info = display_manager->GetDisplayInfo(display_id);
   float next_scale =
       internal::DisplayManager::GetNextUIScale(display_info, up);
   display_manager->SetDisplayUIScale(display_id, next_scale);
   return true;
 }
 
 bool HandleScaleReset() {
   internal::DisplayManager* display_manager =
       Shell::GetInstance()->display_manager();
   int64 display_id = display_manager->GetDisplayIdForUIScaling();
   if (display_id == gfx::Display::kInvalidDisplayID)
     return false;
+
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Scale_Ui_Reset"));
+
   display_manager->SetDisplayUIScale(display_id, 1.0f);
   return true;
 }
 
+void HandleSwapPrimaryDisplay() {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Swap_Primary_Display"));
+  Shell::GetInstance()->display_controller()->SwapPrimaryDisplay();
+}
+
+void HandleRestoreTab() {
+  content::RecordAction(content::UserMetricsAction("Accel_Restore_Tab"));
+  Shell::GetInstance()->new_window_delegate()->RestoreTab();
+}
+
 // Rotates the screen.
 bool HandleRotateScreen() {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Rotate_Window"));
   gfx::Point point = Shell::GetScreen()->GetCursorScreenPoint();
   gfx::Display display = Shell::GetScreen()->GetDisplayNearestPoint(point);
   const DisplayInfo& display_info =
       Shell::GetInstance()->display_manager()->GetDisplayInfo(display.id());
   Shell::GetInstance()->display_manager()->SetDisplayRotation(
       display.id(), GetNextRotation(display_info.rotation()));
   return true;
 }
 
 bool HandleToggleRootWindowFullScreen() {
@@ skipping 33 matching lines @@
 bool HandleMediaPlayPause() {
   Shell::GetInstance()->media_delegate()->HandleMediaPlayPause();
   return true;
 }
 
 bool HandleMediaPrevTrack() {
   Shell::GetInstance()->media_delegate()->HandleMediaPrevTrack();
   return true;
 }
 
+bool HandleNewIncognitoWindow() {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_New_Incognito_Window"));
+  bool incognito_allowed =
+    Shell::GetInstance()->delegate()->IsIncognitoAllowed();
+  if (incognito_allowed)
+    Shell::GetInstance()->new_window_delegate()->NewWindow(
+        true /* is_incognito */);
+  return incognito_allowed;
+}
+
+void HandleNewTab(ui::KeyboardCode key_code) {
+  if (key_code == ui::VKEY_T)
+    content::RecordAction(content::UserMetricsAction("Accel_NewTab_T"));
+  Shell::GetInstance()->new_window_delegate()->NewTab();
+}
+
+void HandleNewWindow() {
+  content::RecordAction(content::UserMetricsAction("Accel_New_Window"));
+  Shell::GetInstance()->new_window_delegate()->NewWindow(
+      false /* is_incognito */);
+}
+
+void HandleOpenFeedbackPage() {
+  content::RecordAction(
+      content::UserMetricsAction("Accel_Open_Feedback_Page"));
+  ash::Shell::GetInstance()->new_window_delegate()->OpenFeedbackPage();
+}
+
 bool HandlePrintLayerHierarchy() {
   aura::Window::Windows root_windows = Shell::GetAllRootWindows();
   for (size_t i = 0; i < root_windows.size(); ++i) {
     ui::PrintLayerHierarchy(
         root_windows[i]->layer(),
         root_windows[i]->GetDispatcher()->GetLastMouseLocationInRoot());
   }
   return true;
 }
 
@@ skipping 225 matching lines @@
       HandleCycleBackwardMRU(accelerator);
       return true;
     case CYCLE_FORWARD_MRU:
       HandleCycleForwardMRU(accelerator);
       return true;
     case CYCLE_LINEAR:
       HandleCycleLinear(accelerator);
       return true;
 #if defined(OS_CHROMEOS)
     case ADD_REMOVE_DISPLAY:
-      Shell::GetInstance()->display_manager()->AddRemoveDisplay();
+      HandleAddRemoveDisplay();
       return true;
     case TOGGLE_MIRROR_MODE:
-      Shell::GetInstance()->display_controller()->ToggleMirrorMode();
+      HandleToggleMirrorMode();
       return true;
     case LOCK_SCREEN:
-      if (key_code == ui::VKEY_L)
-        content::RecordAction(content::UserMetricsAction("Accel_LockScreen_L"));
-      return HandleLock();
+      return HandleLock(key_code);
     case OPEN_FILE_MANAGER:
       return HandleFileManager();
     case OPEN_CROSH:
       return HandleCrosh();
     case SILENCE_SPOKEN_FEEDBACK:
       HandleSilenceSpokenFeedback();
       break;
     case SWAP_PRIMARY_DISPLAY:
-      Shell::GetInstance()->display_controller()->SwapPrimaryDisplay();
+      HandleSwapPrimaryDisplay();
       return true;
     case SWITCH_TO_NEXT_USER:
-      return SwitchToNextUser();
+      return HandleSwitchToNextUser();
     case TOGGLE_SPOKEN_FEEDBACK:
       return HandleToggleSpokenFeedback();
     case TOGGLE_WIFI:
       Shell::GetInstance()->system_tray_notifier()->NotifyRequestToggleWifi();
       return true;
-    case TOUCH_HUD_CLEAR: {
-      internal::RootWindowController* controller =
-          internal::RootWindowController::ForTargetRootWindow();
-      if (controller->touch_hud_debug()) {
-        controller->touch_hud_debug()->Clear();
-        return true;
-      }
-      return false;
-    }
-    case TOUCH_HUD_MODE_CHANGE: {
-      internal::RootWindowController* controller =
-          internal::RootWindowController::ForTargetRootWindow();
-      if (controller->touch_hud_debug()) {
-        controller->touch_hud_debug()->ChangeToNextMode();
-        return true;
-      }
-      return false;
-    }
-    case TOUCH_HUD_PROJECTION_TOGGLE: {
-      bool enabled = Shell::GetInstance()->is_touch_hud_projection_enabled();
-      Shell::GetInstance()->SetTouchHudProjectionEnabled(!enabled);
+    case TOUCH_HUD_CLEAR:
+      return HandleTouchHudClear();
+    case TOUCH_HUD_MODE_CHANGE:
+      return HandleTouchHudModeChange();
+    case TOUCH_HUD_PROJECTION_TOGGLE:
+      HandleTouchHudProjectToggle();
       return true;
-    }
     case DISABLE_GPU_WATCHDOG:
       content::GpuDataManager::GetInstance()->DisableGpuWatchdog();
       return true;
 #endif
     case OPEN_FEEDBACK_PAGE:
-      ash::Shell::GetInstance()->new_window_delegate()->OpenFeedbackPage();
+      HandleOpenFeedbackPage();
       return true;
     case EXIT:
       // UMA metrics are recorded in the handler.
       exit_warning_handler_.HandleAccelerator();
       return true;
-    case NEW_INCOGNITO_WINDOW: {
-        bool incognito_allowed =
-            Shell::GetInstance()->delegate()->IsIncognitoAllowed();
-        if (incognito_allowed)
-          Shell::GetInstance()->new_window_delegate()->NewWindow(
-              true /* is_incognito */);
-        return incognito_allowed;
-    }
+    case NEW_INCOGNITO_WINDOW:
+      return HandleNewIncognitoWindow();
     case NEW_TAB:
-      if (key_code == ui::VKEY_T)
-        content::RecordAction(content::UserMetricsAction("Accel_NewTab_T"));
-      Shell::GetInstance()->new_window_delegate()->NewTab();
+      HandleNewTab(key_code);
       return true;
     case NEW_WINDOW:
-      Shell::GetInstance()->new_window_delegate()->NewWindow(
-          false /* is_incognito */);
+      HandleNewWindow();
       return true;
     case RESTORE_TAB:
-      Shell::GetInstance()->new_window_delegate()->RestoreTab();
+      HandleRestoreTab();
       return true;
     case TAKE_SCREENSHOT:
-      if (screenshot_delegate_.get() &&
-          screenshot_delegate_->CanTakeScreenshot()) {
-        screenshot_delegate_->HandleTakeScreenshotForAllRootWindows();
-      }
+      HandleTakeScreenshot(screenshot_delegate_.get());
       // Return true to prevent propagation of the key event.
       return true;
     case TAKE_PARTIAL_SCREENSHOT:
-      if (screenshot_delegate_) {
-        ash::PartialScreenshotView::StartPartialScreenshot(
-            screenshot_delegate_.get());
-      }
+      HandleTakePartialScreenshot(screenshot_delegate_.get());
       // Return true to prevent propagation of the key event because
       // this key combination is reserved for partial screenshot.
       return true;
     case TOGGLE_APP_LIST:
-      // If something else was pressed between the Search key (LWIN)
-      // being pressed and released, then ignore the release of the
-      // Search key.
-      if (key_code == ui::VKEY_LWIN &&
-          (previous_event_type == ui::ET_KEY_RELEASED ||
-           previous_key_code != ui::VKEY_LWIN))
-        return false;
-      if (key_code == ui::VKEY_LWIN)
-        content::RecordAction(content::UserMetricsAction("Accel_Search_LWin"));
-      // When spoken feedback is enabled, we should neither toggle the list nor
-      // consume the key since Search+Shift is one of the shortcuts the a11y
-      // feature uses. crbug.com/132296
-      DCHECK_EQ(ui::VKEY_LWIN, accelerator.key_code());
-      if (Shell::GetInstance()->accessibility_delegate()->
-          IsSpokenFeedbackEnabled())
-        return false;
-      ash::Shell::GetInstance()->ToggleAppList(NULL);
-      return true;
+      return HandleToggleAppList(
+          key_code, previous_event_type, previous_key_code, accelerator);
     case DISABLE_CAPS_LOCK:
-      if (previous_event_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;
-      }
-      if (shell->caps_lock_delegate()->IsCapsLockEnabled()) {
-        shell->caps_lock_delegate()->SetCapsLockEnabled(false);
-        return true;
-      }
-      return false;
+      return HandleDisableCapsLock(
+          key_code, previous_event_type, previous_key_code);
     case TOGGLE_CAPS_LOCK:
-      if (key_code == ui::VKEY_LWIN) {
-        // If something else was pressed between the Search key (LWIN)
-        // being pressed and released, then ignore the release of the
-        // Search key.
-        // TODO(danakj): Releasing Alt first breaks this: crbug.com/166495
-        if (previous_event_type == ui::ET_KEY_RELEASED ||
-            previous_key_code != ui::VKEY_LWIN)
-          return false;
-      }
-      shell->caps_lock_delegate()->ToggleCapsLock();
-      return true;
+      return HandleToggleCapsLock(
+          key_code, previous_event_type, previous_key_code);
     case BRIGHTNESS_DOWN:
       if (brightness_control_delegate_)
         return brightness_control_delegate_->HandleBrightnessDown(accelerator);
       break;
     case BRIGHTNESS_UP:
       if (brightness_control_delegate_)
         return brightness_control_delegate_->HandleBrightnessUp(accelerator);
       break;
     case KEYBOARD_BRIGHTNESS_DOWN:
       if (keyboard_brightness_control_delegate_)
@@ skipping 13 matching lines @@
     case VOLUME_DOWN: {
       ash::VolumeControlDelegate* volume_delegate =
           shell->system_tray_delegate()->GetVolumeControlDelegate();
       return volume_delegate && volume_delegate->HandleVolumeDown(accelerator);
     }
     case VOLUME_UP: {
       ash::VolumeControlDelegate* volume_delegate =
           shell->system_tray_delegate()->GetVolumeControlDelegate();
       return volume_delegate && volume_delegate->HandleVolumeUp(accelerator);
     }
-    case FOCUS_LAUNCHER:
-      return shell->focus_cycler()->FocusWidget(
-          Launcher::ForPrimaryDisplay()->shelf_widget());
-    case FOCUS_NEXT_PANE:
+    case FOCUS_LAUNCHER: {
+      return HandleFocusLauncher();
+    }

[James Cook, 2013/11/26 21:40:59]

nit: I don't think you need the extra braces and it makes this too-long switch
statement even longer.

[SteveT, 2013/11/27 17:56:50]

Done here and below.

+    case FOCUS_NEXT_PANE: {
       return HandleRotatePaneFocus(Shell::FORWARD);
-    case FOCUS_PREVIOUS_PANE:
+    }
+    case FOCUS_PREVIOUS_PANE: {
       return HandleRotatePaneFocus(Shell::BACKWARD);
+    }
     case SHOW_KEYBOARD_OVERLAY:
-      ash::Shell::GetInstance()->new_window_delegate()->ShowKeyboardOverlay();
+      HandleShowKeyboardOverlay();
       return true;
     case SHOW_OAK:
-      if (CommandLine::ForCurrentProcess()->HasSwitch(
-              switches::kAshEnableOak)) {
-        oak::ShowOakWindowWithContext(Shell::GetPrimaryRootWindow());
-        return true;
-      }
+      return HandleShowOak();
+    case SHOW_SYSTEM_TRAY_BUBBLE:
+      return HandleShowSystemTrayBubble();
+    case SHOW_MESSAGE_CENTER_BUBBLE:
+      HandleShowMessageCenterBubble();
       break;
-    case SHOW_SYSTEM_TRAY_BUBBLE: {
-      internal::RootWindowController* controller =
-          internal::RootWindowController::ForTargetRootWindow();
-      if (!controller->GetSystemTray()->HasSystemBubble()) {
-        controller->GetSystemTray()->ShowDefaultView(BUBBLE_CREATE_NEW);
-        return true;
-      }
-      break;
-    }
-    case SHOW_MESSAGE_CENTER_BUBBLE: {
-      internal::RootWindowController* controller =
-          internal::RootWindowController::ForTargetRootWindow();
-      internal::StatusAreaWidget* status_area_widget =
-          controller->shelf()->status_area_widget();
-      if (status_area_widget) {
-        WebNotificationTray* notification_tray =
-            status_area_widget->web_notification_tray();
-        if (notification_tray->visible())
-          notification_tray->ShowMessageCenterBubble();
-      }
-      break;
-    }
     case SHOW_TASK_MANAGER:
-      Shell::GetInstance()->new_window_delegate()->ShowTaskManager();
+      HandleShowTaskManager();
       return true;
     case NEXT_IME:
       // This check is necessary e.g. not to process the Shift+Alt+
       // ET_KEY_RELEASED accelerator for Chrome OS (see ash/accelerators/
       // accelerator_controller.cc) when Shift+Alt+Tab is pressed and then Tab
       // is released.
       if (previous_event_type == ui::ET_KEY_RELEASED &&
           // Workaround for crbug.com/139556. CJK IME users tend to press
           // Enter (or Space) and Shift+Alt almost at the same time to commit
           // an IME string and then switch from the IME to the English layout.
           // This workaround allows the user to trigger NEXT_IME even if the
           // user presses Shift+Alt before releasing Enter.
           // TODO(nona|mazda): Fix crbug.com/139556 in a cleaner way.
           previous_key_code != ui::VKEY_RETURN &&
           previous_key_code != ui::VKEY_SPACE) {
         // We totally ignore this accelerator.
         // TODO(mazda): Fix crbug.com/158217
         return false;
       }
+      content::RecordAction(
+          content::UserMetricsAction("Accel_Next_Ime"));
       if (ime_control_delegate_)
         return ime_control_delegate_->HandleNextIme();
       break;
     case PREVIOUS_IME:
+      content::RecordAction(
+          content::UserMetricsAction("Accel_Previous_Ime"));
       if (ime_control_delegate_)
         return ime_control_delegate_->HandlePreviousIme(accelerator);
       break;
     case PRINT_UI_HIERARCHIES:
       return HandlePrintUIHierarchies();
     case SWITCH_IME:
+      content::RecordAction(
+          content::UserMetricsAction("Accel_Switch_Ime"));
       if (ime_control_delegate_)
         return ime_control_delegate_->HandleSwitchIme(accelerator);
       break;
     case LAUNCH_APP_0:
+      content::RecordAction(
+          content::UserMetricsAction("Accel_Launch_App_0"));
       Launcher::ForPrimaryDisplay()->LaunchAppIndexAt(0);
       return true;
     case LAUNCH_APP_1:
+      content::RecordAction(
+          content::UserMetricsAction("Accel_Launch_App_1"));
       Launcher::ForPrimaryDisplay()->LaunchAppIndexAt(1);
       return true;
     case LAUNCH_APP_2:
+      content::RecordAction(
+          content::UserMetricsAction("Accel_Launch_App_2"));
       Launcher::ForPrimaryDisplay()->LaunchAppIndexAt(2);
       return true;
     case LAUNCH_APP_3:
+      content::RecordAction(
+          content::UserMetricsAction("Accel_Launch_App_3"));
       Launcher::ForPrimaryDisplay()->LaunchAppIndexAt(3);
       return true;
     case LAUNCH_APP_4:
+      content::RecordAction(
+          content::UserMetricsAction("Accel_Launch_App_4"));
       Launcher::ForPrimaryDisplay()->LaunchAppIndexAt(4);
       return true;
     case LAUNCH_APP_5:
+      content::RecordAction(
+          content::UserMetricsAction("Accel_Launch_App_5"));
       Launcher::ForPrimaryDisplay()->LaunchAppIndexAt(5);
       return true;
     case LAUNCH_APP_6:
+      content::RecordAction(
+          content::UserMetricsAction("Accel_Launch_App_6"));
       Launcher::ForPrimaryDisplay()->LaunchAppIndexAt(6);
       return true;
     case LAUNCH_APP_7:
+      content::RecordAction(
+          content::UserMetricsAction("Accel_Launch_App_7"));
       Launcher::ForPrimaryDisplay()->LaunchAppIndexAt(7);
       return true;
     case LAUNCH_LAST_APP:
+      content::RecordAction(
+          content::UserMetricsAction("Accel_Launch_Last_App"));
       Launcher::ForPrimaryDisplay()->LaunchAppIndexAt(-1);
       return true;
     case WINDOW_SNAP_LEFT:
     case WINDOW_SNAP_RIGHT: {
       wm::WindowState* window_state = wm::GetActiveWindowState();
       // Disable window snapping shortcut key for full screen window due to
       // http://crbug.com/135487.
       if (!window_state ||
           window_state->window()->type() != aura::client::WINDOW_TYPE_NORMAL ||
           window_state->IsFullscreen()) {
         break;
       }
 
+      if (action == WINDOW_SNAP_LEFT) {
+        content::RecordAction(
+            content::UserMetricsAction("Accel_Window_Snap_Left"));
+      } else {
+        content::RecordAction(
+            content::UserMetricsAction("Accel_Window_Snap_Right"));
+      }
+
       internal::SnapSizer::SnapWindow(window_state,
           action == WINDOW_SNAP_LEFT ? internal::SnapSizer::LEFT_EDGE :
                                        internal::SnapSizer::RIGHT_EDGE);
       return true;
     }
     case WINDOW_MINIMIZE:
       return accelerators::ToggleMinimized();
     case TOGGLE_FULLSCREEN: {
       if (key_code == ui::VKEY_MEDIA_LAUNCH_APP2) {
         content::RecordAction(
             content::UserMetricsAction("Accel_Fullscreen_F4"));
       }
       accelerators::ToggleFullscreen();
       return true;
     }
     case TOGGLE_MAXIMIZED: {
       accelerators::ToggleMaximized();
       return true;
     }
     case WINDOW_POSITION_CENTER: {
-      content::RecordAction(content::UserMetricsAction("Accel_Center"));
+      content::RecordAction(
+          content::UserMetricsAction("Accel_Window_Position_Center"));
       aura::Window* window = wm::GetActiveWindow();
       // Docked windows do not support centering and ignore accelerator.
       if (window && !wm::GetWindowState(window)->IsDocked()) {
         wm::CenterWindow(window);
         return true;
       }
       break;
     }
     case SCALE_UI_UP:
       return HandleScaleUI(true /* up */);
@@ skipping 114 matching lines @@
     keyboard_brightness_control_delegate) {
   keyboard_brightness_control_delegate_ =
       keyboard_brightness_control_delegate.Pass();
 }
 
 bool AcceleratorController::CanHandleAccelerators() const {
   return true;
 }
 
 }  // namespace ash