Reverting key change (again); this breaks every keyboard layout test there is...

webkit/glue/webview_impl.cc

 /*
 * Copyright 2007 Google Inc. All Rights Reserved.
 *
 * Portions Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
 *
 * ***** BEGIN LICENSE BLOCK *****
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
@@ skipping 462 matching lines @@
   if (event.button == WebMouseEvent::BUTTON_RIGHT)
     MouseContextMenu(event);
 }
 
 void WebViewImpl::MouseWheel(const WebMouseWheelEvent& event) {
   MakePlatformWheelEvent platform_event(main_frame()->frameview(), event);
   main_frame()->frame()->eventHandler()->handleWheelEvent(platform_event);
 }
 
 bool WebViewImpl::KeyEvent(const WebKeyboardEvent& event) {
-  DCHECK((event.type == WebInputEvent::RAW_KEY_DOWN) ||
-         (event.type == WebInputEvent::KEY_DOWN) ||
+  DCHECK((event.type == WebInputEvent::KEY_DOWN) ||
          (event.type == WebInputEvent::KEY_UP));
 
   // Please refer to the comments explaining the suppress_next_keypress_event_
   // member.
   // The suppress_next_keypress_event_ is set if the KeyDown is handled by
   // Webkit. A keyDown event is typically associated with a keyPress(char)
   // event and a keyUp event. We reset this flag here as this is a new keyDown
   // event.
   suppress_next_keypress_event_ = false;
 
   // Give autocomplete a chance to consume the key events it is interested in.
   if (AutocompleteHandleKeyEvent(event))
     return true;
 
   Frame* frame = GetFocusedWebCoreFrame();
   if (!frame)
     return false;
 
   EventHandler* handler = frame->eventHandler();
   if (!handler)
     return KeyEventDefault(event);
 
 #if defined(OS_WIN)
   // TODO(pinkerton): figure out these keycodes on non-windows
-  if (((event.modifiers == 0) && (event.windows_key_code == VK_APPS)) ||
+  if (((event.modifiers == 0) && (event.key_code == VK_APPS)) ||
       ((event.modifiers == WebInputEvent::SHIFT_KEY) &&
-       (event.windows_key_code == VK_F10))) {
+       (event.key_code == VK_F10))) {
     SendContextMenuEvent(event);
     return true;
   }
 #endif
 
   MakePlatformKeyboardEvent evt(event);
 
-  if (WebInputEvent::RAW_KEY_DOWN == event.type) {
+#if !defined(OS_MACOSX)
+  if (WebInputEvent::KEY_DOWN == event.type) {
     MakePlatformKeyboardEvent evt_rawkeydown = evt;
+    evt_rawkeydown.SetKeyType(WebCore::PlatformKeyboardEvent::RawKeyDown);
     if (handler->keyEvent(evt_rawkeydown) && !evt_rawkeydown.isSystemKey()) {
       suppress_next_keypress_event_ = true;
       return true;
     }
   } else {
     if (handler->keyEvent(evt)) {
       return true;
     }
   }
+#else
+  // Windows and Cocoa handle events in rather different ways. On Windows,
+  // you get two events: WM_KEYDOWN/WM_KEYUP and WM_CHAR. In
+  // PlatformKeyboardEvent, RawKeyDown represents the raw messages. When
+  // processing them, we don't process text editing events, since we'll be
+  // getting the data soon enough. In Cocoa, we get one event with both the
+  // raw and processed data. Therefore we need to keep the type as KeyDown, so
+  // that we'll know that this is the only time we'll have the event and that
+  // we need to do our thing.
+  if (handler->keyEvent(evt)) {
+    return true;
+  }
+#endif
 
   return KeyEventDefault(event);
 }
 
 bool WebViewImpl::AutocompleteHandleKeyEvent(const WebKeyboardEvent& event) {
   if (!autocomplete_popup_showing_ ||
       // Home and End should be left to the text field to process.
-      event.windows_key_code == base::VKEY_HOME ||
-      event.windows_key_code == base::VKEY_END) {
+      event.key_code == base::VKEY_HOME || event.key_code == base::VKEY_END) {
     return false;
   }
 
-  if (!autocomplete_popup_->isInterestedInEventForKey(event.windows_key_code))
+  if (!autocomplete_popup_->isInterestedInEventForKey(event.key_code))
     return false;
 
   if (autocomplete_popup_->handleKeyEvent(MakePlatformKeyboardEvent(event))) {
 #if defined(OS_WIN)
       // We need to ignore the next CHAR event after this otherwise pressing
       // enter when selecting an item in the menu will go to the page.
-      if (WebInputEvent::RAW_KEY_DOWN == event.type)
+      if (WebInputEvent::KEY_DOWN == event.type)
         suppress_next_keypress_event_ = true;
 #endif
       return true;
     }
 
   return false;
 }
   
 bool WebViewImpl::CharEvent(const WebKeyboardEvent& event) {
   DCHECK(event.type == WebInputEvent::CHAR);
@@ skipping 113 matching lines @@
 
 bool WebViewImpl::KeyEventDefault(const WebKeyboardEvent& event) {
   Frame* frame = GetFocusedWebCoreFrame();
   if (!frame)
     return false;
 
   switch (event.type) {
     case WebInputEvent::CHAR: {
 #if defined(OS_WIN)
       // TODO(pinkerton): hook this up for non-win32
-      if (event.windows_key_code == VK_SPACE) {
+      if (event.key_code == VK_SPACE) {
         int key_code = ((event.modifiers & WebInputEvent::SHIFT_KEY) ?
                          VK_PRIOR : VK_NEXT);
         return ScrollViewWithKeyboard(key_code);
       }
 #endif
       break;
     }
 
-    case WebInputEvent::RAW_KEY_DOWN: {
+    case WebInputEvent::KEY_DOWN: {
       if (event.modifiers == WebInputEvent::CTRL_KEY) {
-        switch (event.windows_key_code) {
+        switch (event.key_code) {
           case 'A':
             GetFocusedFrame()->SelectAll();
             return true;
 #if defined(OS_WIN)
           case VK_INSERT:
 #endif
           case 'C':
             GetFocusedFrame()->Copy();
             return true;
           // Match FF behavior in the sense that Ctrl+home/end are the only Ctrl
           // key combinations which affect scrolling. Safari is buggy in the
           // sense that it scrolls the page for all Ctrl+scrolling key
           // combinations. For e.g. Ctrl+pgup/pgdn/up/down, etc.
 #if defined(OS_WIN)
           case VK_HOME:
           case VK_END:
 #endif
             break;
           default:
             return false;
         }
       }
 #if defined(OS_WIN)
       if (!event.system_key) {
-        return ScrollViewWithKeyboard(event.windows_key_code);
+        return ScrollViewWithKeyboard(event.key_code);
       }
 #endif
       break;
     }
 
     default:
       break;
   }
   return false;
 }
@@ skipping 224 matching lines @@
 
     case WebInputEvent::MOUSE_DOWN:
     case WebInputEvent::MOUSE_DOUBLE_CLICK:
       MouseDown(*static_cast<const WebMouseEvent*>(input_event));
       break;
 
     case WebInputEvent::MOUSE_UP:
       MouseUp(*static_cast<const WebMouseEvent*>(input_event));
       break;
 
-    case WebInputEvent::RAW_KEY_DOWN:
     case WebInputEvent::KEY_DOWN:
     case WebInputEvent::KEY_UP:
       handled = KeyEvent(*static_cast<const WebKeyboardEvent*>(input_event));
       break;
 
     case WebInputEvent::CHAR:
       handled = CharEvent(*static_cast<const WebKeyboardEvent*>(input_event));
       break;
     default:
       handled = false;
@@ skipping 240 matching lines @@
   }
 }
 
 void WebViewImpl::SetInitialFocus(bool reverse) {
   if (page_.get()) {
     // So RestoreFocus does not focus anything when it is called.
     ReleaseFocusReferences();
 
     // Since we don't have a keyboard event, we'll create one.
     WebKeyboardEvent keyboard_event;
-    keyboard_event.type = WebInputEvent::RAW_KEY_DOWN;
+    keyboard_event.type = WebInputEvent::KEY_DOWN;
     if (reverse)
       keyboard_event.modifiers = WebInputEvent::SHIFT_KEY;
     // VK_TAB which is only defined on Windows.
-    keyboard_event.windows_key_code = 0x09;
+    keyboard_event.key_code = 0x09;
     MakePlatformKeyboardEvent platform_event(keyboard_event);
     // We have to set the key type explicitly to avoid an assert in the
     // KeyboardEvent constructor.
+    platform_event.SetKeyType(PlatformKeyboardEvent::RawKeyDown);
     RefPtr<KeyboardEvent> webkit_event = KeyboardEvent::create(platform_event,
                                                                NULL);
     page()->focusController()->setInitialFocus(
         reverse ? WebCore::FocusDirectionBackward :
                   WebCore::FocusDirectionForward,
         webkit_event.get());
   }
 }
 
 // Releases references used to restore focus.
@@ skipping 467 matching lines @@
   Frame* frame = page_->focusController()->focusedFrame();
   if (!frame)
     return NULL;
 
   Document* document = frame->document();
   if (!document)
     return NULL;
 
   return document->focusedNode();
 }