Adds KeyEvent::properties

ui/events/event.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.
 
 #ifndef UI_EVENTS_EVENT_H_
 #define UI_EVENTS_EVENT_H_
 
 #include <stdint.h>
 
 #include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/event_types.h"
 #include "base/gtest_prod_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string16.h"
 #include "base/time/time.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/gesture_event_details.h"
@@ skipping 770 matching lines @@
 // For a character event,
 // -- |bool is_char_| is true.
 // -- |EventType Event::type()| is ET_KEY_PRESSED.
 // -- |DomCode code_| is DomCode::NONE.
 // -- |DomKey key_| is a UTF-16 code point.
 // -- |KeyboardCode key_code_| is conflated with the character-valued key_
 //    by some code, because both arrive in the wParam field of a Windows event.
 //
 class EVENTS_EXPORT KeyEvent : public Event {
  public:
+  using Properties = std::unordered_map<std::string, std::vector<uint8_t>>;
+
   // Create a KeyEvent from a NativeEvent. For Windows this native event can
   // be either a keystroke message (WM_KEYUP/WM_KEYDOWN) or a character message
   // (WM_CHAR). Other systems have only keystroke events.
   explicit KeyEvent(const base::NativeEvent& native_event);
 
   // Create a KeyEvent from a NativeEvent but with mocked flags.
   // This method is necessary for Windows since MSG does not contain all flags.
   KeyEvent(const base::NativeEvent& native_event, int event_flags);
 
   // Create a keystroke event from a legacy KeyboardCode.
@@ skipping 86 matching lines @@
   DomCode code() const { return code_; };
   std::string GetCodeString() const;
 
   // Returns the DOM .key (layout meaning) for a keystroke event.
   DomKey GetDomKey() const;
 
   // Normalizes flags_ so that it describes the state after the event.
   // (Native X11 event flags describe the state before the event.)
   void NormalizeFlags();
 
+  // Sets the properties associated with this KeyEvent.
+  void SetProperties(const Properties& properties);
+
+  // Returns the properties associated with this event, which may be null.
+  // The properties are meant to provide a way to associate arbitrary key/value
+  // pairs with KeyEvents and not used by KeyEvent.
+  const Properties* properties() const { return properties_.get(); }
+
  protected:
   friend class KeyEventTestApi;
 
   // This allows a subclass TranslatedKeyEvent to be a non character event.
   void set_is_char(bool is_char) { is_char_ = is_char; }
 
  private:
   // Determine key_ on a keystroke event from code_ and flags().
   void ApplyLayout() const;
 
+  static bool IsRepeated(const KeyEvent& event);
+
   KeyboardCode key_code_;
 
   // DOM KeyboardEvent |code| (e.g. DomCode::US_A, DomCode::SPACE).
   // http://www.w3.org/TR/DOM-Level-3-Events-code/
   //
   // This value represents the physical position in the keyboard and can be
   // converted from / to keyboard scan code like XKB.
   DomCode code_;
 
   // True if this is a character event, false if this is a keystroke event.
   bool is_char_ = false;
 
   // TODO(kpschoedel): refactor so that key_ is not mutable.
   // This requires defining the KeyEvent completely at construction rather
   // than lazily under GetCharacter(), which likely also means removing
   // the two 'incomplete' constructors. crbug.com/444045
   //
   // DOM KeyboardEvent |key|
   // http://www.w3.org/TR/DOM-Level-3-Events-key/
   //
   // This value represents the meaning of a key, which is either a Unicode
   // character, or a named DomKey:: value.
   // This is not necessarily initialized when the event is constructed;
   // it may be set only if and when GetCharacter() or GetDomKey() is called.
   mutable DomKey key_ = DomKey::NONE;
 
-  static bool IsRepeated(const KeyEvent& event);
+  std::unique_ptr<Properties> properties_;

[sadrul, 2017/03/21 17:21:14]

Should this be a base::Optional?

[sky, 2017/03/21 17:25:37]

My understanding is that base::Optional's size is always that of the element,
where as unique_ptr size is that of the pointer value. As most KeyEvents won't
contain properties I went with unique_ptr.

 
   static KeyEvent* last_key_event_;
 };
 
 class EVENTS_EXPORT ScrollEvent : public MouseEvent {
  public:
   explicit ScrollEvent(const base::NativeEvent& native_event);
   template <class T>
   ScrollEvent(const ScrollEvent& model,
               T* source,
@@ skipping 80 matching lines @@
   // dispatched. This field gets a non-zero value only for gestures that are
   // released through TouchDispositionGestureFilter::SendGesture. The gesture
   // events that aren't fired directly in response to processing a touch-event
   // (e.g. timer fired ones), this id is zero. See crbug.com/618738.
   uint32_t unique_touch_event_id_;
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_EVENT_H_