Revert "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::kNotifierDeprecatedAccelerator),
-          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);
 
-#if defined(OS_CHROMEOS)
-  RegisterDeprecatedAccelerators(kDeprecatedAccelerators,
-                                 kDeprecatedAcceleratorsLength);
-#endif  // defined(OS_CHROMEOS)
-
   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);
+    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);
     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