Add tests for drag and drop for Linux Aura

ui/views/widget/desktop_aura/desktop_drag_drop_client_aurax11.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/desktop_drag_drop_client_aurax11.h"
 
 #include <X11/Xatom.h>
 
 #include "base/event_types.h"
 #include "base/lazy_instance.h"
@@ skipping 62 matching lines @@
 
 // The time to wait since sending the last XdndPosition message before
 // reprocessing the most recent mouse move event in case that the window
 // stacking order has changed and |source_current_window_| needs to be updated.
 const int kRepeatMouseMoveTimeoutMs = 350;
 
 static base::LazyInstance<
     std::map< ::Window, views::DesktopDragDropClientAuraX11*> >::Leaky
         g_live_client_map = LAZY_INSTANCE_INITIALIZER;
 
-// Returns the topmost X11 window at |screen_point| if it is advertising that
-// is supports the Xdnd protocol. Will return the window under the pointer as
-// |mouse_window|. If there's a Xdnd aware window, it will be returned in
-// |dest_window|.
-void FindWindowFor(const gfx::Point& screen_point,
-                   ::Window* mouse_window,
-                   ::Window* dest_window) {
-  views::X11TopmostWindowFinder finder;
-  *mouse_window = finder.FindWindowAt(screen_point);
-  *dest_window = None;
-
-  if (*mouse_window == None)
-    return;
-
-  // Figure out which window we should test as XdndAware. If mouse_window has
-  // XdndProxy, it will set that proxy on target, and if not, |target|'s
-  // original value will remain.
-  XID target = *mouse_window;
-  ui::GetXIDProperty(*mouse_window, "XdndProxy", &target);
-
-  int version;
-  if (ui::GetIntProperty(target, "XdndAware", &version) &&
-      version >= kMinXdndVersion) {
-    *dest_window = target;
-  }
-}
-
 }  // namespace
 
 namespace views {
 
 DesktopDragDropClientAuraX11*
 DesktopDragDropClientAuraX11::g_current_drag_drop_client = NULL;
 
 class DesktopDragDropClientAuraX11::X11DragContext
     : public ui::PlatformEventDispatcher {
  public:
@@ skipping 409 matching lines @@
     unsigned long event_time = next_position_message_->second;
     next_position_message_.reset();
 
     SendXdndPosition(source_window, p, event_time);
   }
 }
 
 void DesktopDragDropClientAuraX11::OnXdndFinished(
     const XClientMessageEvent& event) {
   DVLOG(1) << "XdndFinished";
+  unsigned long source_window = event.data.l[0];
+  if (source_current_window_ != source_window)
+    return;
+
+  // Clear |negotiated_operation_| if the drag was rejected.
+  if ((event.data.l[1] & 1) == 0)
+    negotiated_operation_ = ui::DragDropTypes::DRAG_NONE;
 
   // Clear |source_current_window_| to avoid sending XdndLeave upon ending the
   // move loop.
   source_current_window_ = None;
   move_loop_.EndMoveLoop();
 }
 
 void DesktopDragDropClientAuraX11::OnXdndDrop(
     const XClientMessageEvent& event) {
   DVLOG(1) << "XdndDrop";
@@ skipping 175 matching lines @@
 void DesktopDragDropClientAuraX11::OnMoveLoopEnded() {
   if (source_current_window_ != None) {
     SendXdndLeave(source_current_window_);
     source_current_window_ = None;
   }
   target_current_context_.reset();
   repeat_mouse_move_timer_.Stop();
   end_move_loop_timer_.Stop();
 }
 
+XID DesktopDragDropClientAuraX11::FindWindowFor(
+    const gfx::Point& screen_point) {
+  views::X11TopmostWindowFinder finder;
+  ::Window target = finder.FindWindowAt(screen_point);
+
+  if (target == None)
+    return None;
+
+  // Figure out which window we should test as XdndAware. If mouse_window has
+  // XdndProxy, it will set that proxy on target, and if not, |target|'s
+  // original value will remain.
+  ui::GetXIDProperty(target, "XdndProxy", &target);
+
+  int version;
+  if (ui::GetIntProperty(target, "XdndAware", &version) &&
+      version >= kMinXdndVersion) {
+    return target;
+  }
+  return None;
+}
+
+void DesktopDragDropClientAuraX11::SendXClientEvent(::Window xid,
+                                                    XEvent* xev) {
+  DCHECK_EQ(ClientMessage, xev->type);
+
+  // Don't send messages to the X11 message queue if we can help it.
+  DesktopDragDropClientAuraX11* short_circuit = GetForWindow(xid);
+  if (short_circuit) {
+    Atom message_type = xev->xclient.message_type;
+    if (message_type == atom_cache_.GetAtom("XdndEnter")) {
+      short_circuit->OnXdndEnter(xev->xclient);
+      return;
+    } else if (message_type == atom_cache_.GetAtom("XdndLeave")) {
+      short_circuit->OnXdndLeave(xev->xclient);
+      return;
+    } else if (message_type == atom_cache_.GetAtom("XdndPosition")) {
+      short_circuit->OnXdndPosition(xev->xclient);
+      return;
+    } else if (message_type == atom_cache_.GetAtom("XdndStatus")) {
+      short_circuit->OnXdndStatus(xev->xclient);
+      return;
+    } else if (message_type == atom_cache_.GetAtom("XdndFinished")) {
+      short_circuit->OnXdndFinished(xev->xclient);
+      return;
+    } else if (message_type == atom_cache_.GetAtom("XdndDrop")) {
+      short_circuit->OnXdndDrop(xev->xclient);
+      return;
+    }
+  }
+
+  // I don't understand why the GTK+ code is doing what it's doing here. It
+  // goes out of its way to send the XEvent so that it receives a callback on
+  // success or failure, and when it fails, it then sends an internal
+  // GdkEvent about the failed drag. (And sending this message doesn't appear
+  // to go through normal xlib machinery, but instead passes through the low
+  // level xProto (the x11 wire format) that I don't understand.
+  //
+  // I'm unsure if I have to jump through those hoops, or if XSendEvent is
+  // sufficient.
+  XSendEvent(xdisplay_, xid, False, 0, xev);
+}
+
 void DesktopDragDropClientAuraX11::ProcessMouseMove(
     const gfx::Point& screen_point,
     unsigned long event_time) {
   if (source_state_ != SOURCE_STATE_OTHER)
     return;
 
   // Find the current window the cursor is over.
-  ::Window mouse_window = None;
-  ::Window dest_window = None;
-  FindWindowFor(screen_point, &mouse_window, &dest_window);
+  ::Window dest_window = FindWindowFor(screen_point);
 
   if (source_current_window_ != dest_window) {
     if (source_current_window_ != None)
       SendXdndLeave(source_current_window_);
 
     source_current_window_ = dest_window;
     waiting_on_status_ = false;
     next_position_message_.reset();
     status_received_since_enter_ = false;
     negotiated_operation_ = ui::DragDropTypes::DRAG_NONE;
@@ skipping 227 matching lines @@
   xev.xclient.format = 32;
   xev.xclient.window = dest_window;
   xev.xclient.data.l[0] = xwindow_;
   xev.xclient.data.l[1] = 0;
   xev.xclient.data.l[2] = CurrentTime;
   xev.xclient.data.l[3] = None;
   xev.xclient.data.l[4] = None;
   SendXClientEvent(dest_window, &xev);
 }
 
-void DesktopDragDropClientAuraX11::SendXClientEvent(::Window xid,
-                                                    XEvent* xev) {
-  DCHECK_EQ(ClientMessage, xev->type);
-
-  // Don't send messages to the X11 message queue if we can help it.
-  DesktopDragDropClientAuraX11* short_circuit = GetForWindow(xid);
-  if (short_circuit) {
-    Atom message_type = xev->xclient.message_type;
-    if (message_type == atom_cache_.GetAtom("XdndEnter")) {
-      short_circuit->OnXdndEnter(xev->xclient);
-      return;
-    } else if (message_type == atom_cache_.GetAtom("XdndLeave")) {
-      short_circuit->OnXdndLeave(xev->xclient);
-      return;
-    } else if (message_type == atom_cache_.GetAtom("XdndPosition")) {
-      short_circuit->OnXdndPosition(xev->xclient);
-      return;
-    } else if (message_type == atom_cache_.GetAtom("XdndStatus")) {
-      short_circuit->OnXdndStatus(xev->xclient);
-      return;
-    } else if (message_type == atom_cache_.GetAtom("XdndFinished")) {
-      short_circuit->OnXdndFinished(xev->xclient);
-      return;
-    } else if (message_type == atom_cache_.GetAtom("XdndDrop")) {
-      short_circuit->OnXdndDrop(xev->xclient);
-      return;
-    }
-  }
-
-  // I don't understand why the GTK+ code is doing what it's doing here. It
-  // goes out of its way to send the XEvent so that it receives a callback on
-  // success or failure, and when it fails, it then sends an internal
-  // GdkEvent about the failed drag. (And sending this message doesn't appear
-  // to go through normal xlib machinery, but instead passes through the low
-  // level xProto (the x11 wire format) that I don't understand.
-  //
-  // I'm unsure if I have to jump through those hoops, or if XSendEvent is
-  // sufficient.
-  XSendEvent(xdisplay_, xid, False, 0, xev);
-}
-
 }  // namespace views