Sets X11WholeScreenMoveLoop as OverrideDispatcher to get events even before grab is granted

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/extensions/XInput2.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/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/event_utils.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/desktop_aura/desktop_window_tree_host_x11.h"
 #include "ui/views/widget/widget.h"
 
 namespace views {
 
 namespace {
 
 // The minimum alpha before we declare a pixel transparent when searching in
 // our source image.
 const uint32 kMinAlpha = 32;
 const unsigned char kDragWidgetOpacity = 0xc0;
@@ skipping 36 matching lines @@
   weak_factory_.InvalidateWeakPtrs();
   DCHECK_EQ(MotionNotify, last_xmotion_.type);
   delegate_->OnMouseMovement(&last_xmotion_);
   last_xmotion_.type = LASTEvent;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowTreeHostLinux, ui::PlatformEventDispatcher implementation:
 
 bool X11WholeScreenMoveLoop::CanDispatchEvent(const ui::PlatformEvent& event) {
-  return event->xany.window == grab_input_window_;
+  return in_move_loop_;
 }
 
 uint32_t X11WholeScreenMoveLoop::DispatchEvent(const ui::PlatformEvent& event) {
+  if (!in_move_loop_)
+    return ui::POST_DISPATCH_PERFORM_DEFAULT;
   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: {
+      LOG(INFO) << "MotionNotify in " << grab_input_window_;
       if (drag_widget_.get()) {
         gfx::Screen* screen = gfx::Screen::GetNativeScreen();
         gfx::Point location = gfx::ToFlooredPoint(
             screen->GetCursorScreenPoint() - drag_offset_);
         drag_widget_->SetBounds(gfx::Rect(location, drag_image_.size()));
         drag_widget_->StackAtTop();
       }
       last_xmotion_ = xev->xmotion;
       if (!weak_factory_.HasWeakPtrs()) {
         // Post a task to dispatch mouse movement event when control returns to
         // the message loop. This allows smoother dragging since the events are
         // dispatched without waiting for the drag widget updates.
         base::MessageLoopForUI::current()->PostTask(
             FROM_HERE,
             base::Bind(&X11WholeScreenMoveLoop::DispatchMouseMovement,
                        weak_factory_.GetWeakPtr()));
       }
-      break;
+      return ui::POST_DISPATCH_NONE;
     }
     case ButtonRelease: {
       if (xev->xbutton.button == Button1) {
+      LOG(INFO) << "Release in " << grab_input_window_;
         // Assume that drags are being done with the left mouse button. Only
         // break the drag if the left mouse button was released.
         DispatchMouseMovement();
         delegate_->OnMouseReleased();
       }
-      break;
+      return ui::POST_DISPATCH_NONE;
     }
     case KeyPress: {
       if (ui::KeyboardCodeFromXKeyEvent(xev) == ui::VKEY_ESCAPE) {
         canceled_ = true;
         EndMoveLoop();
+        return ui::POST_DISPATCH_NONE;
       }
       break;
     }
+    case GenericEvent: {
+      ui::EventType type = ui::EventTypeFromNative(xev);
+      switch (type) {
+        case ui::ET_MOUSE_MOVED:
+        case ui::ET_MOUSE_DRAGGED:
+        case ui::ET_MOUSE_RELEASED: {
+          LOG(INFO) << "XI event " << type << " in " << grab_input_window_;
+          XEvent xevent = {0};
+          if (type == ui::ET_MOUSE_RELEASED) {
+            xevent.type = ButtonRelease;
+            xevent.xbutton.button = ui::EventButtonFromNative(xev);
+          } else {
+            xevent.type = MotionNotify;
+          }
+          xevent.xany.display = xev->xgeneric.display;
+          xevent.xany.window = grab_input_window_;
+          // The fields used below are in the same place for all of events
+          // above. Using xmotion from XEvent's unions to avoid repeating
+          // the code.
+          xevent.xmotion.root = DefaultRootWindow(xev->xgeneric.display);
+          xevent.xmotion.time = ui::EventTimeFromNative(xev).InMilliseconds();
+          gfx::Point point(ui::EventSystemLocationFromNative(xev));
+          xevent.xmotion.x_root = point.x();
+          xevent.xmotion.y_root = point.y();
+          DispatchEvent(&xevent);

[sadrul, 2014/04/25 17:19:50]

It would be really great if we didn't have to recreate an XEvent here.

[varkha, 2014/04/25 18:00:35]

We talked about this offline. I think it would be more complicated than it
already is because of the way we post a task to throttle the dispatch of the
motion events.

+          return ui::POST_DISPATCH_NONE;
+        }
+        default:
+          break;
+      }
+    }
   }
 
-  return ui::POST_DISPATCH_STOP_PROPAGATION;
+  return (event->xany.window == grab_input_window_) ?
+      ui::POST_DISPATCH_NONE : ui::POST_DISPATCH_PERFORM_DEFAULT;
 }
 
 bool X11WholeScreenMoveLoop::RunMoveLoop(aura::Window* source,
                                          gfx::NativeCursor cursor) {
   DCHECK(!in_move_loop_);  // Can only handle one nested loop at a time.
 
   // 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());
 
     grab_input_window_ = CreateDragInputWindow(gfx::GetXDisplay());
     // 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)) {
     XDestroyWindow(gfx::GetXDisplay(), grab_input_window_);
     return false;
   }
 
-  ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
+  scoped_ptr<ui::ScopedEventDispatcher> old_dispatcher =
+      nested_dispatcher_.Pass();
+  nested_dispatcher_ =
+         ui::PlatformEventSource::GetInstance()->OverrideDispatcher(this);
   if (!drag_image_.isNull() && CheckIfIconValid())
     CreateDragImageWindow();
 
   // We are handling a mouse drag outside of the aura::RootWindow system. We
   // must manually make aura think that the mouse button is pressed so that we
   // don't draw extraneous tooltips.
   aura::Env* env = aura::Env::GetInstance();
   if (!env->IsMouseButtonDown()) {
     env->set_mouse_button_flags(ui::EF_LEFT_MOUSE_BUTTON);
     should_reset_mouse_flags_ = true;
   }
 
   in_move_loop_ = true;
   canceled_ = false;
   base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
   base::MessageLoop::ScopedNestableTaskAllower allow_nested(loop);
   base::RunLoop run_loop;
   quit_closure_ = run_loop.QuitClosure();
   run_loop.Run();
+  nested_dispatcher_ = old_dispatcher.Pass();
   return !canceled_;
 }
 
 void X11WholeScreenMoveLoop::UpdateCursor(gfx::NativeCursor cursor) {
   if (in_move_loop_) {
     // If we're still in the move loop, regrab the pointer with the updated
     // cursor. Note: we can be called from handling an XdndStatus message after
     // EndMoveLoop() was called, but before we return from the nested RunLoop.
     GrabPointerAndKeyboard(cursor);
   }
@@ skipping 15 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);
 
-  ui::PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
+  LOG(INFO) << "Ungrab";
   drag_widget_.reset();
   delegate_->OnMoveLoopEnded();
   XDestroyWindow(display, grab_input_window_);
+  grab_input_window_ = None;
+  // Restore the previous dispatcher.
+  nested_dispatcher_.reset();
 
   in_move_loop_ = false;
   quit_closure_.Run();
 }
 
 void X11WholeScreenMoveLoop::SetDragImage(const gfx::ImageSkia& image,
                                           gfx::Vector2dF offset) {
   drag_image_ = image;
   drag_offset_ = offset;
   // Reset the Y offset, so that the drag-image is always just below the cursor,
   // so that it is possible to see where the cursor is going.
   drag_offset_.set_y(0.f);
 }
 
 bool X11WholeScreenMoveLoop::GrabPointerAndKeyboard(gfx::NativeCursor cursor) {
   XDisplay* display = gfx::GetXDisplay();
   XGrabServer(display);
 
   XUngrabPointer(display, CurrentTime);
+  LOG(INFO) << "Ungrab";
+
   int ret = XGrabPointer(
       display,
       grab_input_window_,
       False,
       ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
       GrabModeAsync,
       GrabModeAsync,
       None,
       cursor.platform(),
       CurrentTime);
   if (ret != GrabSuccess) {
     DLOG(ERROR) << "Grabbing pointer for dragging failed: "
                 << ui::GetX11ErrorString(display, ret);
   } else {
     XUngrabKeyboard(display, CurrentTime);
     ret = XGrabKeyboard(
         display,
         grab_input_window_,
         False,
         GrabModeAsync,
         GrabModeAsync,
         CurrentTime);
     if (ret != GrabSuccess) {
       DLOG(ERROR) << "Grabbing keyboard for dragging failed: "
                   << ui::GetX11ErrorString(display, ret);
     }
   }
+  LOG(INFO) << "Grab " << grab_input_window_;
 
   XUngrabServer(display);
   return ret == GrabSuccess;
 }
 
 Window X11WholeScreenMoveLoop::CreateDragInputWindow(XDisplay* display) {
   // Creates an invisible, InputOnly toplevel window. This window will receive
   // all mouse movement for drags. It turns out that normal windows doing a
   // grab doesn't redirect pointer motion events if the pointer isn't over the
   // grabbing window. But InputOnly windows are able to grab everything. This
@@ skipping 60 matching lines @@
     for (int x = 0; x < in_bitmap->width(); ++x) {
       if (SkColorGetA(in_row[x]) > kMinAlpha)
         return true;
     }
   }
 
   return false;
 }
 
 }  // namespace views