mojo: Plumb through sufficient context to make real blink::WebInputEvents.

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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/event_types.h"
 #include "base/gtest_prod_util.h"
 #include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/gesture_event_details.h"
 #include "ui/events/gestures/gesture_types.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/events/latency_info.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/point_conversions.h"
 
 namespace gfx {
@@ skipping 561 matching lines @@
   // Create a character event.
   KeyEvent(base::char16 character, KeyboardCode key_code, int flags);
 
   // Used for synthetic events with code of DOM KeyboardEvent (e.g. 'KeyA')
   // See also: ui/events/keycodes/dom4/keycode_converter_data.h
   KeyEvent(EventType type,
            KeyboardCode key_code,
            const std::string& code,
            int flags);
 
+  KeyEvent(const KeyEvent& rhs);
+
+  KeyEvent& operator=(const KeyEvent& rhs);
+
+  virtual ~KeyEvent();
+
+  // Used for synthetic events inside of mojo.
+  //
+  // TODO(erg): While we transition to mojo, we have to hack around a mismatch
+  // in our event types. Our ui::Events don't really have all the data we need
+  // to process key events, and we instead do per-platform conversions with
+  // native HWNDs or XEvents. And we can't reliably send those native data
+  // types across mojo types in a cross-platform way. So instead, we set the
+  // resulting data when read across IPC boundaries.
+  //
+  // Please note that |windows_key_code| does not necessarily have the same
+  // value as |key_code()|. Long term, those values will go away as we
+  // transition to mojo.
+  void SetSelfContainedKeyEventData(int32_t windows_key_code,

[sky, 2014/08/21 15:44:42]

SelfContained? Maybe SetExtendedData? (KeyEvent is unnecessary since this
function is in the KeyEvent class).

It seems like this data is only used by mojo. If that's the case could we make
KeyEvent have a Data object that is a struct with a pure virtual destructor and
mojo has the code to set and manipulate it?

+                                    int32_t platform_key_code,
+                                    base::char16 text,
+                                    base::char16 unmodified_text);
+
+  // These accessors will first return data from a native event if it exists,
+  // and will then check explicitly set values from
+  // SetSelfContainedKeyEventData().
+  int32_t GetWindowsKeyCode() const;
+  base::char16 GetKeyText() const;
+  base::char16 GetKeyUnmodifiedText() const;
+
   // This bypasses the normal mapping from keystroke events to characters,
   // which allows an I18N virtual keyboard to fabricate a keyboard event that
   // does not have a corresponding KeyboardCode (example: U+00E1 Latin small
   // letter A with acute, U+0410 Cyrillic capital letter A).
   void set_character(base::char16 character) { character_ = character; }
 
   // Gets the character generated by this key event. It only supports Unicode
   // BMP characters.
   base::char16 GetCharacter() const;
 
@@ skipping 48 matching lines @@
   uint32 platform_keycode_;
 
   // String of 'key' defined in DOM KeyboardEvent (e.g. 'a', 'â')
   // http://www.w3.org/TR/uievents/#keyboard-key-codes.
   //
   // This value represents the text that the key event will insert to input
   // field. For key with modifier key, it may have specifial text.
   // e.g. CTRL+A has '\x01'.
   base::char16 character_;
 
+  // Parts of our event handling require raw native events (see both the
+  // windows and linux implementations of web_input_event in content/). Because
+  // mojo instead serializes and deserializes events in potentially different
+  // processes, we need to have a mechanism to keep track of this data.
+  struct ExtendedMojoData;
+  scoped_ptr<ExtendedMojoData> extended_mojo_data_;
+
   static bool IsRepeated(const KeyEvent& event);
 
   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,
@@ skipping 61 matching lines @@
 
   const GestureEventDetails& details() const { return details_; }
 
  private:
   GestureEventDetails details_;
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_EVENT_H_