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

ui/platform_window/x11/x11_window.cc

 // Copyright 2014 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/platform_window/x11/x11_window.h"
 
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
+#include "ui/events/platform/platform_event_builder.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/events/platform/x11/x11_event_source.h"
 #include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/x/x11_atom_cache.h"
 #include "ui/gfx/x/x11_types.h"
 #include "ui/platform_window/platform_window_delegate.h"
 
 namespace ui {
@@ skipping 42 matching lines @@
   xwindow_ = None;
 }
 
 void X11Window::ProcessXInput2Event(XEvent* xev) {
   if (!TouchFactory::GetInstance()->ShouldProcessXI2Event(xev))
     return;
   EventType event_type = EventTypeFromNative(xev);
   switch (event_type) {
     case ET_KEY_PRESSED:
     case ET_KEY_RELEASED: {
-      KeyEvent key_event(xev);
+      KeyEvent key_event = PlatformEventBuilder::BuildKeyEvent(xev);
       delegate_->DispatchEvent(&key_event);
       break;
     }
     case ET_MOUSE_PRESSED:
     case ET_MOUSE_MOVED:
     case ET_MOUSE_DRAGGED:
     case ET_MOUSE_RELEASED: {
-      MouseEvent mouse_event(xev);
+      MouseEvent mouse_event = PlatformEventBuilder::BuildMouseEvent(xev);
       delegate_->DispatchEvent(&mouse_event);
       break;
     }
     case ET_MOUSEWHEEL: {
-      MouseWheelEvent wheel_event(xev);
+      MouseWheelEvent wheel_event =
+          PlatformEventBuilder::BuildMouseWheelEvent(xev);
       delegate_->DispatchEvent(&wheel_event);
       break;
     }
     case ET_SCROLL_FLING_START:
     case ET_SCROLL_FLING_CANCEL:
     case ET_SCROLL: {
-      ScrollEvent scroll_event(xev);
+      ScrollEvent scroll_event = PlatformEventBuilder::BuildScrollEvent(xev);
       delegate_->DispatchEvent(&scroll_event);
       break;
     }
     case ET_TOUCH_MOVED:
     case ET_TOUCH_PRESSED:
     case ET_TOUCH_CANCELLED:
     case ET_TOUCH_RELEASED: {
-      TouchEvent touch_event(xev);
+      TouchEvent touch_event = PlatformEventBuilder::BuildTouchEvent(xev);
+
+      if (touch_event.type() == ET_TOUCH_PRESSED)
+        IncrementTouchIdRefCount(xev);
+
       delegate_->DispatchEvent(&touch_event);
+
+      ClearTouchIdIfReleased(xev);
       break;
     }
     default:
       break;
   }
 }
 
 void X11Window::Show() {
   if (window_mapped_)
     return;
@@ skipping 137 matching lines @@
 bool X11Window::CanDispatchEvent(const PlatformEvent& event) {
   return FindXEventTarget(event) == xwindow_;
 }
 
 uint32_t X11Window::DispatchEvent(const PlatformEvent& event) {
   XEvent* xev = event;
   switch (xev->type) {
     case EnterNotify: {
       // EnterNotify creates ET_MOUSE_MOVED. Mark as synthesized as this is
       // not real mouse move event.
-      MouseEvent mouse_event(xev);
+      MouseEvent mouse_event = PlatformEventBuilder::BuildMouseEvent(xev);
       CHECK_EQ(ET_MOUSE_MOVED, mouse_event.type());
       mouse_event.set_flags(mouse_event.flags() | EF_IS_SYNTHESIZED);
       delegate_->DispatchEvent(&mouse_event);
       break;
     }
     case LeaveNotify: {
-      MouseEvent mouse_event(xev);
+      MouseEvent mouse_event = PlatformEventBuilder::BuildMouseEvent(xev);
       delegate_->DispatchEvent(&mouse_event);
       break;
     }
 
     case Expose: {
       gfx::Rect damage_rect(xev->xexpose.x,
                             xev->xexpose.y,
                             xev->xexpose.width,
                             xev->xexpose.height);
       delegate_->OnDamageRect(damage_rect);
       break;
     }
 
     case KeyPress:
     case KeyRelease: {
-      KeyEvent key_event(xev);
+      KeyEvent key_event = PlatformEventBuilder::BuildKeyEvent(xev);
       delegate_->DispatchEvent(&key_event);
       break;
     }
 
     case ButtonPress:
     case ButtonRelease: {
       switch (EventTypeFromNative(xev)) {
         case ET_MOUSEWHEEL: {
-          MouseWheelEvent mouseev(xev);
+          MouseWheelEvent mouseev =
+              PlatformEventBuilder::BuildMouseWheelEvent(xev);
           delegate_->DispatchEvent(&mouseev);
           break;
         }
         case ET_MOUSE_PRESSED:
         case ET_MOUSE_RELEASED: {
-          MouseEvent mouseev(xev);
+          MouseEvent mouseev = PlatformEventBuilder::BuildMouseEvent(xev);
           delegate_->DispatchEvent(&mouseev);
           break;
         }
         case ET_UNKNOWN:
           // No event is created for X11-release events for mouse-wheel
           // buttons.
           break;
         default:
           NOTREACHED();
       }
@@ skipping 39 matching lines @@
 
     case GenericEvent: {
       ProcessXInput2Event(xev);
       break;
     }
   }
   return POST_DISPATCH_STOP_PROPAGATION;
 }
 
 }  // namespace ui