Revert of 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_;
 
-  // The move loop. Not owned.
-  TestMoveLoop* loop_;
+  // Whether the move loop is running.
+  bool move_loop_running_;
 
   // 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),
-      loop_(NULL),
+      move_loop_running_(false),
       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 loop_->IsRunning();
+  return move_loop_running_;
 }
 
-scoped_ptr<X11MoveLoop> TestDragDropClient::CreateMoveLoop(
-    X11MoveLoopDelegate* delegate) {
-  loop_ = new TestMoveLoop(delegate);
-  return scoped_ptr<X11MoveLoop>(loop_);
+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;
 }
 
 ::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