Fix flakiness of DesktopDragDropClientAuraX11Tests

ui/views/widget/desktop_aura/desktop_drag_drop_client_aurax11_unittest.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 <map>
 #include <vector>
 
 // Include views_test_base.h first because the definition of None in X.h
 // conflicts with the definition of None in gtest-type-util.h
 #include "ui/views/test/views_test_base.h"
 
 #include "base/memory/scoped_ptr.h"
+#include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/x/x11_atom_cache.h"
 #include "ui/gfx/x/x11_types.h"
 #include "ui/views/widget/desktop_aura/desktop_cursor_loader_updater.h"
 #include "ui/views/widget/desktop_aura/desktop_drag_drop_client_aurax11.h"
 #include "ui/views/widget/desktop_aura/desktop_native_cursor_manager.h"
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
+#include "ui/views/widget/desktop_aura/x11_move_loop.h"
 #include "ui/views/widget/widget.h"
 
 #include <X11/Xlib.h>
 
 namespace views {
 
 namespace {
 
 const char* kAtomsToCache[] = {
   "XdndActionCopy",
@@ skipping 32 matching lines @@
   ::Window xid_;
 
   // Not owned.
   TestDragDropClient* client_;
 
   std::vector<XClientMessageEvent> events_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientMessageEventCollector);
 };
 
+// An implementation of X11MoveLoop where RunMoveLoop() always starts the move
+// loop.
+class TestMoveLoop : public X11MoveLoop {
+ public:
+  explicit TestMoveLoop(X11MoveLoopDelegate* delegate);
+  virtual ~TestMoveLoop();
+
+  // Returns true if the move loop is running.
+  bool IsRunning() const;
+
+  // X11MoveLoop:
+  virtual bool RunMoveLoop(aura::Window* window,
+                           gfx::NativeCursor cursor) OVERRIDE;
+  virtual void UpdateCursor(gfx::NativeCursor cursor) OVERRIDE;
+  virtual void EndMoveLoop() OVERRIDE;
+  virtual void SetDragImage(const gfx::ImageSkia& image,
+                            const gfx::Vector2dF& offset) OVERRIDE;
+
+ private:
+  // Not owned.
+  X11MoveLoopDelegate* delegate_;
+
+  // Ends the move loop.
+  base::Closure quit_closure_;
+
+  bool is_running_;
+};
+
 // Implementation of DesktopDragDropClientAuraX11 which works with a fake
 // |DesktopDragDropClientAuraX11::source_current_window_|.
 class TestDragDropClient : public DesktopDragDropClientAuraX11 {
  public:
   // The location in screen coordinates used for the synthetic mouse moves
   // generated in SetTopmostXWindowAndMoveMouse().
   static const int kMouseMoveX;
   static const int kMouseMoveY;
 
   TestDragDropClient(aura::Window* window,
@@ skipping 29 matching lines @@
                   bool accepted_drop,
                   ::Atom performed_action);
 
   // Sets |xid| as the topmost window at the current mouse position and
   // generates a synthetic mouse move.
   void SetTopmostXWindowAndMoveMouse(::Window xid);
 
   // Returns true if the move loop is running.
   bool IsMoveLoopRunning();
 
-  // DesktopDragDropClientAuraX11:
-  virtual int StartDragAndDrop(
-      const ui::OSExchangeData& data,
-      aura::Window* root_window,
-      aura::Window* source_window,
-      const gfx::Point& root_location,
-      int operation,
-      ui::DragDropTypes::DragEventSource source) OVERRIDE;
-  virtual void OnMoveLoopEnded() OVERRIDE;
-
  private:
   // DesktopDragDropClientAuraX11:
+  virtual scoped_ptr<X11MoveLoop> CreateMoveLoop(
+      X11MoveLoopDelegate* delegate) OVERRIDE;
   virtual ::Window FindWindowFor(const gfx::Point& screen_point) OVERRIDE;
   virtual void SendXClientEvent(::Window xid, XEvent* event) OVERRIDE;
 
   // The XID of the window which initiated the drag.
   ::Window source_xid_;
 
   // The XID of the window which is simulated to be the topmost window at the
   // current mouse position.
   ::Window target_xid_;
 
-  // Whether the move loop is running.
-  bool move_loop_running_;
+  // The move loop. Not owned.
+  TestMoveLoop* loop_;
 
   // Map of ::Windows to the collector which intercepts XClientMessageEvents
   // for that window.
   std::map< ::Window, ClientMessageEventCollector*> collectors_;
 
   ui::X11AtomCache atom_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDragDropClient);
 };
 
@@ skipping 17 matching lines @@
   to_return.swap(events_);
   return to_return;
 }
 
 void ClientMessageEventCollector::RecordEvent(
     const XClientMessageEvent& event) {
   events_.push_back(event);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// TestMoveLoop
+
+TestMoveLoop::TestMoveLoop(X11MoveLoopDelegate* delegate)
+    : delegate_(delegate),
+      is_running_(false) {
+}
+
+TestMoveLoop::~TestMoveLoop() {
+}
+
+bool TestMoveLoop::IsRunning() const {
+  return is_running_;
+}
+
+bool TestMoveLoop::RunMoveLoop(
+    aura::Window* window,
+    gfx::NativeCursor cursor) {
+  is_running_ = true;
+  base::RunLoop run_loop;
+  quit_closure_ = run_loop.QuitClosure();
+  run_loop.Run();
+  return true;
+}
+
+void TestMoveLoop::UpdateCursor(gfx::NativeCursor cursor) {
+}
+
+void TestMoveLoop::EndMoveLoop() {
+  if (is_running_) {
+    delegate_->OnMoveLoopEnded();
+    is_running_ = false;
+    quit_closure_.Run();
+  }
+}
+
+void TestMoveLoop::SetDragImage(const gfx::ImageSkia& image,
+                                const gfx::Vector2dF& offset) {
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // TestDragDropClient
 
 // static
 const int TestDragDropClient::kMouseMoveX = 100;
 
 // static
 const int TestDragDropClient::kMouseMoveY = 200;
 
 TestDragDropClient::TestDragDropClient(
     aura::Window* window,
     DesktopNativeCursorManager* cursor_manager)
     : DesktopDragDropClientAuraX11(window,
                                    cursor_manager,
                                    gfx::GetXDisplay(),
                                    window->GetHost()->GetAcceleratedWidget()),
       source_xid_(window->GetHost()->GetAcceleratedWidget()),
       target_xid_(None),
-      move_loop_running_(false),
+      loop_(NULL),
       atom_cache_(gfx::GetXDisplay(), kAtomsToCache) {
 }
 
 TestDragDropClient::~TestDragDropClient() {
 }
 
 Atom TestDragDropClient::GetAtom(const char* name) {
   return atom_cache_.GetAtom(name);
 }
 
@@ skipping 45 matching lines @@
   target_xid_ = xid;
 
   XMotionEvent event;
   event.time = CurrentTime;
   event.x_root = kMouseMoveX;
   event.y_root = kMouseMoveY;
   OnMouseMovement(&event);
 }
 
 bool TestDragDropClient::IsMoveLoopRunning() {
-  return move_loop_running_;
+  return loop_->IsRunning();
 }
 
-int TestDragDropClient::StartDragAndDrop(
-    const ui::OSExchangeData& data,
-    aura::Window* root_window,
-    aura::Window* source_window,
-    const gfx::Point& root_location,
-    int operation,
-    ui::DragDropTypes::DragEventSource source) {
-  move_loop_running_ = true;
-  return DesktopDragDropClientAuraX11::StartDragAndDrop(data, root_window,
-      source_window, root_location, operation, source);
-}
-
-void TestDragDropClient::OnMoveLoopEnded() {
-  DesktopDragDropClientAuraX11::OnMoveLoopEnded();
-  move_loop_running_ = false;
+scoped_ptr<X11MoveLoop> TestDragDropClient::CreateMoveLoop(
+    X11MoveLoopDelegate* delegate) {
+  loop_ = new TestMoveLoop(delegate);
+  return scoped_ptr<X11MoveLoop>(loop_);
 }
 
 ::Window TestDragDropClient::FindWindowFor(const gfx::Point& screen_point) {
   return target_xid_;
 }
 
 void TestDragDropClient::SendXClientEvent(::Window xid, XEvent* event) {
   std::map< ::Window, ClientMessageEventCollector*>::iterator it =
       collectors_.find(xid);
   if (it != collectors_.end())
@@ skipping 34 matching lines @@
     params.native_widget = new DesktopNativeWidgetAura(widget_.get());
     params.bounds = gfx::Rect(100, 100);
     widget_->Init(params);
     widget_->Show();
 
     cursor_manager_.reset(new DesktopNativeCursorManager(
         DesktopCursorLoaderUpdater::Create()));
 
     client_.reset(new TestDragDropClient(widget_->GetNativeWindow(),
                                          cursor_manager_.get()));
+    client_->Init();
   }
 
   virtual void TearDown() OVERRIDE {
     client_.reset();
     cursor_manager_.reset();
     widget_.reset();
     ViewsTestBase::TearDown();
   }
 
   TestDragDropClient* client() {
@@ skipping 319 matching lines @@
 
   // Repeat the test but reject the drop in the XdndFinished message instead.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&RejectAfterMouseReleaseStep3, client()));
   result = StartDragAndDrop();
   EXPECT_EQ(ui::DragDropTypes::DRAG_NONE, result);
 }
 
 }  // namespace views