x11: Move X event handling out of the message-pump.

ui/views/widget/desktop_aura/x11_whole_screen_move_loop.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/views/widget/desktop_aura/x11_whole_screen_move_loop.h"
 
 #include <X11/Xlib.h>
 // Get rid of a macro from Xlib.h that conflicts with Aura's RootWindow class.
 #undef RootWindow
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_pump_x11.h"
 #include "base/run_loop.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
+#include "ui/events/platform/x11/x11_event_source.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/widget/widget.h"
 
 namespace views {
 
 namespace {
 
 // The minimum alpha before we declare a pixel transparent when searching in
@@ skipping 25 matching lines @@
     : delegate_(delegate),
       in_move_loop_(false),
       should_reset_mouse_flags_(false),
       grab_input_window_(None),
       weak_factory_(this) {
   last_xmotion_.type = LASTEvent;
 }
 
 X11WholeScreenMoveLoop::~X11WholeScreenMoveLoop() {}
 
-////////////////////////////////////////////////////////////////////////////////
-// DesktopWindowTreeHostLinux, MessagePumpDispatcher implementation:
-
 void X11WholeScreenMoveLoop::DispatchMouseMovement() {
   if (!weak_factory_.HasWeakPtrs())
     return;
   weak_factory_.InvalidateWeakPtrs();
   DCHECK_EQ(MotionNotify, last_xmotion_.type);
   delegate_->OnMouseMovement(&last_xmotion_);
   last_xmotion_.type = LASTEvent;
 }
 
-uint32_t X11WholeScreenMoveLoop::Dispatch(const base::NativeEvent& event) {
+////////////////////////////////////////////////////////////////////////////////
+// DesktopWindowTreeHostLinux, ui::PlatformEventDispatcher implementation:
+
+bool X11WholeScreenMoveLoop::CanDispatchEvent(const ui::PlatformEvent& event) {
+  return event->xany.window == grab_input_window_;
+}
+
+uint32_t X11WholeScreenMoveLoop::DispatchEvent(const ui::PlatformEvent& event) {
   XEvent* xev = event;
 
   // Note: the escape key is handled in the tab drag controller, which has
   // keyboard focus even though we took pointer grab.
   switch (xev->type) {
     case MotionNotify: {
       if (drag_widget_.get()) {
         gfx::Screen* screen = gfx::Screen::GetNativeScreen();
         gfx::Point location = gfx::ToFlooredPoint(
             screen->GetCursorScreenPoint() - drag_offset_);
@@ skipping 21 matching lines @@
       }
       break;
     }
     case KeyPress: {
       if (ui::KeyboardCodeFromXKeyEvent(xev) == ui::VKEY_ESCAPE)
         EndMoveLoop();
       break;
     }
   }
 
-  return POST_DISPATCH_NONE;
+  return ui::POST_DISPATCH_STOP_PROPAGATION;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowTreeHostLinux, aura::client::WindowMoveClient implementation:
 
 bool X11WholeScreenMoveLoop::RunMoveLoop(aura::Window* source,
                                          gfx::NativeCursor cursor) {
   // Start a capture on the host, so that it continues to receive events during
   // the drag. This may be second time we are capturing the mouse events - the
   // first being when a mouse is first pressed. That first capture needs to be
   // released before the call to GrabPointerAndKeyboard below, otherwise it may
   // get released while we still need the pointer grab, which is why we restrict
   // the scope here.
   {
     ScopedCapturer capturer(source->GetHost());
 
     DCHECK(!in_move_loop_);  // Can only handle one nested loop at a time.
     in_move_loop_ = true;
 
     XDisplay* display = gfx::GetXDisplay();
 
     grab_input_window_ = CreateDragInputWindow(display);
     if (!drag_image_.isNull() && CheckIfIconValid())
       CreateDragImageWindow();
-    base::MessagePumpX11::Current()->AddDispatcherForWindow(
-        this, grab_input_window_);
+    ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
     // Releasing ScopedCapturer ensures that any other instance of
     // X11ScopedCapture will not prematurely release grab that will be acquired
     // below.
   }
   // TODO(varkha): Consider integrating GrabPointerAndKeyboard with
   // ScopedCapturer to avoid possibility of logically keeping multiple grabs.
   if (!GrabPointerAndKeyboard(cursor))
     return false;
 
   // We are handling a mouse drag outside of the aura::RootWindow system. We
@@ skipping 38 matching lines @@
 
   // TODO(erg): Is this ungrab the cause of having to click to give input focus
   // on drawn out windows? Not ungrabbing here screws the X server until I kill
   // the chrome process.
 
   // Ungrab before we let go of the window.
   XDisplay* display = gfx::GetXDisplay();
   XUngrabPointer(display, CurrentTime);
   XUngrabKeyboard(display, CurrentTime);
 
-  base::MessagePumpX11::Current()->RemoveDispatcherForWindow(
-      grab_input_window_);
+  ui::PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
   drag_widget_.reset();
   delegate_->OnMoveLoopEnded();
   XDestroyWindow(display, grab_input_window_);
 
   in_move_loop_ = false;
   quit_closure_.Run();
 }
 
 void X11WholeScreenMoveLoop::SetDragImage(const gfx::ImageSkia& image,
                                           gfx::Vector2dF offset) {
@@ skipping 52 matching lines @@
   memset(&swa, 0, sizeof(swa));
   swa.event_mask = ButtonPressMask | ButtonReleaseMask | PointerMotionMask |
                    KeyPressMask | KeyReleaseMask | StructureNotifyMask;
   swa.override_redirect = True;
   Window window = XCreateWindow(display,
                                 DefaultRootWindow(display),
                                 -100, -100, 10, 10,
                                 0, CopyFromParent, InputOnly, CopyFromParent,
                                 attribute_mask, &swa);
   XMapRaised(display, window);
-  base::MessagePumpX11::Current()->BlockUntilWindowMapped(window);
+  ui::X11EventSource::GetInstance()->BlockUntilWindowMapped(window);
   return window;
 }
 
 void X11WholeScreenMoveLoop::CreateDragImageWindow() {
   Widget* widget = new Widget;
   Widget::InitParams params(Widget::InitParams::TYPE_DRAG);
   params.opacity = Widget::InitParams::OPAQUE_WINDOW;
   params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.accept_events = false;
 
@@ skipping 36 matching lines @@
     for (int x = 0; x < in_bitmap->width(); ++x) {
       if (SkColorGetA(in_row[x]) > kMinAlpha)
         return true;
     }
   }
 
   return false;
 }
 
 }  // namespace views