Split the event library into a cross-platform and native part. Part 1.

ui/events/x/events_x_unittest.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 <cstring>
 #include <set>
 
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/XKBlib.h>
 
 // Generically-named #defines from Xlib that conflict with symbols in GTest.
 #undef Bool
 #undef None
 
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_utils.h"
+#include "ui/events/platform/platform_event_builder.h"
 #include "ui/events/test/events_test_utils.h"
 #include "ui/events/test/events_test_utils_x11.h"
 #include "ui/events/x/device_data_manager_x11.h"
 #include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/point.h"
 
 namespace ui {
 
 namespace {
 
@@ skipping 33 matching lines @@
 }
 
 // Returns true if the keysym maps to a KeyEvent with the EF_FUNCTION_KEY
 // flag set, or the keysym maps to a zero key code.
 bool HasFunctionKeyFlagSetIfSupported(Display* display, int x_keysym) {
   XEvent event;
   int x_keycode = XKeysymToKeycode(display, x_keysym);
   // Exclude keysyms for which the server has no corresponding keycode.
   if (x_keycode) {
     InitKeyEvent(display, &event, true, x_keycode, 0);
-    ui::KeyEvent ui_key_event(&event);
+    ui::KeyEvent ui_key_event = PlatformEventBuilder::BuildKeyEvent(&event);
     return (ui_key_event.flags() & ui::EF_FUNCTION_KEY);
   }
   return true;
 }
 
 }  // namespace
 
 class EventsXTest : public testing::Test {
  public:
   EventsXTest() {}
@@ skipping 108 matching lines @@
   EXPECT_EQ("230,240", ui::EventSystemLocationFromNative(&event).ToString());
 }
 
 TEST_F(EventsXTest, ClickCount) {
   XEvent event;
   gfx::Point location(5, 10);
 
   for (int i = 1; i <= 3; ++i) {
     InitButtonEvent(&event, true, location, 1, 0);
     {
-      MouseEvent mouseev(&event);
+      MouseEvent mouseev = PlatformEventBuilder::BuildMouseEvent(&event);
       EXPECT_EQ(ui::ET_MOUSE_PRESSED, mouseev.type());
       EXPECT_EQ(i, mouseev.GetClickCount());
     }
 
     InitButtonEvent(&event, false, location, 1, 0);
     {
-      MouseEvent mouseev(&event);
+      MouseEvent mouseev = PlatformEventBuilder::BuildMouseEvent(&event);
       EXPECT_EQ(ui::ET_MOUSE_RELEASED, mouseev.type());
       EXPECT_EQ(i, mouseev.GetClickCount());
     }
   }
 }
 
 #if defined(USE_XI2_MT)
 TEST_F(EventsXTest, TouchEventBasic) {
   std::vector<unsigned int> devices;
   devices.push_back(0);
@@ skipping 227 matching lines @@
     { false, XK_A },
   };
 
   for (size_t k = 0; k < arraysize(keys); ++k) {
     int x_keycode = XKeysymToKeycode(display, keys[k].x_keysym);
     // Exclude keysyms for which the server has no corresponding keycode.
     if (x_keycode) {
       InitKeyEvent(display, &event, true, x_keycode, 0);
       // int keysym = XLookupKeysym(&event.xkey, 0);
       // if (keysym) {
-      ui::KeyEvent ui_key_event(&event);
+      ui::KeyEvent ui_key_event = PlatformEventBuilder::BuildKeyEvent(&event);
       EXPECT_EQ(keys[k].is_numpad_key ? ui::EF_NUMPAD_KEY : 0,
                 ui_key_event.flags() & ui::EF_NUMPAD_KEY);
     }
   }
 }
 
 TEST_F(EventsXTest, FunctionKeyEvents) {
   Display* display = gfx::GetXDisplay();
 
   // Min  function key code minus 1.
@@ skipping 134 matching lines @@
   Display* display = gfx::GetXDisplay();
 
   unsigned int state_to_be_fabricated[] = {
     0, ShiftMask, LockMask, ShiftMask | LockMask,
   };
   for (size_t i = 0; i < arraysize(state_to_be_fabricated); ++i) {
     unsigned int state = state_to_be_fabricated[i];
     for (int is_char = 0; is_char < 2; ++is_char) {
       XEvent x_event;
       InitKeyEvent(display, &x_event, true, 0, state);
-      ui::KeyEvent key_event(&x_event);
+      ui::KeyEvent key_event = PlatformEventBuilder::BuildKeyEvent(&x_event);
       if (is_char) {
         KeyEventTestApi test_event(&key_event);
         test_event.set_is_char(true);
       }
       EXPECT_TRUE(key_event.flags() & ui::EF_IME_FABRICATED_KEY);
     }
   }
 
   unsigned int state_to_be_not_fabricated[] = {
     ControlMask, Mod1Mask, Mod2Mask, ShiftMask | ControlMask,
   };
   for (size_t i = 0; i < arraysize(state_to_be_not_fabricated); ++i) {
     unsigned int state = state_to_be_not_fabricated[i];
     for (int is_char = 0; is_char < 2; ++is_char) {
       XEvent x_event;
       InitKeyEvent(display, &x_event, true, 0, state);
-      ui::KeyEvent key_event(&x_event);
+      ui::KeyEvent key_event = PlatformEventBuilder::BuildKeyEvent(&x_event);
       if (is_char) {
         KeyEventTestApi test_event(&key_event);
         test_event.set_is_char(true);
       }
       EXPECT_FALSE(key_event.flags() & ui::EF_IME_FABRICATED_KEY);
     }
   }
 }
 #endif
 
 }  // namespace ui