wayland patch for inspection

ui/base/ime/fake_input_method.cc

 // 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.
 
 #include "ui/base/ime/fake_input_method.h"
 
 #include "base/logging.h"
 #include "base/strings/string16.h"
 #include "ui/base/events/event.h"
 #include "ui/base/events/event_constants.h"
 #include "ui/base/events/event_utils.h"
 #include "ui/base/glib/glib_integers.h"
 #include "ui/base/ime/input_method_delegate.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/base/keycodes/keyboard_code_conversion.h"
 
-#if defined(USE_X11)
+#if defined(USE_WAYLAND)
+#include "ui/base/keycodes/keyboard_code_conversion_wayland.h"
+#elif defined(USE_X11)
 #include <X11/X.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include "ui/base/keycodes/keyboard_code_conversion_x.h"
 #endif
 
 namespace {
 
-#if defined(USE_X11)
+#if defined(USE_WAYLAND)
+#elif defined(USE_X11)
 uint32 EventFlagsFromXFlags(unsigned int flags) {
   return (flags & LockMask ? ui::EF_CAPS_LOCK_DOWN : 0U) |
       (flags & ControlMask ? ui::EF_CONTROL_DOWN : 0U) |
       (flags & ShiftMask ? ui::EF_SHIFT_DOWN : 0U) |
       (flags & Mod1Mask ? ui::EF_ALT_DOWN : 0U);
 }
 #endif
 
 }  // namespace
 
@@ skipping 27 matching lines @@
 #if defined(OS_WIN)
   if (native_event.message == WM_CHAR) {
     if (text_input_client_) {
       text_input_client_->InsertChar(ui::KeyboardCodeFromNative(native_event),
                                      ui::EventFlagsFromNative(native_event));
       handled = true;
     }
   } else {
     handled = delegate_->DispatchKeyEventPostIME(native_event);
   }
+#elif defined(USE_WAYLAND)
+  DCHECK(native_event);
+  if (EventTypeFromNative(native_event) == ET_KEY_RELEASED) {
+    // On key release, just dispatch it.
+    delegate_->DispatchKeyEventPostIME(native_event);
+  } else {
+    const uint32 state = EventFlagsFromNative(native_event);
+    // Send a RawKeyDown event first,
+    delegate_->DispatchKeyEventPostIME(native_event);
+    if (text_input_client_) {
+      // then send a Char event via ui::TextInputClient.
+      const KeyboardCode key_code = ui::KeyboardCodeFromNative(native_event);
+      uint16 ch = 0;
+      if (!(state & ui::EF_CONTROL_DOWN))
+        ch = ui::GetCharacterFromWaylandEvent(native_event);
+      if (!ch)
+        ch = ui::GetCharacterFromKeyCode(key_code, state);
+      if (ch)
+        text_input_client_->InsertChar(ch, state);
+    }
+  }
 #elif defined(USE_X11)
   DCHECK(native_event);
   if (native_event->type == KeyRelease) {
     // On key release, just dispatch it.
     handled = delegate_->DispatchKeyEventPostIME(native_event);
   } else {
     const uint32 state = EventFlagsFromXFlags(native_event->xkey.state);
     // Send a RawKeyDown event first,
     handled = delegate_->DispatchKeyEventPostIME(native_event);
     if (text_input_client_) {
@@ skipping 63 matching lines @@
 
 void FakeInputMethod::AddObserver(InputMethodObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void FakeInputMethod::RemoveObserver(InputMethodObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 }  // namespace ui