Converts ui::Accelerator::type to an enum

ui/base/accelerators/accelerator.h

 // 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.
 
 // This class describe a keyboard accelerator (or keyboard shortcut).
 // Keyboard accelerators are registered with the FocusManager.
 // It has a copy constructor and assignment operator so that it can be copied.
 // It also defines the < operator so that it can be used as a key in a std::map.
 //
 
@@ skipping 17 matching lines @@
 // This is a cross-platform class for accelerator keys used in menus.
 // |platform_accelerator| should be used to store platform specific data.
 //
 // While |modifiers| may include EF_IS_REPEAT, EF_IS_REPEAT is not considered
 // an intrinsic part of an Accelerator. This is done so that an accelerator
 // for a particular KeyEvent matches an accelerator with or without the repeat
 // flag. A side effect of this is that == (and <) does not consider the
 // repeat flag in its comparison.
 class UI_BASE_EXPORT Accelerator {
  public:
+  enum class KeyState {

[msw, 2017/03/16 16:57:22]

very optional nit: If this weren't an enum class, users could cite values
without the extra typename scoping: ie.  ui::Accelerator::PRESSED vs
ui::Accelerator::KeyState::PRESSED, which would be a little less verbose.

[sky, 2017/03/16 17:06:40]

If I went down that route I would use a more verbose name for the enum values,
e.g. KEY_STATE_PRESSED, in which case it isn't really any shorter.

+    PRESSED,
+    RELEASED,
+  };
+
   Accelerator();
   // NOTE: this constructor strips out non key related flags.
-  Accelerator(ui::KeyboardCode keycode, int modifiers);
+  Accelerator(KeyboardCode key_code, int modifiers);
   explicit Accelerator(const KeyEvent& key_event);
   Accelerator(const Accelerator& accelerator);
   ~Accelerator();
 
   // Masks out all the non-modifiers KeyEvent |flags| and returns only the
   // available modifier ones. This does not include EF_IS_REPEAT.
   static int MaskOutKeyEventFlags(int flags);
 
   Accelerator& operator=(const Accelerator& accelerator);
 
   // Define the < operator so that the KeyboardShortcut can be used as a key in
   // a std::map.
   bool operator <(const Accelerator& rhs) const;
 
   bool operator ==(const Accelerator& rhs) const;
 
   bool operator !=(const Accelerator& rhs) const;
 
-  ui::KeyboardCode key_code() const { return key_code_; }
+  KeyboardCode key_code() const { return key_code_; }
 
-  // Sets the event type if the accelerator should be processed on an event
-  // other than ui::ET_KEY_PRESSED.
-  void set_type(ui::EventType type) { type_ = type; }
-  ui::EventType type() const { return type_; }
+  // Sets the key state that triggers the accelerator. Default is PRESSED.
+  void set_key_state(KeyState state) { key_state_ = state; }
+  KeyState key_state() const { return key_state_; }
 
   int modifiers() const { return modifiers_; }
 
   bool IsShiftDown() const;
   bool IsCtrlDown() const;
   bool IsAltDown() const;
   bool IsCmdDown() const;
   bool IsRepeat() const;
 
   // Returns a string with the localized shortcut if any.
   base::string16 GetShortcutText() const;
 
   void set_platform_accelerator(std::unique_ptr<PlatformAccelerator> p) {
     platform_accelerator_ = std::move(p);
   }
 
   // This class keeps ownership of the returned object.
   const PlatformAccelerator* platform_accelerator() const {
     return platform_accelerator_.get();
   }
 
  private:
   // The keycode (VK_...).
   KeyboardCode key_code_;
 
-  // The event type (usually ui::ET_KEY_PRESSED).
-  EventType type_;
+  KeyState key_state_;
 
   // The state of the Shift/Ctrl/Alt keys. This corresponds to Event::flags().
   int modifiers_;
 
   // Stores platform specific data. May be NULL.
   std::unique_ptr<PlatformAccelerator> platform_accelerator_;
 };
 
 // An interface that classes that want to register for keyboard accelerators
 // should implement.
@@ skipping 11 matching lines @@
   virtual ~AcceleratorTarget() {}
 };
 
 // Since accelerator code is one of the few things that can't be cross platform
 // in the chrome UI, separate out just the GetAcceleratorForCommandId() from
 // the menu delegates.
 class AcceleratorProvider {
  public:
   // Gets the accelerator for the specified command id. Returns true if the
   // command id has a valid accelerator, false otherwise.
-  virtual bool GetAcceleratorForCommandId(
-      int command_id,
-      ui::Accelerator* accelerator) const = 0;
+  virtual bool GetAcceleratorForCommandId(int command_id,
+                                          Accelerator* accelerator) const = 0;
 
  protected:
   virtual ~AcceleratorProvider() {}
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_ACCELERATORS_ACCELERATOR_H_