Deprecating high-conflict 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 <string>
 
@@ skipping 20 matching lines @@
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_delegate.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.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/system_notifier.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/system/tray/system_tray_notifier.h"
 #include "ash/system/web_notification/web_notification_tray.h"
 #include "ash/touch/touch_hud_debug.h"
 #include "ash/utility/partial_screenshot_controller.h"
 #include "ash/volume_control_delegate.h"
 #include "ash/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/wm/mru_window_tracker.h"
 #include "ash/wm/overview/window_selector_controller.h"
 #include "ash/wm/power_button_controller.h"
 #include "ash/wm/window_cycle_controller.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/wm_event.h"
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/metrics/user_metrics.h"
 #include "ui/aura/env.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/accelerators/accelerator_manager.h"
+#include "ui/base/l10n/l10n_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/screen.h"
+#include "ui/message_center/message_center.h"
+#include "ui/message_center/notification.h"
+#include "ui/message_center/notifier_settings.h"
 #include "ui/views/controls/webview/webview.h"
 
 #if defined(OS_CHROMEOS)
 #include "ash/system/chromeos/keyboard_brightness_controller.h"
 #include "base/sys_info.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 {
 
 using base::UserMetricsAction;
 
+inline ui::Accelerator CreateAccelerator(ui::KeyboardCode keycode,
+                                         int modifiers,
+                                         bool trigger_on_press) {
+  ui::Accelerator accelerator(keycode, modifiers);
+  accelerator.set_type(trigger_on_press ? ui::ET_KEY_PRESSED
+                                        : ui::ET_KEY_RELEASED);
+  return accelerator;
+}
+
+void ShowDeprecatedAcceleratorNotification(int message_id) {
+  const base::string16 message = l10n_util::GetStringUTF16(message_id);
+  scoped_ptr<message_center::Notification> notification(
+      new message_center::Notification(
+          message_center::NOTIFICATION_TYPE_SIMPLE,
+          kDeprecatedAcceleratorNotificationId, base::string16(), message,
+          gfx::Image(), base::string16(),
+          message_center::NotifierId(
+              message_center::NotifierId::SYSTEM_COMPONENT,
+              system_notifier::kNotifierAcceleratorController),
+          message_center::RichNotificationData(), nullptr));
+  message_center::MessageCenter::Get()->AddNotification(notification.Pass());
+}
+
+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);
+}
+
 bool CanHandleAccessibleFocusCycle() {
   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);
@@ skipping 659 matching lines @@
       ime_control_delegate_->RemapAccelerator(accelerator) : accelerator;
 
   std::map<ui::Accelerator, AcceleratorAction>::const_iterator iter =
       accelerators_.find(remapped_accelerator);
   if (iter == accelerators_.end())
     return false;  // not an accelerator.
 
   return reserved_actions_.find(iter->second) != reserved_actions_.end();
 }
 
+bool AcceleratorController::IsDeprecated(
+    const ui::Accelerator& accelerator) const {
+  return deprecated_accelerators_.count(accelerator) != 0;
+}
+
 bool AcceleratorController::PerformActionIfEnabled(AcceleratorAction action) {
   if (CanPerformAction(action, ui::Accelerator())) {
     PerformAction(action, ui::Accelerator());
     return true;
   }
   return false;
 }
 
 AcceleratorController::AcceleratorProcessingRestriction
 AcceleratorController::GetCurrentAcceleratorRestriction() {
@@ skipping 55 matching lines @@
     reserved_actions_.insert(kReservedActions[i]);
   for (size_t i = 0; i < kNonrepeatableActionsLength; ++i)
     nonrepeatable_actions_.insert(kNonrepeatableActions[i]);
   for (size_t i = 0; i < kActionsAllowedInAppModeLength; ++i)
     actions_allowed_in_app_mode_.insert(kActionsAllowedInAppMode[i]);
   for (size_t i = 0; i < kActionsNeedingWindowLength; ++i)
     actions_needing_window_.insert(kActionsNeedingWindow[i]);
 
   RegisterAccelerators(kAcceleratorData, kAcceleratorDataLength);
 
+  RegisterDeprecatedAccelerators(kDeprecatedAccelerators,
+                                 kDeprecatedAcceleratorsLength);
+
   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(accelerators[i].keycode,
-                                accelerators[i].modifiers);
-    accelerator.set_type(accelerators[i].trigger_on_press ?
-                         ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED);
+    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));
   }
 }
 
+void AcceleratorController::RegisterDeprecatedAccelerators(
+    const DeprecatedAcceleratorData deprecated_accelerators[],
+    size_t length) {
+  for (size_t i = 0; i < length; ++i) {
+    const DeprecatedAcceleratorData* data = &deprecated_accelerators[i];
+    const AcceleratorAction action = data->deprecated_accelerator.action;
+    const ui::Accelerator deprecated_accelerator =
+        CreateAccelerator(data->deprecated_accelerator.keycode,
+                          data->deprecated_accelerator.modifiers,
+                          data->deprecated_accelerator.trigger_on_press);
+
+    Register(deprecated_accelerator, this);
+    actions_with_deprecations_[action] = data;
+    accelerators_[deprecated_accelerator] = action;
+    deprecated_accelerators_.insert(deprecated_accelerator);
+  }
+}
+
 bool AcceleratorController::CanPerformAction(
     AcceleratorAction action,
     const ui::Accelerator& accelerator) {
   if (nonrepeatable_actions_.find(action) != nonrepeatable_actions_.end() &&
       accelerator.IsRepeat()) {
     return false;
   }
 
+  // Handling the deprecated accelerators.
+  auto itr = actions_with_deprecations_.find(action);
+  if (itr != actions_with_deprecations_.end()) {
+    const DeprecatedAcceleratorData* data = itr->second;
+    if (deprecated_accelerators_.count(accelerator)) {
+      // This accelerator has been deprecated and should be treated according
+      // to its |DeprecatedAcceleratorData|.
+
+      // Record UMA stats.
+      RecordUmaHistogram(data->uma_histogram_name, DEPRECATED_USED);
+
+      // We always display the notification as long as this entry exists.
+      ShowDeprecatedAcceleratorNotification(data->notification_message_id);
+
+      if (!data->deprecated_enabled)
+        return false;
+    } else {
+      // This is a new accelerator replacing the old deprecated one.
+      // Record UMA stats and proceed normally.
+      RecordUmaHistogram(data->uma_histogram_name, NEW_USED);
+    }
+  }
+
   AcceleratorProcessingRestriction restriction =
       GetAcceleratorProcessingRestriction(action);
   if (restriction != RESTRICTION_NONE)
     return restriction == RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
 
   const ui::Accelerator& previous_accelerator =
       accelerator_history_->previous_accelerator();
 
   // True should be returned if running |action| does something. Otherwise,
   // false should be returned to give the web contents a chance at handling the
@@ skipping 447 matching lines @@
 }
 
 void AcceleratorController::SetKeyboardBrightnessControlDelegate(
     scoped_ptr<KeyboardBrightnessControlDelegate>
     keyboard_brightness_control_delegate) {
   keyboard_brightness_control_delegate_ =
       keyboard_brightness_control_delegate.Pass();
 }
 
 }  // namespace ash