1 files changed, 71 insertions, 36 deletions

diff --git a/webkit/glue/webinputevent.h b/webkit/glue/webinputevent.h
index 5565478..dbfe456 100644
--- a/webkit/glue/webinputevent.h
+++ b/webkit/glue/webinputevent.h
@@ -6,11 +6,11 @@
 #define WEBKIT_GLUE_WEBINPUTEVENT_H_
 
 #include "base/basictypes.h"
+#include "base/string16.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #elif defined(OS_MACOSX)
-#include <vector>
 #ifdef __OBJC__
 @class NSEvent;
 @class NSView;
@@ -19,6 +19,7 @@ class NSEvent;
 class NSView;
 #endif  // __OBJC__
 #elif defined(OS_LINUX)
+#include <glib.h>
 typedef struct _GdkEventButton GdkEventButton;
 typedef struct _GdkEventMotion GdkEventMotion;
 typedef struct _GdkEventScroll GdkEventScroll;
@@ -31,6 +32,10 @@ typedef struct _GdkEventKey GdkEventKey;
 //
 // The fields of these event classes roughly correspond to the fields required
 // by WebCore's platform event classes.
+//
+// WARNING! These classes must remain PODs (plain old data). They will be
+// "serialized" by shipping their raw bytes across the wire, so they must not
+// contain any non-bit-copyable member variables!
 
 // WebInputEvent --------------------------------------------------------------
 
@@ -38,6 +43,17 @@ class WebInputEvent {
  public:
   WebInputEvent() : modifiers(0) { }
 
+  // There are two schemes used for keyboard input. On Windows (and,
+  // interestingly enough, on Mac Carbon) there are two events for a keypress.
+  // One is a raw keydown, which provides the keycode only. If the app doesn't
+  // handle that, then the system runs key translation to create an event
+  // containing the generated character and pumps that event. In such a scheme,
+  // those two events are translated to RAW_KEY_DOWN and CHAR events
+  // respectively. In Cocoa and Gtk, key events contain both the keycode and any
+  // translation into actual text. In such a case, WebCore will eventually need
+  // to split the events (see disambiguateKeyDownEvent and its callers) but we
+  // don't worry about that here. We just use a different type (KEY_DOWN) to
+  // indicate this.
   enum Type {
     // WebMouseEvent
     MOUSE_DOWN,
@@ -50,6 +66,7 @@ class WebInputEvent {
     MOUSE_WHEEL,
 
     // WebKeyboardEvent
+    RAW_KEY_DOWN,
     KEY_DOWN,
     KEY_UP,
     CHAR
@@ -72,7 +89,10 @@ class WebInputEvent {
 
   // Returns true if the WebInputEvent |type| is a keyboard event.
   static bool IsKeyboardEventType(int type) {
-    return type == KEY_DOWN || type == KEY_UP || type == CHAR;
+    return type == RAW_KEY_DOWN ||
+           type == KEY_DOWN ||
+           type == KEY_UP ||
+           type == CHAR;
   }
 };
 
@@ -126,53 +146,68 @@ class WebMouseWheelEvent : public WebMouseEvent {
 
 // WebKeyboardEvent -----------------------------------------------------------
 
+// Caps on string lengths so we can make them static arrays and keep them PODs.
+const size_t kTextLengthCap = 4;
+// http://www.w3.org/TR/DOM-Level-3-Events/keyset.html lists the identifiers.
+// The longest is 18 characters, so we'll round up to the next multiple of 4.
+const size_t kIdentifierLengthCap = 20;
+
 class WebKeyboardEvent : public WebInputEvent {
  public:
-  // The key_code field is the Windows key code associated with this key event.
-  // This sometimes matches the ASCII value of the key (for e.g. a-z) but
-  // officially ignores case, and has its own set of codes for control keys as
-  // well as other visible letters like punctuation.
-  // webkit/port/platform/chromium/KeyboardCodes* is an attempt at defining all
-  // of these keys, but it's not all the way there yet.  (E.g., the Windows
-  // implementation there just passes through the code from the windows message
-  // directly.)
-  int key_code;
-
-#if defined(OS_MACOSX)
-  // text arrays extracted from the native event. On Mac, there may be
-  // multiple keys sent as a single event if the flags don't change.
-  std::vector<unsigned short> text;
-  std::vector<unsigned short> unmodified_text;
-  std::vector<unsigned short> key_identifier;
-#elif defined(OS_WIN)
-  bool system_key;  // Set if we receive a SYSKEYDOWN/WM_SYSKEYUP message.
-  MSG actual_message; // Set to the current keyboard message.
-#elif defined(OS_LINUX)
-  // The unicode character, if available, corresponding to this key event.
-  // TODO(evanm): temporary hack for test_shell.  Ideally we'd either manage
-  // to stuff everything into key_code, or make this field shared by all
-  // implementations, but this will have to do for now.
-  wchar_t text;
+  // |windows_key_code| is the Windows key code associated with this key event.
+  // Sometimes it's direct from the event (i.e. on Windows), sometimes it's via
+  // a mapping function.  If you want a list, see
+  // webkit/port/platform/chromium/KeyboardCodes* .
+  int windows_key_code;
+
+  // The actual key code genenerated by the platform. The DOM spec runs on
+  // Windows-equivalent codes (thus |windows_key_code| above) but it doesn't
+  // hurt to have this one around.
+  int native_key_code;
+
+  // |text| is the text generated by this keystroke. |unmodified_text| is
+  // |text|, but unmodified by an concurrently-held modifiers (except shift).
+  // This is useful for working out shortcut keys. Linux and Windows guarantee
+  // one character per event. The Mac does not, but in reality that's all it
+  // ever gives. We're generous, and cap it a bit longer.
+  char16 text[kTextLengthCap];
+  char16 unmodified_text[kTextLengthCap];
+
+  // This is a string identifying the key pressed.
+  char key_identifier[kIdentifierLengthCap];
+
+  // This identifies whether this event was tagged by the system as being a
+  // "system key" event (see
+  // http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx for details).
+  // Other platforms don't have this concept, but it's just easier to leave it
+  // always false than ifdef.
+
+  bool system_key;
+
+  // References to the original event.
+#if defined(OS_WIN)
+  MSG actual_message;  // Set to the current keyboard message. TODO(avi): remove
 #endif
 
-  WebKeyboardEvent() 
-      : key_code(0)
+  WebKeyboardEvent() : windows_key_code(0),
+                       native_key_code(0),
+                       system_key(false) {
+    memset(&text, 0, sizeof(text));
+    memset(&unmodified_text, 0, sizeof(unmodified_text));
+    memset(&key_identifier, 0, sizeof(key_identifier));
 #if defined(OS_WIN)
-        , system_key(false) {
     memset(&actual_message, 0, sizeof(actual_message));
-  }
-#else
-  {}
 #endif
+  }
 
 #if defined(OS_WIN)
-  WebKeyboardEvent(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
+  explicit WebKeyboardEvent(HWND hwnd, UINT message, WPARAM wparam,
+                            LPARAM lparam);
 #elif defined(OS_MACOSX)
-  WebKeyboardEvent(NSEvent *event);
+  explicit WebKeyboardEvent(NSEvent *event);
 #elif defined(OS_LINUX)
   explicit WebKeyboardEvent(const GdkEventKey* event);
 #endif
 };
 
-
 #endif  // WEBKIT_GLUE_WEBINPUTEVENT_H_