Regression: Search+Key pops up app launcher

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 411 matching lines @@
   return true;
 }
 
 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))
+
+  if ((key_code != ui::VKEY_BROWSER_SEARCH ||
+       accelerator.type() != ui::ET_KEY_PRESSED) &&
+      (key_code != ui::VKEY_LWIN ||
+       previous_event_type != ui::ET_KEY_PRESSED ||
+       previous_key_code != ui::VKEY_LWIN ||
+       accelerator.type() != ui::ET_KEY_RELEASED)) {
     return false;
+  }
+
   if (key_code == ui::VKEY_LWIN)
     base::RecordAction(base::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 HandleToggleFullscreen(ui::KeyboardCode key_code) {
   if (key_code == ui::VKEY_MEDIA_LAUNCH_APP2) {
     base::RecordAction(UserMetricsAction("Accel_Fullscreen_F4"));
@@ skipping 245 matching lines @@
 bool HandleVolumeUp(const ui::Accelerator& accelerator) {
   VolumeControlDelegate* volume_delegate =
       Shell::GetInstance()->system_tray_delegate()->GetVolumeControlDelegate();
   if (volume_delegate)
     volume_delegate->HandleVolumeUp(accelerator);
   return true;
 }
 
 #endif  // defined(OS_CHROMEOS)
 
-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
 
 ////////////////////////////////////////////////////////////////////////////////
 // AcceleratorController, public:
 
 AcceleratorController::AcceleratorController()
-    : accelerator_manager_(new ui::AcceleratorManager) {
+    : accelerator_manager_(new ui::AcceleratorManager),
+      accelerator_history_(new ui::AcceleratorHistory) {
   Init();
 }
 
 AcceleratorController::~AcceleratorController() {
 }
 
 void AcceleratorController::Register(const ui::Accelerator& accelerator,
                                      ui::AcceleratorTarget* target) {
   accelerator_manager_->Register(accelerator,
                                  ui::AcceleratorManager::kNormalPriority,
                                  target);
 }
 
 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 61 matching lines @@
 }
 
 bool AcceleratorController::CanHandleAccelerators() const {
   return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // AcceleratorController, private:
 
 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 45 matching lines @@
     return restriction == RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION;
 
   if (nonrepeatable_actions_.find(action) != nonrepeatable_actions_.end() &&
       accelerator.IsRepeat()) {
     return true;
   }
 
   const ui::KeyboardCode key_code = accelerator.key_code();
 
   // Type of the previous accelerator. Used by NEXT_IME and DISABLE_CAPS_LOCK.
-  const ui::EventType previous_event_type = previous_accelerator_.type();
-  const ui::KeyboardCode previous_key_code = previous_accelerator_.key_code();
+  const ui::Accelerator& previous_accelerator =
+      accelerator_history_->previous_accelerator();
+  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 239 matching lines @@
 }
 
 void AcceleratorController::SetKeyboardBrightnessControlDelegate(
     scoped_ptr<KeyboardBrightnessControlDelegate>
     keyboard_brightness_control_delegate) {
   keyboard_brightness_control_delegate_ =
       keyboard_brightness_control_delegate.Pass();
 }
 
 }  // namespace ash