Removes grab input window and extra grab and ungrab in X11WholeScreenMoveLoop

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/scoped_event_dispatcher.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
-// our source image.
-const uint32 kMinAlpha = 32;
-const unsigned char kDragWidgetOpacity = 0xc0;
-
-class ScopedCapturer {
- public:
-  explicit ScopedCapturer(aura::WindowTreeHost* host)
-      : host_(host) {
-    host_->SetCapture();
-  }
-
-  ~ScopedCapturer() {
-    host_->ReleaseCapture();
-  }
-
- private:
-  aura::WindowTreeHost* host_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedCapturer);
-};
-
-}  // namespace
-
 X11WholeScreenMoveLoop::X11WholeScreenMoveLoop(
     X11WholeScreenMoveLoopDelegate* delegate)
     : delegate_(delegate),
       in_move_loop_(false),
       should_reset_mouse_flags_(false),
-      grab_input_window_(None),
       canceled_(false),
       weak_factory_(this) {
   last_xmotion_.type = LASTEvent;
 }
 
 X11WholeScreenMoveLoop::~X11WholeScreenMoveLoop() {}
 
 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;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowTreeHostLinux, ui::PlatformEventDispatcher implementation:
 
 bool X11WholeScreenMoveLoop::CanDispatchEvent(const ui::PlatformEvent& event) {
-  return in_move_loop_;
+  NOTREACHED();
+  return true;
 }
 
 uint32_t X11WholeScreenMoveLoop::DispatchEvent(const ui::PlatformEvent& event) {
-  // This method processes all events for the grab_input_window_ as well as
-  // mouse events for all windows while the move loop is active - even before
-  // the grab is granted by X. This allows mouse notification events that were
-  // sent after the capture was requested but before the capture was granted
-  // to be dispatched. It is especially important to process the mouse release
-  // event that should have stopped the drag even if that mouse release happened
-  // before the grab was granted.
+  // This method processes all mouse events for all windows while the move loop
+  // is active.
   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: {
-      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()));
       }
       return ui::POST_DISPATCH_NONE;
     }
     case ButtonRelease: {
       if (xev->xbutton.button == Button1) {
         // 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();
       }
-      return ui::POST_DISPATCH_NONE;
+      // default will end up releasing capture in Widget::OnMouseEvent().

[pkotwicz, 2014/05/12 16:04:29]

Nit: default -> Default

[varkha, 2014/05/20 17:13:35]

Done.

+      return ui::POST_DISPATCH_PERFORM_DEFAULT;
     }
     case KeyPress: {
       if (ui::KeyboardCodeFromXKeyEvent(xev) == ui::VKEY_ESCAPE) {
         canceled_ = true;
         EndMoveLoop();

[pkotwicz, 2014/05/12 16:04:29]

Maybe comment that how capture is released is different based on what type of
move loop we are in (drag and drop, tab dragging etc)

Thanks for looking into the specifics. This is educational.

[varkha, 2014/05/20 17:13:35]

Done.

+        // After the move loop ends the capture will get released.
+        // When dragging browser tabs this will happen when the tab loses focus
+        // since either the dragged browser frame is getting destroyed (for
+        // dragging out into a new frame) or the focus gets moved back to the
+        // source browser (when trying to drag into another browser in which
+        // case the EscapeTracker will dispatch the KeyPress event).
+        // For drag and drop scenarios the capture is on the drag widget and
+        // will get lost when the drag widget is destroyed in
+        // DesktopDragDropClientAuraX11::OnMoveLoopEnded().
         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: {
           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_;
+          XIDeviceEvent* xievent =
+              static_cast<XIDeviceEvent*>(xev->xcookie.data);
+          xevent.xany.window = xievent->event;
           // 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);
-          return ui::POST_DISPATCH_NONE;
+          return DispatchEvent(&xevent);
         }
         default:
           break;
       }
     }
   }
 
-  return (event->xany.window == grab_input_window_) ?
-      ui::POST_DISPATCH_NONE : ui::POST_DISPATCH_PERFORM_DEFAULT;
+  return ui::POST_DISPATCH_PERFORM_DEFAULT;
 }
 
-bool X11WholeScreenMoveLoop::RunMoveLoop(aura::Window* source,
-                                         gfx::NativeCursor cursor) {
+bool X11WholeScreenMoveLoop::RunMoveLoop() {
   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;
-  }
-
   scoped_ptr<ui::ScopedEventDispatcher> old_dispatcher =
       nested_dispatcher_.Pass();
   nested_dispatcher_ =
          ui::PlatformEventSource::GetInstance()->OverrideDispatcher(this);

[pkotwicz, 2014/05/12 16:04:29]

Nit: might as well fix the alignment here

[varkha, 2014/05/20 17:13:35]

Done.

-  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);
-  }
-}
-
 void X11WholeScreenMoveLoop::EndMoveLoop() {
   if (!in_move_loop_)
     return;
 
   // Prevent DispatchMouseMovement from dispatching any posted motion event.
   weak_factory_.InvalidateWeakPtrs();
   last_xmotion_.type = LASTEvent;
 
   // We undo our emulated mouse click from RunMoveLoop();
   if (should_reset_mouse_flags_) {
     aura::Env::GetInstance()->set_mouse_button_flags(0);
     should_reset_mouse_flags_ = false;
   }
 
-  // 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);
-
   // Restore the previous dispatcher.
   nested_dispatcher_.reset();
-  drag_widget_.reset();
   delegate_->OnMoveLoopEnded();
-  XDestroyWindow(display, grab_input_window_);
-  grab_input_window_ = None;
 
   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);
-  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);
-    }
-  }
-
-  XUngrabServer(display);
-  XFlush(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
-  // is what GTK+ does, and I found a patch to KDE that did something similar.
-  unsigned long attribute_mask = CWEventMask | CWOverrideRedirect;
-  XSetWindowAttributes swa;
-  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);
-  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;
-
-  gfx::Point location = gfx::ToFlooredPoint(
-      gfx::Screen::GetNativeScreen()->GetCursorScreenPoint() - drag_offset_);
-  params.bounds = gfx::Rect(location, drag_image_.size());
-  widget->set_focus_on_creation(false);
-  widget->set_frame_type(Widget::FRAME_TYPE_FORCE_NATIVE);
-  widget->Init(params);
-  widget->SetOpacity(kDragWidgetOpacity);
-  widget->GetNativeWindow()->SetName("DragWindow");
-
-  ImageView* image = new ImageView();
-  image->SetImage(drag_image_);
-  image->SetBounds(0, 0, drag_image_.width(), drag_image_.height());
-  widget->SetContentsView(image);
-  widget->Show();
-  widget->GetNativeWindow()->layer()->SetFillsBoundsOpaquely(false);
-
-  drag_widget_.reset(widget);
-}
-
-bool X11WholeScreenMoveLoop::CheckIfIconValid() {
-  // Because we need a GL context per window, we do a quick check so that we
-  // don't make another context if the window would just be displaying a mostly
-  // transparent image.
-  const SkBitmap* in_bitmap = drag_image_.bitmap();
-  SkAutoLockPixels in_lock(*in_bitmap);
-  for (int y = 0; y < in_bitmap->height(); ++y) {
-    uint32* in_row = in_bitmap->getAddr32(0, y);
-
-    for (int x = 0; x < in_bitmap->width(); ++x) {
-      if (SkColorGetA(in_row[x]) > kMinAlpha)
-        return true;
-    }
-  }
-
-  return false;
-}
-
 }  // namespace views