Move CreateFakeXEvent to x11_util.{h,cc}.

ui/base/x/x11_util.cc

 // Copyright (c) 2011 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.
 
 // This file defines utility functions for X11 (Linux only). This code has been
 // ported from XCB since we can't use XCB on Ubuntu while its 32-bit support
 // remains woefully incomplete.
 
 #include "ui/base/x/x11_util.h"
 
 #include <sys/ipc.h>
 #include <sys/shm.h>
 
 #include <list>
 #include <map>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
+#include "ui/base/keycodes/keyboard_code_conversion_x.h"
 #include "ui/base/x/x11_util_internal.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #include <gtk/gtk.h>
 #include "ui/base/gtk/gtk_compat.h"
 #include "ui/base/gtk/gdk_x_compat.h"
@@ skipping 59 matching lines @@
                             max_length, // max length to get
                             False,      // deleted
                             AnyPropertyType,
                             type,
                             format,
                             num_items,
                             &remaining_bytes,
                             property);
 }
 
+// Converts ui::EventType to XKeyEvent state.
+unsigned int XKeyEventState(int flags) {
+  return
+      ((flags & ui::EF_SHIFT_DOWN) ? ShiftMask : 0) |
+      ((flags & ui::EF_CONTROL_DOWN) ? ControlMask : 0) |
+      ((flags & ui::EF_CAPS_LOCK_DOWN) ? LockMask : 0);
+}
+
+// Converts EventType to XKeyEvent type.
+int XKeyEventType(ui::EventType type) {
+  switch (type) {
+    case ui::ET_KEY_PRESSED:
+      return KeyPress;
+    case ui::ET_KEY_RELEASED:
+      return KeyRelease;
+    default:
+      return 0;
+  }
+}
+
+// Converts KeyboardCode to XKeyEvent keycode.
+unsigned int XKeyEventKeyCode(ui::KeyboardCode key_code,
+                              int flags,
+                              Display* display) {
+  const int keysym = XKeysymForWindowsKeyCode(key_code,
+                                              flags & ui::EF_SHIFT_DOWN);
+  // Tests assume the keycode for XK_less is equal to the one of XK_comma,
+  // but XKeysymToKeycode returns 94 for XK_less while it returns 59 for
+  // XK_comma. Here we convert the value for XK_less to the value for XK_comma.
+  return (keysym == XK_less) ? 59 : XKeysymToKeycode(display, keysym);
+}
+
 // A process wide singleton that manages the usage of X cursors.
 class XCursorCache {
  public:
    XCursorCache() {}
   ~XCursorCache() {
     Clear();
   }
 
   Cursor GetCursor(int cursor_shape) {
     // Lookup cursor by attempting to insert a null value, which avoids
@@ skipping 749 matching lines @@
 }
 
 int GetMappedButton(int button) {
   return XButtonMap::GetInstance()->GetMappedButton(button);
 }
 
 void UpdateButtonMap() {
   XButtonMap::GetInstance()->UpdateMapping();
 }
 
+void InitXKeyEventForTesting(EventType type,
+                             KeyboardCode key_code,
+                             int flags,
+                             XEvent* event) {
+  CHECK(event);
+  Display* display = GetXDisplay();
+  XKeyEvent key_event;
+  key_event.type = XKeyEventType(type);
+  CHECK_NE(0, key_event.type);
+  key_event.serial = 0;
+  key_event.send_event = 0;
+  key_event.display = display;
+  key_event.time = 0;
+  key_event.window = 0;
+  key_event.root = 0;
+  key_event.subwindow = 0;
+  key_event.x = 0;
+  key_event.y = 0;
+  key_event.x_root = 0;
+  key_event.y_root = 0;
+  key_event.state = XKeyEventState(flags);
+  key_event.keycode = XKeyEventKeyCode(key_code, flags, display);
+  key_event.same_screen = 1;
+  event->type = key_event.type;
+  event->xkey = key_event;
+}
+
 // ----------------------------------------------------------------------------
 // These functions are declared in x11_util_internal.h because they require
 // XLib.h to be included, and it conflicts with many other headers.
 XRenderPictFormat* GetRenderARGB32Format(Display* dpy) {
   static XRenderPictFormat* pictformat = NULL;
   if (pictformat)
     return pictformat;
 
   // First look for a 32-bit format which ignores the alpha value
   XRenderPictFormat templ;
@@ skipping 110 matching lines @@
       << "request_code " << static_cast<int>(error_event.request_code) << ", "
       << "minor_code " << static_cast<int>(error_event.minor_code)
       << " (" << request_str << ")";
 }
 
 // ----------------------------------------------------------------------------
 // End of x11_util_internal.h
 
 
 }  // namespace ui