Revert of Fix flakiness of DesktopDragDropClientAuraX11Tests

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"
 #include "base/message_loop/message_loop.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/dragdrop/drop_target_event.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/dragdrop/os_exchange_data_provider_aurax11.h"
 #include "ui/base/x/selection_utils.h"
 #include "ui/base/x/x11_foreign_window_manager.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/events/event.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/views/widget/desktop_aura/desktop_native_cursor_manager.h"
 #include "ui/views/widget/desktop_aura/x11_topmost_window_finder.h"
-#include "ui/views/widget/desktop_aura/x11_whole_screen_move_loop.h"
 #include "ui/wm/public/drag_drop_client.h"
 #include "ui/wm/public/drag_drop_delegate.h"
 
 using aura::client::DragDropDelegate;
 using ui::OSExchangeData;
 
 namespace {
 
 const int kMinXdndVersion = 5;
 
@@ skipping 319 matching lines @@
   return ui::POST_DISPATCH_NONE;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 DesktopDragDropClientAuraX11::DesktopDragDropClientAuraX11(
     aura::Window* root_window,
     views::DesktopNativeCursorManager* cursor_manager,
     Display* xdisplay,
     ::Window xwindow)
-    : root_window_(root_window),
+    : move_loop_(this),
+      root_window_(root_window),
       xdisplay_(xdisplay),
       xwindow_(xwindow),
       atom_cache_(xdisplay_, kAtomsToCache),
       target_window_(NULL),
       waiting_on_status_(false),
       status_received_since_enter_(false),
       source_provider_(NULL),
       source_current_window_(None),
       source_state_(SOURCE_STATE_OTHER),
       drag_operation_(0),
@@ skipping 24 matching lines @@
 // static
 DesktopDragDropClientAuraX11* DesktopDragDropClientAuraX11::GetForWindow(
     ::Window window) {
   std::map< ::Window, DesktopDragDropClientAuraX11*>::const_iterator it =
       g_live_client_map.Get().find(window);
   if (it == g_live_client_map.Get().end())
     return NULL;
   return it->second;
 }
 
-void DesktopDragDropClientAuraX11::Init() {
-  move_loop_ = CreateMoveLoop(this);
-}
-
 void DesktopDragDropClientAuraX11::OnXdndEnter(
     const XClientMessageEvent& event) {
   DVLOG(1) << "XdndEnter";
 
   int version = (event.data.l[1] & 0xff000000) >> 24;
   if (version < 3) {
     LOG(ERROR) << "Received old XdndEnter message.";
     return;
   }
 
@@ skipping 56 matching lines @@
   if (event.data.l[1] & 1) {
     ::Atom atom_operation = event.data.l[4];
     negotiated_operation_ = AtomToDragOperation(atom_operation);
   } else {
     negotiated_operation_ = ui::DragDropTypes::DRAG_NONE;
   }
 
   if (source_state_ == SOURCE_STATE_PENDING_DROP) {
     // We were waiting on the status message so we could send the XdndDrop.
     if (negotiated_operation_ == ui::DragDropTypes::DRAG_NONE) {
-      move_loop_->EndMoveLoop();
+      move_loop_.EndMoveLoop();
       return;
     }
     source_state_ = SOURCE_STATE_DROPPED;
     SendXdndDrop(source_window);
     return;
   }
 
   switch (negotiated_operation_) {
     case ui::DragDropTypes::DRAG_COPY:
-      move_loop_->UpdateCursor(copy_grab_cursor_);
+      move_loop_.UpdateCursor(copy_grab_cursor_);
       break;
     case ui::DragDropTypes::DRAG_MOVE:
-      move_loop_->UpdateCursor(move_grab_cursor_);
+      move_loop_.UpdateCursor(move_grab_cursor_);
       break;
     default:
-      move_loop_->UpdateCursor(grab_cursor_);
+      move_loop_.UpdateCursor(grab_cursor_);
       break;
   }
 
   // Note: event.data.[2,3] specify a rectangle. It is a request by the other
   // window to not send further XdndPosition messages while the cursor is
   // within it. However, it is considered advisory and (at least according to
   // the spec) the other side must handle further position messages within
   // it. GTK+ doesn't bother with this, so neither should we.
 
   if (next_position_message_.get()) {
@@ skipping 14 matching lines @@
   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();
+  move_loop_.EndMoveLoop();
 }
 
 void DesktopDragDropClientAuraX11::OnXdndDrop(
     const XClientMessageEvent& event) {
   DVLOG(1) << "XdndDrop";
 
   unsigned long source_window = event.data.l[0];
 
   int drag_operation = ui::DragDropTypes::DRAG_NONE;
   if (target_window_) {
@@ skipping 72 matching lines @@
 
   // It is possible for the DesktopWindowTreeHostX11 to be destroyed during the
   // move loop, which would also destroy this drag-client. So keep track of
   // whether it is alive after the drag ends.
   base::WeakPtr<DesktopDragDropClientAuraX11> alive(
       weak_ptr_factory_.GetWeakPtr());
 
   // Windows has a specific method, DoDragDrop(), which performs the entire
   // drag. We have to emulate this, so we spin off a nested runloop which will
   // track all cursor movement and reroute events to a specific handler.
-  move_loop_->SetDragImage(source_provider_->GetDragImage(),
-                           source_provider_->GetDragImageOffset());
-  move_loop_->RunMoveLoop(source_window, grab_cursor_);
+  move_loop_.SetDragImage(source_provider_->GetDragImage(),
+                          source_provider_->GetDragImageOffset());
+  move_loop_.RunMoveLoop(source_window, grab_cursor_);
 
   if (alive) {
-    move_loop_->SetDragImage(gfx::ImageSkia(), gfx::Vector2dF());
+    move_loop_.SetDragImage(gfx::ImageSkia(), gfx::Vector2dF());
 
     source_provider_ = NULL;
     g_current_drag_drop_client = NULL;
     drag_operation_ = 0;
     XDeleteProperty(xdisplay_, xwindow_, atom_cache_.GetAtom("XdndActionList"));
     XDeleteProperty(xdisplay_, xwindow_, atom_cache_.GetAtom(kXdndDirectSave0));
 
     return negotiated_operation_;
   }
   return ui::DragDropTypes::DRAG_NONE;
 }
 
 void DesktopDragDropClientAuraX11::DragUpdate(aura::Window* target,
                                               const ui::LocatedEvent& event) {
   NOTIMPLEMENTED();
 }
 
 void DesktopDragDropClientAuraX11::Drop(aura::Window* target,
                                         const ui::LocatedEvent& event) {
   NOTIMPLEMENTED();
 }
 
 void DesktopDragDropClientAuraX11::DragCancel() {
-  move_loop_->EndMoveLoop();
+  move_loop_.EndMoveLoop();
 }
 
 bool DesktopDragDropClientAuraX11::IsDragDropInProgress() {
   return !!g_current_drag_drop_client;
 }
 
 void DesktopDragDropClientAuraX11::OnWindowDestroyed(aura::Window* window) {
   DCHECK_EQ(target_window_, window);
   target_window_ = NULL;
 }
 
 void DesktopDragDropClientAuraX11::OnMouseMovement(XMotionEvent* event) {
   repeat_mouse_move_timer_.Stop();
   ProcessMouseMove(gfx::Point(event->x_root, event->y_root), event->time);
 }
 
 void DesktopDragDropClientAuraX11::OnMouseReleased() {
   repeat_mouse_move_timer_.Stop();
 
   if (source_state_ != SOURCE_STATE_OTHER) {
     // The user has previously released the mouse and is clicking in
     // frustration.
-    move_loop_->EndMoveLoop();
+    move_loop_.EndMoveLoop();
     return;
   }
 
   if (source_current_window_ != None) {
     if (waiting_on_status_) {
       if (status_received_since_enter_) {
         // If we are waiting for an XdndStatus message, we need to wait for it
         // to complete.
         source_state_ = SOURCE_STATE_PENDING_DROP;
 
         // Start timer to end the move loop if the target takes too long to send
         // the XdndStatus and XdndFinished messages.
         StartEndMoveLoopTimer();
         return;
       }
 
-      move_loop_->EndMoveLoop();
+      move_loop_.EndMoveLoop();
       return;
     }
 
     if (negotiated_operation_ != ui::DragDropTypes::DRAG_NONE) {
       // Start timer to end the move loop if the target takes too long to send
       // an XdndFinished message. It is important that StartEndMoveLoopTimer()
       // is called before SendXdndDrop() because SendXdndDrop()
       // sends XdndFinished synchronously if the drop target is a Chrome
       // window.
       StartEndMoveLoopTimer();
 
       // We have negotiated an action with the other end.
       source_state_ = SOURCE_STATE_DROPPED;
       SendXdndDrop(source_current_window_);
       return;
     }
   }
 
-  move_loop_->EndMoveLoop();
+  move_loop_.EndMoveLoop();
 }
 
 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();
 }
 
-scoped_ptr<X11MoveLoop> DesktopDragDropClientAuraX11::CreateMoveLoop(
-    X11MoveLoopDelegate* delegate) {
-  return scoped_ptr<X11MoveLoop>(new X11WholeScreenMoveLoop(this));
-}
-
 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 |target| has
   // XdndProxy, it will set that proxy on target, and if not, |target|'s
@@ skipping 84 matching lines @@
 
 void DesktopDragDropClientAuraX11::StartEndMoveLoopTimer() {
   end_move_loop_timer_.Start(FROM_HERE,
                              base::TimeDelta::FromMilliseconds(
                                  kEndMoveLoopTimeoutMs),
                              this,
                              &DesktopDragDropClientAuraX11::EndMoveLoop);
 }
 
 void DesktopDragDropClientAuraX11::EndMoveLoop() {
-  move_loop_->EndMoveLoop();
+  move_loop_.EndMoveLoop();
 }
 
 void DesktopDragDropClientAuraX11::DragTranslate(
     const gfx::Point& root_window_location,
     scoped_ptr<ui::OSExchangeData>* data,
     scoped_ptr<ui::DropTargetEvent>* event,
     aura::client::DragDropDelegate** delegate) {
   gfx::Point root_location = root_window_location;
   root_window_->GetHost()->ConvertPointFromNativeScreen(&root_location);
   aura::Window* target_window =
@@ skipping 193 matching lines @@
   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);
 }
 
 }  // namespace views