Sync ui/events to chromium @ https://codereview.chromium.org/1210203002

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/devices/x11/touch_factory_x11.h"
 #include "ui/events/event.h"
-#include "ui/events/platform/platform_event_builder.h"
+#include "ui/events/event_utils.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/events/platform/platform_event_source.h"
-#include "ui/events/platform/platform_event_utils.h"
-#include "ui/events/platform/x11/touch_factory_x11.h"
 #include "ui/events/platform/x11/x11_event_source.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 {
 
 namespace {
 
@@ skipping 18 matching lines @@
       xdisplay_(gfx::GetXDisplay()),
       xwindow_(None),
       xroot_window_(DefaultRootWindow(xdisplay_)),
       atom_cache_(xdisplay_, kAtomsToCache),
       window_mapped_(false) {
   CHECK(delegate_);
   TouchFactory::SetTouchDeviceListFromCommandLine();
 }
 
 X11Window::~X11Window() {
-  Destroy();
 }
 
 void X11Window::Destroy() {
-  delegate_->OnClosed();
   if (xwindow_ == None)
     return;
 
   // Stop processing events.
   PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
-  XDestroyWindow(xdisplay_, xwindow_);
+  XID xwindow = xwindow_;
+  XDisplay* xdisplay = xdisplay_;
   xwindow_ = None;
+  delegate_->OnClosed();
+  // |this| might be deleted because of the above call.
+
+  XDestroyWindow(xdisplay, xwindow);
 }
 
 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 = PlatformEventBuilder::BuildKeyEvent(xev);
+      KeyEvent key_event(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 = PlatformEventBuilder::BuildMouseEvent(xev);
+      MouseEvent mouse_event(xev);
       delegate_->DispatchEvent(&mouse_event);
       break;
     }
     case ET_MOUSEWHEEL: {
-      MouseWheelEvent wheel_event =
-          PlatformEventBuilder::BuildMouseWheelEvent(xev);
+      MouseWheelEvent wheel_event(xev);
       delegate_->DispatchEvent(&wheel_event);
       break;
     }
     case ET_SCROLL_FLING_START:
     case ET_SCROLL_FLING_CANCEL:
     case ET_SCROLL: {
-      ScrollEvent scroll_event = PlatformEventBuilder::BuildScrollEvent(xev);
+      ScrollEvent scroll_event(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 = PlatformEventBuilder::BuildTouchEvent(xev);
-
-      if (touch_event.type() == ET_TOUCH_PRESSED)
-        IncrementTouchIdRefCount(xev);
-
+      TouchEvent touch_event(xev);
       delegate_->DispatchEvent(&touch_event);
-
-      ClearTouchIdIfReleased(xev);
       break;
     }
     default:
       break;
   }
 }
 
 void X11Window::Show() {
   if (window_mapped_)
     return;
@@ skipping 50 matching lines @@
   XSetWMProtocols(xdisplay_, xwindow_, protocols, 2);
 
   // We need a WM_CLIENT_MACHINE and WM_LOCALE_NAME value so we integrate with
   // the desktop environment.
   XSetWMProperties(
       xdisplay_, xwindow_, NULL, NULL, NULL, 0, NULL, NULL, NULL);
 
   // Likewise, the X server needs to know this window's pid so it knows which
   // program to kill if the window hangs.
   // XChangeProperty() expects "pid" to be long.
-  COMPILE_ASSERT(sizeof(long) >= sizeof(pid_t), pid_t_bigger_than_long);
+  static_assert(sizeof(long) >= sizeof(pid_t),
+                "pid_t should not be larger than long");
   long pid = getpid();
   XChangeProperty(xdisplay_,
                   xwindow_,
                   atom_cache_.GetAtom("_NET_WM_PID"),
                   XA_CARDINAL,
                   32,
                   PropModeReplace,
                   reinterpret_cast<unsigned char*>(&pid),
                   1);
   // Before we map the window, set size hints. Otherwise, some window managers
   // will ignore toplevel XMoveWindow commands.
   XSizeHints size_hints;
   size_hints.flags = PPosition | PWinGravity;
   size_hints.x = requested_bounds_.x();
   size_hints.y = requested_bounds_.y();
   // Set StaticGravity so that the window position is not affected by the
   // frame width when running with window manager.
   size_hints.win_gravity = StaticGravity;
   XSetWMNormalHints(xdisplay_, xwindow_, &size_hints);
 
+  // TODO(sky): provide real scale factor.
   delegate_->OnAcceleratedWidgetAvailable(xwindow_);
 
   XMapWindow(xdisplay_, xwindow_);
 
   // We now block until our window is mapped. Some X11 APIs will crash and
   // burn if passed |xwindow_| before the window is mapped, and XMapWindow is
   // asynchronous.
   if (X11EventSource::GetInstance())
     X11EventSource::GetInstance()->BlockUntilWindowMapped(xwindow_);
   window_mapped_ = true;
@@ skipping 36 matching lines @@
 void X11Window::Maximize() {}
 
 void X11Window::Minimize() {}
 
 void X11Window::Restore() {}
 
 void X11Window::SetCursor(PlatformCursor cursor) {}
 
 void X11Window::MoveCursorTo(const gfx::Point& location) {}
 
+void X11Window::ConfineCursorToBounds(const gfx::Rect& bounds) {
+}
+
 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 = PlatformEventBuilder::BuildMouseEvent(xev);
+      MouseEvent mouse_event(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 = PlatformEventBuilder::BuildMouseEvent(xev);
+      MouseEvent mouse_event(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 = PlatformEventBuilder::BuildKeyEvent(xev);
+      KeyEvent key_event(xev);
       delegate_->DispatchEvent(&key_event);
       break;
     }
 
     case ButtonPress:
     case ButtonRelease: {
       switch (EventTypeFromNative(xev)) {
         case ET_MOUSEWHEEL: {
-          MouseWheelEvent mouseev =
-              PlatformEventBuilder::BuildMouseWheelEvent(xev);
+          MouseWheelEvent mouseev(xev);
           delegate_->DispatchEvent(&mouseev);
           break;
         }
         case ET_MOUSE_PRESSED:
         case ET_MOUSE_RELEASED: {
-          MouseEvent mouseev = PlatformEventBuilder::BuildMouseEvent(xev);
+          MouseEvent mouseev(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