Avoid toggling app list if interrupted by mouse

ui/base/accelerators/accelerator.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 "ui/base/accelerators/accelerator.h"
 
 #include <stdint.h>
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
@@ skipping 24 matching lines @@
 
 }  // namespace
 
 Accelerator::Accelerator() : Accelerator(VKEY_UNKNOWN, EF_NONE) {}
 
 Accelerator::Accelerator(KeyboardCode key_code,
                          int modifiers,
                          KeyState key_state)
     : key_code_(key_code),
       key_state_(key_state),
-      modifiers_(modifiers & kInterestingFlagsMask) {}
+      modifiers_(modifiers & kInterestingFlagsMask),
+      interrupted_by_mouse_event_(false) {}
 
 Accelerator::Accelerator(const KeyEvent& key_event)
     : key_code_(key_event.key_code()),
       key_state_(key_event.type() == ET_KEY_PRESSED ? KeyState::PRESSED
                                                     : KeyState::RELEASED),
       // |modifiers_| may include the repeat flag.
-      modifiers_(key_event.flags() & kInterestingFlagsMask) {}
+      modifiers_(key_event.flags() & kInterestingFlagsMask),
+      interrupted_by_mouse_event_(false) {}
 
 Accelerator::Accelerator(const Accelerator& accelerator) {
   key_code_ = accelerator.key_code_;
   key_state_ = accelerator.key_state_;
   modifiers_ = accelerator.modifiers_;
+  interrupted_by_mouse_event_ = accelerator.interrupted_by_mouse_event_;
   if (accelerator.platform_accelerator_)
     platform_accelerator_ = accelerator.platform_accelerator_->CreateCopy();
 }
 
 Accelerator::~Accelerator() {
 }
 
 // static
 int Accelerator::MaskOutKeyEventFlags(int flags) {
   return flags & kModifierMask;
 }
 
 Accelerator& Accelerator::operator=(const Accelerator& accelerator) {
   if (this != &accelerator) {
     key_code_ = accelerator.key_code_;
     key_state_ = accelerator.key_state_;
     modifiers_ = accelerator.modifiers_;
+    interrupted_by_mouse_event_ = accelerator.interrupted_by_mouse_event_;
     if (accelerator.platform_accelerator_)
       platform_accelerator_ = accelerator.platform_accelerator_->CreateCopy();
     else
       platform_accelerator_.reset();
   }
   return *this;
 }
 
 bool Accelerator::operator <(const Accelerator& rhs) const {
   if (key_code_ != rhs.key_code_)
     return key_code_ < rhs.key_code_;
   if (key_state_ != rhs.key_state_) {
     return static_cast<int32_t>(key_state_) <
            static_cast<int32_t>(rhs.key_state_);
   }
   return MaskOutKeyEventFlags(modifiers_) <
          MaskOutKeyEventFlags(rhs.modifiers_);
 }
 
 bool Accelerator::operator ==(const Accelerator& rhs) const {
   return (key_code_ == rhs.key_code_) && (key_state_ == rhs.key_state_) &&
          (MaskOutKeyEventFlags(modifiers_) ==
-          MaskOutKeyEventFlags(rhs.modifiers_));
+          MaskOutKeyEventFlags(rhs.modifiers_)) &&
+         interrupted_by_mouse_event_ == rhs.interrupted_by_mouse_event_;
 }
 
 bool Accelerator::operator !=(const Accelerator& rhs) const {
   return !(*this == rhs);
 }
 
 bool Accelerator::IsShiftDown() const {
   return (modifiers_ & EF_SHIFT_DOWN) != 0;
 }
 
@@ skipping 175 matching lines @@
 
     // Subtracting the size of the shortcut key and 1 for the '+' sign.
     shortcut_rtl.append(shortcut, 0, shortcut.length() - key_length - 1);
     shortcut.swap(shortcut_rtl);
   }
 
   return shortcut;
 }
 
 }  // namespace ui