Remove PlatformKeyboardEvent

third_party/WebKit/Source/core/editing/EditingBehavior.cpp

 /*
  * Copyright (C) 2006, 2007 Apple, Inc.  All rights reserved.
  * Copyright (C) 2012 Google, Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 10 matching lines @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/editing/EditingBehavior.h"
 
 #include "core/events/KeyboardEvent.h"
 #include "platform/KeyboardCodes.h"
-#include "platform/PlatformKeyboardEvent.h"
+#include "public/platform/WebInputEvent.h"
 
 namespace blink {
 
 namespace {
 
 //
 // The below code was adapted from the WebKit file webview.cpp
 //
 
-const unsigned CtrlKey = 1 << 0;
-const unsigned AltKey = 1 << 1;
-const unsigned ShiftKey = 1 << 2;
-const unsigned MetaKey = 1 << 3;
+const unsigned CtrlKey = WebInputEvent::ControlKey;
+const unsigned AltKey = WebInputEvent::AltKey;
+const unsigned ShiftKey = WebInputEvent::ShiftKey;
+const unsigned MetaKey = WebInputEvent::MetaKey;
 #if OS(MACOSX)
 // Aliases for the generic key defintions to make kbd shortcuts definitions more
 // readable on OS X.
 const unsigned OptionKey  = AltKey;
 
 // Do not use this constant for anything but cursor movement commands. Keys
 // with cmd set have their |isSystemKey| bit set, so chances are the shortcut
 // will not be executed. Another, less important, reason is that shortcuts
 // defined in the layoutObject do not blink the menu item that they triggered. See
 // http://crbug.com/25856 and the bugs linked from there for details.
@@ skipping 146 matching lines @@
         if (key == entry.key && modifiers == entry.modifiers)
             return entry.name;
     }
     return nullptr;
 }
 
 } // anonymous namespace
 
 const char* EditingBehavior::interpretKeyEvent(const KeyboardEvent& event) const
 {
-    const PlatformKeyboardEvent* keyEvent = event.keyEvent();
+    const WebKeyboardEvent* keyEvent = event.keyEvent();
     if (!keyEvent)
         return "";
 
     static HashMap<int, const char*>* keyDownCommandsMap = nullptr;
     static HashMap<int, const char*>* keyPressCommandsMap = nullptr;
 
     if (!keyDownCommandsMap) {
         keyDownCommandsMap = new HashMap<int, const char*>;
         keyPressCommandsMap = new HashMap<int, const char*>;
 
         for (const auto& entry : kKeyboardCodeKeyDownEntries) {
             keyDownCommandsMap->set(entry.modifiers << 16 | entry.virtualKey, entry.name);
         }
 
         for (const auto& entry : kKeyboardCodeKeyPressEntries) {
             keyPressCommandsMap->set(entry.modifiers << 16 | entry.charCode, entry.name);
         }
     }
 
-    unsigned modifiers = 0;
-    if (keyEvent->shiftKey())
-        modifiers |= ShiftKey;
-    if (keyEvent->altKey())
-        modifiers |= AltKey;
-    if (keyEvent->ctrlKey())
-        modifiers |= CtrlKey;
-    if (keyEvent->metaKey())
-        modifiers |= MetaKey;
+    unsigned modifiers = keyEvent->modifiers & (ShiftKey | AltKey | CtrlKey | MetaKey);
 
-    if (keyEvent->type() == PlatformEvent::RawKeyDown) {
+    if (keyEvent->type == WebInputEvent::RawKeyDown) {
         int mapKey = modifiers << 16 | event.keyCode();
         const char* name = mapKey ? keyDownCommandsMap->get(mapKey) : nullptr;
         if (!name)
-            name = lookupCommandNameFromDomKeyKeyDown(keyEvent->key(), modifiers);
+            name = lookupCommandNameFromDomKeyKeyDown(event.key(), modifiers);
         return name;
     }
 
     int mapKey = modifiers << 16 | event.charCode();
     return mapKey ? keyPressCommandsMap->get(mapKey) : 0;
 }
 
 bool EditingBehavior::shouldInsertCharacter(const KeyboardEvent& event) const
 {
-    if (event.keyEvent()->text().length() != 1)
+    if (event.keyEvent()->text[1] != 0)
         return true;
 
     // On Gtk/Linux, it emits key events with ASCII text and ctrl on for ctrl-<x>.
     // In Webkit, EditorClient::handleKeyboardEvent in
     // WebKit/gtk/WebCoreSupport/EditorClientGtk.cpp drop such events.
     // On Mac, it emits key events with ASCII text and meta on for Command-<x>.
     // These key events should not emit text insert event.
     // Alt key would be used to insert alternative character, so we should let
     // through. Also note that Ctrl-Alt combination equals to AltGr key which is
     // also used to insert alternative character.
     // http://code.google.com/p/chromium/issues/detail?id=10846
     // Windows sets both alt and meta are on when "Alt" key pressed.
     // http://code.google.com/p/chromium/issues/detail?id=2215
     // Also, we should not rely on an assumption that keyboards don't
     // send ASCII characters when pressing a control key on Windows,
     // which may be configured to do it so by user.
     // See also http://en.wikipedia.org/wiki/Keyboard_Layout
     // FIXME(ukai): investigate more detail for various keyboard layout.
-    UChar ch = event.keyEvent()->text()[0U];
+    UChar ch = event.keyEvent()->text[0U];
 
     // Don't insert null or control characters as they can result in
     // unexpected behaviour
     if (ch < ' ')
         return false;
 #if !OS(WIN)
     // Don't insert ASCII character if ctrl w/o alt or meta is on.
     // On Mac, we should ignore events when meta is on (Command-<x>).
     if (ch < 0x80) {
-        if (event.keyEvent()->ctrlKey() && !event.keyEvent()->altKey())
+        if (event.ctrlKey() && !event.altKey())
             return false;
 #if OS(MACOSX)
-        if (event.keyEvent()->metaKey())
+        if (event.metaKey())
             return false;
 #endif
     }
 #endif
 
     return true;
 }
 } // namespace blink