Fixing WebKeyboardEvent. For reals this time.

webkit/glue/webinputevent.h

 // Copyright (c) 2006-2008 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 WEBKIT_GLUE_WEBINPUTEVENT_H_
 #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;
 #else
 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;
 typedef struct _GdkEventKey GdkEventKey;
 #endif
 
 // The classes defined in this file are intended to be used with WebView's
 // HandleInputEvent method.  These event types are cross-platform; however,
 // there are platform-specific constructors that accept native UI events.
 //
 // 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 --------------------------------------------------------------
 
 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,
     MOUSE_UP,
     MOUSE_MOVE,
     MOUSE_LEAVE,
     MOUSE_DOUBLE_CLICK,
 
     // WebMouseWheelEvent
     MOUSE_WHEEL,
 
     // WebKeyboardEvent
+    RAW_KEY_DOWN,
     KEY_DOWN,
     KEY_UP,
     CHAR
   };
 
   enum Modifiers {
     // modifiers for all events:
     SHIFT_KEY      = 1 << 0,
     CTRL_KEY       = 1 << 1,
     ALT_KEY        = 1 << 2,
@@ skipping 51 matching lines @@
   WebMouseWheelEvent(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
 #elif defined(OS_MACOSX)
   WebMouseWheelEvent(NSEvent *event, NSView* view);
 #elif defined(OS_LINUX)
   explicit WebMouseWheelEvent(const GdkEventScroll* event);
 #endif
 };
 
 // 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;
+  // |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;
 
-#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;
+  // 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
+
+  // Stores the GDK keyval and modifier state of the GdkEventKey; this is used
+  // to transport these values across IPC so they can be used in the front end
+  // code.
+  guint gdk_keyval;
+  guint gdk_modifier;
 #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));
+#endif
   }
-#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_