chromeos: Remove some IME methods from ash::SystemTrayDelegate

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 <utility>
 
 #include "ash/accelerators/accelerator_commands.h"
 #include "ash/accelerators/accelerator_controller_delegate.h"
 #include "ash/accelerators/debug_commands.h"
 #include "ash/accessibility_delegate.h"
 #include "ash/accessibility_types.h"
 #include "ash/focus_cycler.h"
-#include "ash/ime_control_delegate.h"
+#include "ash/ime/ime_switch_type.h"
 #include "ash/media_controller.h"
 #include "ash/multi_profile_uma.h"
 #include "ash/new_window_controller.h"
 #include "ash/resources/vector_icons/vector_icons.h"
 #include "ash/root_window_controller.h"
 #include "ash/rotator/window_rotation.h"
 #include "ash/session/session_controller.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shelf/wm_shelf.h"
 #include "ash/shell.h"
@@ skipping 35 matching lines @@
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/message_center/message_center.h"
 
 namespace ash {
 namespace {
 
 using base::UserMetricsAction;
+using chromeos::input_method::InputMethodManager;
 using message_center::Notification;
 
 // Identifier for the high contrast toggle accelerator notification.
 const char kHighContrastToggleAccelNotificationId[] =
     "chrome://settings/accessibility/highcontrast";
 
 // The notification delegate that will be used to open the keyboard shortcut
 // help page when the notification is clicked.
 class DeprecatedAcceleratorNotificationDelegate
     : public message_center::NotificationDelegate {
@@ skipping 83 matching lines @@
 }
 
 void RecordUmaHistogram(const char* histogram_name,
                         DeprecatedAcceleratorUsage sample) {
   auto* histogram = base::LinearHistogram::FactoryGet(
       histogram_name, 1, DEPRECATED_USAGE_COUNT, DEPRECATED_USAGE_COUNT + 1,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(sample);
 }
 
+void RecordImeSwitchByAccelerator() {
+  UMA_HISTOGRAM_ENUMERATION("InputMethod.ImeSwitch",
+                            ImeSwitchType::kAccelerator, ImeSwitchType::kCount);
+}
+
 void HandleCycleBackwardMRU(const ui::Accelerator& accelerator) {
   if (accelerator.key_code() == ui::VKEY_TAB)
     base::RecordAction(base::UserMetricsAction("Accel_PrevWindow_Tab"));
 
   Shell::Get()->window_cycle_controller()->HandleCycleWindow(
       WindowCycleController::BACKWARD);
 }
 
 void HandleCycleForwardMRU(const ui::Accelerator& accelerator) {
   if (accelerator.key_code() == ui::VKEY_TAB)
@@ skipping 60 matching lines @@
   if (accelerator.key_code() == ui::VKEY_T)
     base::RecordAction(UserMetricsAction("Accel_NewTab_T"));
   Shell::Get()->new_window_controller()->NewTab();
 }
 
 void HandleNewWindow() {
   base::RecordAction(UserMetricsAction("Accel_New_Window"));
   Shell::Get()->new_window_controller()->NewWindow(false /* is_incognito */);
 }
 
-bool CanHandleNextIme(ImeControlDelegate* ime_control_delegate) {
-  return ime_control_delegate && ime_control_delegate->CanCycleIme();
+bool CanCycleInputMethod() {
+  InputMethodManager* manager = InputMethodManager::Get();
+  DCHECK(manager);
+  if (!manager->GetActiveIMEState()) {
+    LOG(WARNING) << "Cannot cycle through input methods as they are not "
+                    "initialized yet.";
+    return false;
+  }
+  return manager->GetActiveIMEState()->CanCycleInputMethod();
 }
 
 bool CanHandleCycleMru(const ui::Accelerator& accelerator) {
   // Don't do anything when Alt+Tab is hit while a virtual keyboard is showing.
   // Touchscreen users have better window switching options. It would be
   // preferable if we could tell whether this event actually came from a virtual
   // keyboard, but there's no easy way to do so, thus we block Alt+Tab when the
   // virtual keyboard is showing, even if it came from a real keyboard. See
   // http://crbug.com/638269
   keyboard::KeyboardController* keyboard_controller =
       keyboard::KeyboardController::GetInstance();
   return !(keyboard_controller && keyboard_controller->keyboard_visible());
 }
 
-void HandleNextIme(ImeControlDelegate* ime_control_delegate) {
+void HandleNextIme() {
   base::RecordAction(UserMetricsAction("Accel_Next_Ime"));
-  ime_control_delegate->HandleNextIme();
+  RecordImeSwitchByAccelerator();
+  InputMethodManager::Get()->GetActiveIMEState()->SwitchToNextInputMethod();
 }
 
 void HandleOpenFeedbackPage() {
   base::RecordAction(UserMetricsAction("Accel_Open_Feedback_Page"));
   Shell::Get()->new_window_controller()->OpenFeedbackPage();
 }
 
-bool CanHandlePreviousIme(ImeControlDelegate* ime_control_delegate) {
-  return ime_control_delegate && ime_control_delegate->CanCycleIme();
-}
-
-void HandlePreviousIme(ImeControlDelegate* ime_control_delegate,
-                       const ui::Accelerator& accelerator) {
+void HandlePreviousIme(const ui::Accelerator& accelerator) {
   base::RecordAction(UserMetricsAction("Accel_Previous_Ime"));
-  if (accelerator.key_state() == ui::Accelerator::KeyState::PRESSED)
-    ime_control_delegate->HandlePreviousIme();
+  if (accelerator.key_state() == ui::Accelerator::KeyState::PRESSED) {
+    RecordImeSwitchByAccelerator();
+    InputMethodManager::Get()
+        ->GetActiveIMEState()
+        ->SwitchToPreviousInputMethod();
+  }
   // Else: consume the Ctrl+Space ET_KEY_RELEASED event but do not do anything.
 }
 
 void HandleRestoreTab() {
   base::RecordAction(UserMetricsAction("Accel_Restore_Tab"));
   Shell::Get()->new_window_controller()->RestoreTab();
 }
 
 // Rotate the active window.
 void HandleRotateActiveWindow() {
@@ skipping 46 matching lines @@
     tray->ShowDefaultView(BUBBLE_CREATE_NEW);
     tray->ActivateBubble();
   }
 }
 
 void HandleShowTaskManager() {
   base::RecordAction(UserMetricsAction("Accel_Show_Task_Manager"));
   Shell::Get()->new_window_controller()->ShowTaskManager();
 }
 
-bool CanHandleSwitchIme(ImeControlDelegate* ime_control_delegate,
-                        const ui::Accelerator& accelerator) {
-  return ime_control_delegate &&
-         ime_control_delegate->CanSwitchIme(accelerator);
+bool CanHandleSwitchIme(const ui::Accelerator& accelerator) {
+  InputMethodManager* manager = InputMethodManager::Get();
+  DCHECK(manager);
+  if (!manager->GetActiveIMEState()) {
+    LOG(WARNING) << "Cannot switch input methods as they are not "
+                    "initialized yet.";
+    return false;
+  }
+  return manager->GetActiveIMEState()->CanSwitchInputMethod(accelerator);
 }
 
-void HandleSwitchIme(ImeControlDelegate* ime_control_delegate,
-                     const ui::Accelerator& accelerator) {
+void HandleSwitchIme(const ui::Accelerator& accelerator) {
   base::RecordAction(UserMetricsAction("Accel_Switch_Ime"));
-  ime_control_delegate->HandleSwitchIme(accelerator);
+  RecordImeSwitchByAccelerator();
+  InputMethodManager::Get()->GetActiveIMEState()->SwitchInputMethod(
+      accelerator);
 }
 
 bool CanHandleToggleAppList(const ui::Accelerator& accelerator,
                             const ui::Accelerator& previous_accelerator) {
   if (accelerator.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.
     if (previous_accelerator.key_state() !=
             ui::Accelerator::KeyState::PRESSED ||
@@ skipping 353 matching lines @@
     return true;
   }
   return false;
 }
 
 AcceleratorController::AcceleratorProcessingRestriction
 AcceleratorController::GetCurrentAcceleratorRestriction() {
   return GetAcceleratorProcessingRestriction(-1);
 }
 
-void AcceleratorController::SetImeControlDelegate(
-    std::unique_ptr<ImeControlDelegate> ime_control_delegate) {
-  ime_control_delegate_ = std::move(ime_control_delegate);
-}
-
 bool AcceleratorController::ShouldCloseMenuAndRepostAccelerator(
     const ui::Accelerator& accelerator) const {
   auto itr = accelerators_.find(accelerator);
   if (itr == accelerators_.end())
     return false;  // Menu shouldn't be closed for an invalid accelerator.
 
   AcceleratorAction action = itr->second;
   return actions_keeping_menu_open_.count(action) == 0;
 }
 
@@ skipping 152 matching lines @@
     case DEBUG_TOGGLE_WALLPAPER_MODE:
     case DEBUG_TRIGGER_CRASH:
       return debug::DebugAcceleratorsEnabled();
     case DISABLE_CAPS_LOCK:
       return CanHandleDisableCapsLock(previous_accelerator);
     case LOCK_SCREEN:
       return CanHandleLock();
     case NEW_INCOGNITO_WINDOW:
       return CanHandleNewIncognitoWindow();
     case NEXT_IME:
-      return CanHandleNextIme(ime_control_delegate_.get());
+      return CanCycleInputMethod();
     case PREVIOUS_IME:
-      return CanHandlePreviousIme(ime_control_delegate_.get());
+      return CanCycleInputMethod();
     case SHOW_MESSAGE_CENTER_BUBBLE:
       return CanHandleShowMessageCenterBubble();
     case SHOW_STYLUS_TOOLS:
       return CanHandleShowStylusTools();
     case SWITCH_IME:
-      return CanHandleSwitchIme(ime_control_delegate_.get(), accelerator);
+      return CanHandleSwitchIme(accelerator);
     case SWITCH_TO_PREVIOUS_USER:
     case SWITCH_TO_NEXT_USER:
       return CanHandleCycleUser();
     case TOGGLE_APP_LIST:
       return CanHandleToggleAppList(accelerator, previous_accelerator);
     case TOGGLE_CAPS_LOCK:
       return CanHandleToggleCapsLock(accelerator, previous_accelerator);
     case WINDOW_CYCLE_SNAP_LEFT:
     case WINDOW_CYCLE_SNAP_RIGHT:
       return CanHandleWindowSnap();
@@ skipping 170 matching lines @@
     case NEW_INCOGNITO_WINDOW:
       HandleNewIncognitoWindow();
       break;
     case NEW_TAB:
       HandleNewTab(accelerator);
       break;
     case NEW_WINDOW:
       HandleNewWindow();
       break;
     case NEXT_IME:
-      HandleNextIme(ime_control_delegate_.get());
+      HandleNextIme();
       break;
     case OPEN_CROSH:
       HandleCrosh();
       break;
     case OPEN_FEEDBACK_PAGE:
       HandleOpenFeedbackPage();
       break;
     case OPEN_FILE_MANAGER:
       HandleFileManager();
       break;
     case OPEN_GET_HELP:
       HandleGetHelp();
       break;
     case PREVIOUS_IME:
-      HandlePreviousIme(ime_control_delegate_.get(), accelerator);
+      HandlePreviousIme(accelerator);
       break;
     case PRINT_UI_HIERARCHIES:
       debug::PrintUIHierarchies();
       break;
     case RESTORE_TAB:
       HandleRestoreTab();
       break;
     case ROTATE_WINDOW:
       HandleRotateActiveWindow();
       break;
@@ skipping 12 matching lines @@
     case SHOW_SYSTEM_TRAY_BUBBLE:
       HandleShowSystemTrayBubble();
       break;
     case SHOW_TASK_MANAGER:
       HandleShowTaskManager();
       break;
     case SUSPEND:
       HandleSuspend();
       break;
     case SWITCH_IME:
-      HandleSwitchIme(ime_control_delegate_.get(), accelerator);
+      HandleSwitchIme(accelerator);
       break;
     case SWITCH_TO_NEXT_USER:
       HandleCycleUser(CycleUserDirection::NEXT);
       break;
     case SWITCH_TO_PREVIOUS_USER:
       HandleCycleUser(CycleUserDirection::PREVIOUS);
       break;
     case TOGGLE_APP_LIST:
       HandleToggleAppList(accelerator);
       break;
@@ skipping 124 matching lines @@
       data->uma_histogram_name, data->notification_message_id,
       data->old_shortcut_id, data->new_shortcut_id);
 
   if (!data->deprecated_enabled)
     return AcceleratorProcessingStatus::STOP;
 
   return AcceleratorProcessingStatus::PROCEED;
 }
 
 }  // namespace ash