Add EF_IS_REPEAT flag to KeyEvent to handle repeated accelerators correctly.

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 725 matching lines @@
 bool HandlePrintUIHierarchies() {
   // This is a separate command so the user only has to hit one key to generate
   // all the logs. Developers use the individual dumps repeatedly, so keep
   // those as separate commands to avoid spamming their logs.
   HandlePrintLayerHierarchy();
   HandlePrintWindowHierarchy();
   HandlePrintViewHierarchy();
   return true;
 }
 
+class AutoSet {
+ public:
+  AutoSet(ui::Accelerator* scoped, ui::Accelerator new_value)
+      : scoped_(scoped), new_value_(new_value) {}
+  ~AutoSet() { *scoped_ = new_value_; }
+
+ private:
+  ui::Accelerator* scoped_;
+  const ui::Accelerator new_value_;
+
+  DISALLOW_COPY_AND_ASSIGN(AutoSet);
+};
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
-// AcceleratorControllerContext, public:
-
-AcceleratorControllerContext::AcceleratorControllerContext() {
-  current_accelerator_.set_type(ui::ET_UNKNOWN);
-  previous_accelerator_.set_type(ui::ET_UNKNOWN);
-}
-
-void AcceleratorControllerContext::UpdateContext(
-    const ui::Accelerator& accelerator) {
-  previous_accelerator_ = current_accelerator_;
-  current_accelerator_ = accelerator;
-}
-
-////////////////////////////////////////////////////////////////////////////////
 // AcceleratorController, public:
 
 AcceleratorController::AcceleratorController()
     : accelerator_manager_(new ui::AcceleratorManager) {
   Init();
 }
 
 AcceleratorController::~AcceleratorController() {
 }
 
 void AcceleratorController::Init() {
+  previous_accelerator_.set_type(ui::ET_UNKNOWN);
   for (size_t i = 0; i < kActionsAllowedAtLoginOrLockScreenLength; ++i) {
     actions_allowed_at_login_screen_.insert(
         kActionsAllowedAtLoginOrLockScreen[i]);
     actions_allowed_at_lock_screen_.insert(
         kActionsAllowedAtLoginOrLockScreen[i]);
   }
   for (size_t i = 0; i < kActionsAllowedAtLockScreenLength; ++i)
     actions_allowed_at_lock_screen_.insert(kActionsAllowedAtLockScreen[i]);
   for (size_t i = 0; i < kActionsAllowedAtModalWindowLength; ++i)
     actions_allowed_at_modal_window_.insert(kActionsAllowedAtModalWindow[i]);
@@ skipping 34 matching lines @@
 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);
 }
 
 bool AcceleratorController::Process(const ui::Accelerator& accelerator) {
+  AutoSet auto_set(&previous_accelerator_, accelerator);
+
   if (ime_control_delegate_) {
     return accelerator_manager_->Process(
         ime_control_delegate_->RemapAccelerator(accelerator));
   }
   return accelerator_manager_->Process(accelerator);
 }
 
 bool AcceleratorController::IsRegistered(
     const ui::Accelerator& accelerator) const {
   return accelerator_manager_->GetCurrentTarget(accelerator) != NULL;
@@ skipping 44 matching lines @@
     Shell::GetInstance()->accessibility_delegate()->TriggerAccessibilityAlert(
         A11Y_ALERT_WINDOW_NEEDED);
     return true;
   }
 
   const ui::KeyboardCode key_code = accelerator.key_code();
   // PerformAction() is performed from gesture controllers and passes
   // empty Accelerator() instance as the second argument. Such events
   // should never be suspended.
   const bool gesture_event = key_code == ui::VKEY_UNKNOWN;
-
   // Ignore accelerators invoked as repeated (while holding a key for a long
   // time, if their handling is nonrepeatable.
   if (nonrepeatable_actions_.find(action) != nonrepeatable_actions_.end() &&
-      context_.repeated() && !gesture_event) {
+      accelerator.IsRepeat() && !gesture_event) {
     return true;
   }
   // Type of the previous accelerator. Used by NEXT_IME and DISABLE_CAPS_LOCK.
-  const ui::EventType previous_event_type =
-    context_.previous_accelerator().type();
-  const ui::KeyboardCode previous_key_code =
-    context_.previous_accelerator().key_code();
+  const ui::EventType previous_event_type = previous_accelerator_.type();
+  const ui::KeyboardCode previous_key_code = previous_accelerator_.key_code();
 
   // You *MUST* return true when some action is performed. Otherwise, this
   // function might be called *twice*, via BrowserView::PreHandleKeyboardEvent
   // and BrowserView::HandleKeyboardEvent, for a single accelerator press.
   //
   // If your accelerator invokes more than one line of code, please either
   // implement it in your module's controller code (like TOGGLE_MIRROR_MODE
   // below) or pull it into a HandleFoo() function above.
   switch (action) {
     case ACCESSIBLE_FOCUS_NEXT:
@@ skipping 270 matching lines @@
     keyboard_brightness_control_delegate) {
   keyboard_brightness_control_delegate_ =
       keyboard_brightness_control_delegate.Pass();
 }
 
 bool AcceleratorController::CanHandleAccelerators() const {
   return true;
 }
 
 }  // namespace ash