ui/views/widget/desktop_aura/desktop_drag_drop_client_aurax11_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <map>
   6 #include <vector>
   7
   8 // Include views_test_base.h first because the definition of None in X.h
   9 // conflicts with the definition of None in gtest-type-util.h
  10 #include "ui/views/test/views_test_base.h"
  11
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/run_loop.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "ui/aura/window.h"
  16 #include "ui/aura/window_tree_host.h"
  17 #include "ui/base/dragdrop/os_exchange_data.h"
  18 #include "ui/base/x/x11_util.h"
  19 #include "ui/gfx/x/x11_atom_cache.h"
  20 #include "ui/gfx/x/x11_types.h"
  21 #include "ui/views/widget/desktop_aura/desktop_cursor_loader_updater.h"
  22 #include "ui/views/widget/desktop_aura/desktop_drag_drop_client_aurax11.h"
  23 #include "ui/views/widget/desktop_aura/desktop_native_cursor_manager.h"
  24 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
  25 #include "ui/views/widget/desktop_aura/x11_move_loop.h"
  26 #include "ui/views/widget/widget.h"
  27
  28 #include <X11/Xlib.h>
  29
  30 namespace views {
  31
  32 namespace {
  33
  34 const char* kAtomsToCache[] = {
  35   "XdndActionCopy",
  36   "XdndDrop",
  37   "XdndEnter",
  38   "XdndFinished",
  39   "XdndLeave",
  40   "XdndPosition",
  41   "XdndStatus",
  42   "XdndTypeList",
  43   NULL
  44 };
  45
  46 class TestDragDropClient;
  47
  48 // Collects messages which would otherwise be sent to |xid_| via
  49 // SendXClientEvent().
  50 class ClientMessageEventCollector {
  51  public:
  52   ClientMessageEventCollector(::Window xid, TestDragDropClient* client);
  53   virtual ~ClientMessageEventCollector();
  54
  55   // Returns true if |events_| is non-empty.
  56   bool HasEvents() const {
  57     return !events_.empty();
  58   }
  59
  60   // Pops all of |events_| and returns the popped events in the order that they
  61   // were on the stack
  62   std::vector<XClientMessageEvent> PopAllEvents();
  63
  64   // Adds |event| to the stack.
  65   void RecordEvent(const XClientMessageEvent& event);
  66
  67  private:
  68   ::Window xid_;
  69
  70   // Not owned.
  71   TestDragDropClient* client_;
  72
  73   std::vector<XClientMessageEvent> events_;
  74
  75   DISALLOW_COPY_AND_ASSIGN(ClientMessageEventCollector);
  76 };
  77
  78 // An implementation of X11MoveLoop where RunMoveLoop() always starts the move
  79 // loop.
  80 class TestMoveLoop : public X11MoveLoop {
  81  public:
  82   explicit TestMoveLoop(X11MoveLoopDelegate* delegate);
  83   virtual ~TestMoveLoop();
  84
  85   // Returns true if the move loop is running.
  86   bool IsRunning() const;
  87
  88   // X11MoveLoop:
  89   virtual bool RunMoveLoop(aura::Window* window,
  90                            gfx::NativeCursor cursor) OVERRIDE;
  91   virtual void UpdateCursor(gfx::NativeCursor cursor) OVERRIDE;
  92   virtual void EndMoveLoop() OVERRIDE;
  93
  94  private:
  95   // Not owned.
  96   X11MoveLoopDelegate* delegate_;
  97
  98   // Ends the move loop.
  99   base::Closure quit_closure_;
 100
 101   bool is_running_;
 102 };
 103
 104 // Implementation of DesktopDragDropClientAuraX11 which works with a fake
 105 // |DesktopDragDropClientAuraX11::source_current_window_|.
 106 class TestDragDropClient : public DesktopDragDropClientAuraX11 {
 107  public:
 108   // The location in screen coordinates used for the synthetic mouse moves
 109   // generated in SetTopmostXWindowAndMoveMouse().
 110   static const int kMouseMoveX;
 111   static const int kMouseMoveY;
 112
 113   TestDragDropClient(aura::Window* window,
 114                      DesktopNativeCursorManager* cursor_manager);
 115   virtual ~TestDragDropClient();
 116
 117   // Returns the XID of the window which initiated the drag.
 118   ::Window source_xwindow() {
 119     return source_xid_;
 120   }
 121
 122   // Returns the Atom with |name|.
 123   Atom GetAtom(const char* name);
 124
 125   // Returns true if the event's message has |type|.
 126   bool MessageHasType(const XClientMessageEvent& event,
 127                       const char* type);
 128
 129   // Sets |collector| to collect XClientMessageEvents which would otherwise
 130   // have been sent to the drop target window.
 131   void SetEventCollectorFor(::Window xid,
 132                             ClientMessageEventCollector* collector);
 133
 134   // Builds an XdndStatus message and sends it to
 135   // DesktopDragDropClientAuraX11.
 136   void OnStatus(XID target_window,
 137                 bool will_accept_drop,
 138                 ::Atom accepted_action);
 139
 140   // Builds an XdndFinished message and sends it to
 141   // DesktopDragDropClientAuraX11.
 142   void OnFinished(XID target_window,
 143                   bool accepted_drop,
 144                   ::Atom performed_action);
 145
 146   // Sets |xid| as the topmost window at the current mouse position and
 147   // generates a synthetic mouse move.
 148   void SetTopmostXWindowAndMoveMouse(::Window xid);
 149
 150   // Returns true if the move loop is running.
 151   bool IsMoveLoopRunning();
 152
 153  private:
 154   // DesktopDragDropClientAuraX11:
 155   virtual scoped_ptr<X11MoveLoop> CreateMoveLoop(
 156       X11MoveLoopDelegate* delegate) OVERRIDE;
 157   virtual ::Window FindWindowFor(const gfx::Point& screen_point) OVERRIDE;
 158   virtual void SendXClientEvent(::Window xid, XEvent* event) OVERRIDE;
 159
 160   // The XID of the window which initiated the drag.
 161   ::Window source_xid_;
 162
 163   // The XID of the window which is simulated to be the topmost window at the
 164   // current mouse position.
 165   ::Window target_xid_;
 166
 167   // The move loop. Not owned.
 168   TestMoveLoop* loop_;
 169
 170   // Map of ::Windows to the collector which intercepts XClientMessageEvents
 171   // for that window.
 172   std::map< ::Window, ClientMessageEventCollector*> collectors_;
 173
 174   ui::X11AtomCache atom_cache_;
 175
 176   DISALLOW_COPY_AND_ASSIGN(TestDragDropClient);
 177 };
 178
 179 ///////////////////////////////////////////////////////////////////////////////
 180 // ClientMessageEventCollector
 181
 182 ClientMessageEventCollector::ClientMessageEventCollector(
 183     ::Window xid,
 184     TestDragDropClient* client)
 185     : xid_(xid),
 186       client_(client) {
 187   client->SetEventCollectorFor(xid, this);
 188 }
 189
 190 ClientMessageEventCollector::~ClientMessageEventCollector() {
 191   client_->SetEventCollectorFor(xid_, NULL);
 192 }
 193
 194 std::vector<XClientMessageEvent> ClientMessageEventCollector::PopAllEvents() {
 195   std::vector<XClientMessageEvent> to_return;
 196   to_return.swap(events_);
 197   return to_return;
 198 }
 199
 200 void ClientMessageEventCollector::RecordEvent(
 201     const XClientMessageEvent& event) {
 202   events_.push_back(event);
 203 }
 204
 205 ///////////////////////////////////////////////////////////////////////////////
 206 // TestMoveLoop
 207
 208 TestMoveLoop::TestMoveLoop(X11MoveLoopDelegate* delegate)
 209     : delegate_(delegate),
 210       is_running_(false) {
 211 }
 212
 213 TestMoveLoop::~TestMoveLoop() {
 214 }
 215
 216 bool TestMoveLoop::IsRunning() const {
 217   return is_running_;
 218 }
 219
 220 bool TestMoveLoop::RunMoveLoop(
 221     aura::Window* window,
 222     gfx::NativeCursor cursor) {
 223   is_running_ = true;
 224   base::RunLoop run_loop;
 225   quit_closure_ = run_loop.QuitClosure();
 226   run_loop.Run();
 227   return true;
 228 }
 229
 230 void TestMoveLoop::UpdateCursor(gfx::NativeCursor cursor) {
 231 }
 232
 233 void TestMoveLoop::EndMoveLoop() {
 234   if (is_running_) {
 235     delegate_->OnMoveLoopEnded();
 236     is_running_ = false;
 237     quit_closure_.Run();
 238   }
 239 }
 240
 241 ///////////////////////////////////////////////////////////////////////////////
 242 // TestDragDropClient
 243
 244 // static
 245 const int TestDragDropClient::kMouseMoveX = 100;
 246
 247 // static
 248 const int TestDragDropClient::kMouseMoveY = 200;
 249
 250 TestDragDropClient::TestDragDropClient(
 251     aura::Window* window,
 252     DesktopNativeCursorManager* cursor_manager)
 253     : DesktopDragDropClientAuraX11(window,
 254                                    cursor_manager,
 255                                    gfx::GetXDisplay(),
 256                                    window->GetHost()->GetAcceleratedWidget()),
 257       source_xid_(window->GetHost()->GetAcceleratedWidget()),
 258       target_xid_(None),
 259       loop_(NULL),
 260       atom_cache_(gfx::GetXDisplay(), kAtomsToCache) {
 261 }
 262
 263 TestDragDropClient::~TestDragDropClient() {
 264 }
 265
 266 Atom TestDragDropClient::GetAtom(const char* name) {
 267   return atom_cache_.GetAtom(name);
 268 }
 269
 270 bool TestDragDropClient::MessageHasType(const XClientMessageEvent& event,
 271                                         const char* type) {
 272   return event.message_type == atom_cache_.GetAtom(type);
 273 }
 274
 275 void TestDragDropClient::SetEventCollectorFor(
 276     ::Window xid,
 277     ClientMessageEventCollector* collector) {
 278   if (collector)
 279     collectors_[xid] = collector;
 280   else
 281     collectors_.erase(xid);
 282 }
 283
 284 void TestDragDropClient::OnStatus(XID target_window,
 285                                   bool will_accept_drop,
 286                                   ::Atom accepted_action) {
 287   XClientMessageEvent event;
 288   event.message_type = atom_cache_.GetAtom("XdndStatus");
 289   event.format = 32;
 290   event.window = source_xid_;
 291   event.data.l[0] = target_window;
 292   event.data.l[1] = will_accept_drop ? 1 : 0;
 293   event.data.l[2] = 0;
 294   event.data.l[3] = 0;
 295   event.data.l[4] = accepted_action;
 296   OnXdndStatus(event);
 297 }
 298
 299 void TestDragDropClient::OnFinished(XID target_window,
 300                                     bool accepted_drop,
 301                                     ::Atom performed_action) {
 302   XClientMessageEvent event;
 303   event.message_type = atom_cache_.GetAtom("XdndFinished");
 304   event.format = 32;
 305   event.window = source_xid_;
 306   event.data.l[0] = target_window;
 307   event.data.l[1] = accepted_drop ? 1 : 0;
 308   event.data.l[2] = performed_action;
 309   event.data.l[3] = 0;
 310   event.data.l[4] = 0;
 311   OnXdndFinished(event);
 312 }
 313
 314 void TestDragDropClient::SetTopmostXWindowAndMoveMouse(::Window xid) {
 315   target_xid_ = xid;
 316
 317   XMotionEvent event;
 318   event.time = CurrentTime;
 319   event.x_root = kMouseMoveX;
 320   event.y_root = kMouseMoveY;
 321   OnMouseMovement(&event);
 322 }
 323
 324 bool TestDragDropClient::IsMoveLoopRunning() {
 325   return loop_->IsRunning();
 326 }
 327
 328 scoped_ptr<X11MoveLoop> TestDragDropClient::CreateMoveLoop(
 329     X11MoveLoopDelegate* delegate) {
 330   loop_ = new TestMoveLoop(delegate);
 331   return scoped_ptr<X11MoveLoop>(loop_);
 332 }
 333
 334 ::Window TestDragDropClient::FindWindowFor(const gfx::Point& screen_point) {
 335   return target_xid_;
 336 }
 337
 338 void TestDragDropClient::SendXClientEvent(::Window xid, XEvent* event) {
 339   std::map< ::Window, ClientMessageEventCollector*>::iterator it =
 340       collectors_.find(xid);
 341   if (it != collectors_.end())
 342     it->second->RecordEvent(event->xclient);
 343 }
 344
 345 }  // namespace
 346
 347 class DesktopDragDropClientAuraX11Test : public ViewsTestBase {
 348  public:
 349   DesktopDragDropClientAuraX11Test() {
 350   }
 351
 352   virtual ~DesktopDragDropClientAuraX11Test() {
 353   }
 354
 355   int StartDragAndDrop() {
 356     ui::OSExchangeData data;
 357     data.SetString(base::ASCIIToUTF16("Test"));
 358
 359     return client_->StartDragAndDrop(
 360         data,
 361         widget_->GetNativeWindow()->GetRootWindow(),
 362         widget_->GetNativeWindow(),
 363         gfx::Point(),
 364         ui::DragDropTypes::DRAG_COPY,
 365         ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE);
 366   }
 367
 368   // ViewsTestBase:
 369   virtual void SetUp() OVERRIDE {
 370     ViewsTestBase::SetUp();
 371
 372     // Create widget to initiate the drags.
 373     widget_.reset(new Widget);
 374     Widget::InitParams params(Widget::InitParams::TYPE_WINDOW);
 375     params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 376     params.native_widget = new DesktopNativeWidgetAura(widget_.get());
 377     params.bounds = gfx::Rect(100, 100);
 378     widget_->Init(params);
 379     widget_->Show();
 380
 381     cursor_manager_.reset(new DesktopNativeCursorManager(
 382         DesktopCursorLoaderUpdater::Create()));
 383
 384     client_.reset(new TestDragDropClient(widget_->GetNativeWindow(),
 385                                          cursor_manager_.get()));
 386     client_->Init();
 387   }
 388
 389   virtual void TearDown() OVERRIDE {
 390     client_.reset();
 391     cursor_manager_.reset();
 392     widget_.reset();
 393     ViewsTestBase::TearDown();
 394   }
 395
 396   TestDragDropClient* client() {
 397     return client_.get();
 398   }
 399
 400  private:
 401   scoped_ptr<TestDragDropClient> client_;
 402   scoped_ptr<DesktopNativeCursorManager> cursor_manager_;
 403
 404   // The widget used to initiate drags.
 405   scoped_ptr<Widget> widget_;
 406
 407   DISALLOW_COPY_AND_ASSIGN(DesktopDragDropClientAuraX11Test);
 408 };
 409
 410 namespace {
 411
 412 void BasicStep2(TestDragDropClient* client, XID toplevel) {
 413   EXPECT_TRUE(client->IsMoveLoopRunning());
 414
 415   ClientMessageEventCollector collector(toplevel, client);
 416   client->SetTopmostXWindowAndMoveMouse(toplevel);
 417
 418   // XdndEnter should have been sent to |toplevel| before the XdndPosition
 419   // message.
 420   std::vector<XClientMessageEvent> events = collector.PopAllEvents();
 421   ASSERT_EQ(2u, events.size());
 422
 423   EXPECT_TRUE(client->MessageHasType(events[0], "XdndEnter"));
 424   EXPECT_EQ(client->source_xwindow(),
 425             static_cast<XID>(events[0].data.l[0]));
 426   EXPECT_EQ(1, events[0].data.l[1] & 1);
 427   std::vector<Atom> targets;
 428   ui::GetAtomArrayProperty(client->source_xwindow(), "XdndTypeList", &targets);
 429   EXPECT_FALSE(targets.empty());
 430
 431   EXPECT_TRUE(client->MessageHasType(events[1], "XdndPosition"));
 432   EXPECT_EQ(client->source_xwindow(),
 433             static_cast<XID>(events[0].data.l[0]));
 434   const long kCoords =
 435       TestDragDropClient::kMouseMoveX << 16 | TestDragDropClient::kMouseMoveY;
 436   EXPECT_EQ(kCoords, events[1].data.l[2]);
 437   EXPECT_EQ(client->GetAtom("XdndActionCopy"),
 438             static_cast<Atom>(events[1].data.l[4]));
 439
 440   client->OnStatus(toplevel, true, client->GetAtom("XdndActionCopy"));
 441
 442   // Because there is no unprocessed XdndPosition, the drag drop client should
 443   // send XdndDrop immediately after the mouse is released.
 444   client->OnMouseReleased();
 445
 446   events = collector.PopAllEvents();
 447   ASSERT_EQ(1u, events.size());
 448   EXPECT_TRUE(client->MessageHasType(events[0], "XdndDrop"));
 449   EXPECT_EQ(client->source_xwindow(),
 450             static_cast<XID>(events[0].data.l[0]));
 451
 452   // Send XdndFinished to indicate that the drag drop client can cleanup any
 453   // data related to this drag. The move loop should end only after the
 454   // XdndFinished message was received.
 455   EXPECT_TRUE(client->IsMoveLoopRunning());
 456   client->OnFinished(toplevel, true, client->GetAtom("XdndActionCopy"));
 457   EXPECT_FALSE(client->IsMoveLoopRunning());
 458 }
 459
 460 void BasicStep3(TestDragDropClient* client, XID toplevel) {
 461   EXPECT_TRUE(client->IsMoveLoopRunning());
 462
 463   ClientMessageEventCollector collector(toplevel, client);
 464   client->SetTopmostXWindowAndMoveMouse(toplevel);
 465
 466   std::vector<XClientMessageEvent> events = collector.PopAllEvents();
 467   ASSERT_EQ(2u, events.size());
 468   EXPECT_TRUE(client->MessageHasType(events[0], "XdndEnter"));
 469   EXPECT_TRUE(client->MessageHasType(events[1], "XdndPosition"));
 470
 471   client->OnStatus(toplevel, true, client->GetAtom("XdndActionCopy"));
 472   client->SetTopmostXWindowAndMoveMouse(toplevel);
 473   events = collector.PopAllEvents();
 474   ASSERT_EQ(1u, events.size());
 475   EXPECT_TRUE(client->MessageHasType(events[0], "XdndPosition"));
 476
 477   // We have not received an XdndStatus ack for the second XdndPosition message.
 478   // Test that sending XdndDrop is delayed till the XdndStatus ack is received.
 479   client->OnMouseReleased();
 480   EXPECT_FALSE(collector.HasEvents());
 481
 482   client->OnStatus(toplevel, true, client->GetAtom("XdndActionCopy"));
 483   events = collector.PopAllEvents();
 484   ASSERT_EQ(1u, events.size());
 485   EXPECT_TRUE(client->MessageHasType(events[0], "XdndDrop"));
 486
 487   EXPECT_TRUE(client->IsMoveLoopRunning());
 488   client->OnFinished(toplevel, true, client->GetAtom("XdndActionCopy"));
 489   EXPECT_FALSE(client->IsMoveLoopRunning());
 490 }
 491
 492 }  // namespace
 493
 494 TEST_F(DesktopDragDropClientAuraX11Test, Basic) {
 495   XID toplevel = 1;
 496
 497   base::MessageLoop::current()->PostTask(FROM_HERE,
 498                                          base::Bind(&BasicStep2,
 499                                          client(),
 500                                          toplevel));
 501   int result = StartDragAndDrop();
 502   EXPECT_EQ(ui::DragDropTypes::DRAG_COPY, result);
 503
 504   // Do another drag and drop to test that the data is properly cleaned up as a
 505   // result of the XdndFinished message.
 506   base::MessageLoop::current()->PostTask(FROM_HERE,
 507                                          base::Bind(&BasicStep3,
 508                                          client(),
 509                                          toplevel));
 510   result = StartDragAndDrop();
 511   EXPECT_EQ(ui::DragDropTypes::DRAG_COPY, result);
 512 }
 513
 514 namespace {
 515
 516 void TargetDoesNotRespondStep2(TestDragDropClient* client) {
 517   EXPECT_TRUE(client->IsMoveLoopRunning());
 518
 519   XID toplevel = 1;
 520   ClientMessageEventCollector collector(toplevel, client);
 521   client->SetTopmostXWindowAndMoveMouse(toplevel);
 522
 523   std::vector<XClientMessageEvent> events = collector.PopAllEvents();
 524   ASSERT_EQ(2u, events.size());
 525   EXPECT_TRUE(client->MessageHasType(events[0], "XdndEnter"));
 526   EXPECT_TRUE(client->MessageHasType(events[1], "XdndPosition"));
 527
 528   client->OnMouseReleased();
 529   events = collector.PopAllEvents();
 530   ASSERT_EQ(1u, events.size());
 531   EXPECT_TRUE(client->MessageHasType(events[0], "XdndLeave"));
 532   EXPECT_FALSE(client->IsMoveLoopRunning());
 533 }
 534
 535 }  // namespace
 536
 537 // Test that we do not wait for the target to send XdndStatus if we have not
 538 // received any XdndStatus messages at all from the target. The Unity
 539 // DNDCollectionWindow is an example of an XdndAware target which does not
 540 // respond to XdndPosition messages at all.
 541 TEST_F(DesktopDragDropClientAuraX11Test, TargetDoesNotRespond) {
 542   base::MessageLoop::current()->PostTask(
 543       FROM_HERE,
 544       base::Bind(&TargetDoesNotRespondStep2, client()));
 545   int result = StartDragAndDrop();
 546   EXPECT_EQ(ui::DragDropTypes::DRAG_NONE, result);
 547 }
 548
 549 namespace {
 550
 551 void QueuePositionStep2(TestDragDropClient* client) {
 552   EXPECT_TRUE(client->IsMoveLoopRunning());
 553
 554   XID toplevel = 1;
 555   ClientMessageEventCollector collector(toplevel, client);
 556   client->SetTopmostXWindowAndMoveMouse(toplevel);
 557   client->SetTopmostXWindowAndMoveMouse(toplevel);
 558   client->SetTopmostXWindowAndMoveMouse(toplevel);
 559
 560   std::vector<XClientMessageEvent> events = collector.PopAllEvents();
 561   ASSERT_EQ(2u, events.size());
 562   EXPECT_TRUE(client->MessageHasType(events[0], "XdndEnter"));
 563   EXPECT_TRUE(client->MessageHasType(events[1], "XdndPosition"));
 564
 565   client->OnStatus(toplevel, true, client->GetAtom("XdndActionCopy"));
 566   events = collector.PopAllEvents();
 567   ASSERT_EQ(1u, events.size());
 568   EXPECT_TRUE(client->MessageHasType(events[0], "XdndPosition"));
 569
 570   client->OnStatus(toplevel, true, client->GetAtom("XdndActionCopy"));
 571   EXPECT_FALSE(collector.HasEvents());
 572
 573   client->OnMouseReleased();
 574   events = collector.PopAllEvents();
 575   ASSERT_EQ(1u, events.size());
 576   EXPECT_TRUE(client->MessageHasType(events[0], "XdndDrop"));
 577
 578   EXPECT_TRUE(client->IsMoveLoopRunning());
 579   client->OnFinished(toplevel, true, client->GetAtom("XdndActionCopy"));
 580   EXPECT_FALSE(client->IsMoveLoopRunning());
 581 }
 582
 583 }  // namespace
 584
 585 // Test that XdndPosition messages are queued till the pending XdndPosition
 586 // message is acked via an XdndStatus message.
 587 TEST_F(DesktopDragDropClientAuraX11Test, QueuePosition) {
 588   base::MessageLoop::current()->PostTask(
 589       FROM_HERE,
 590       base::Bind(&QueuePositionStep2, client()));
 591   int result = StartDragAndDrop();
 592   EXPECT_EQ(ui::DragDropTypes::DRAG_COPY, result);
 593 }
 594
 595 namespace {
 596
 597 void TargetChangesStep2(TestDragDropClient* client) {
 598   EXPECT_TRUE(client->IsMoveLoopRunning());
 599
 600   XID toplevel1 = 1;
 601   ClientMessageEventCollector collector1(toplevel1, client);
 602   client->SetTopmostXWindowAndMoveMouse(toplevel1);
 603
 604   std::vector<XClientMessageEvent> events1 = collector1.PopAllEvents();
 605   ASSERT_EQ(2u, events1.size());
 606   EXPECT_TRUE(client->MessageHasType(events1[0], "XdndEnter"));
 607   EXPECT_TRUE(client->MessageHasType(events1[1], "XdndPosition"));
 608
 609   XID toplevel2 = 2;
 610   ClientMessageEventCollector collector2(toplevel2, client);
 611   client->SetTopmostXWindowAndMoveMouse(toplevel2);
 612
 613   // It is possible for |toplevel1| to send XdndStatus after the source has sent
 614   // XdndLeave but before |toplevel1| has received the XdndLeave message. The
 615   // XdndStatus message should be ignored.
 616   client->OnStatus(toplevel1, true, client->GetAtom("XdndActionCopy"));
 617   events1 = collector1.PopAllEvents();
 618   ASSERT_EQ(1u, events1.size());
 619   EXPECT_TRUE(client->MessageHasType(events1[0], "XdndLeave"));
 620
 621   std::vector<XClientMessageEvent> events2 = collector2.PopAllEvents();
 622   ASSERT_EQ(2u, events2.size());
 623   EXPECT_TRUE(client->MessageHasType(events2[0], "XdndEnter"));
 624   EXPECT_TRUE(client->MessageHasType(events2[1], "XdndPosition"));
 625
 626   client->OnStatus(toplevel2, true, client->GetAtom("XdndActionCopy"));
 627   client->OnMouseReleased();
 628   events2 = collector2.PopAllEvents();
 629   ASSERT_EQ(1u, events2.size());
 630   EXPECT_TRUE(client->MessageHasType(events2[0], "XdndDrop"));
 631
 632   EXPECT_TRUE(client->IsMoveLoopRunning());
 633   client->OnFinished(toplevel2, true, client->GetAtom("XdndActionCopy"));
 634   EXPECT_FALSE(client->IsMoveLoopRunning());
 635 }
 636
 637 }  // namespace
 638
 639 // Test the behavior when the target changes during a drag.
 640 TEST_F(DesktopDragDropClientAuraX11Test, TargetChanges) {
 641   base::MessageLoop::current()->PostTask(
 642       FROM_HERE,
 643       base::Bind(&TargetChangesStep2, client()));
 644   int result = StartDragAndDrop();
 645   EXPECT_EQ(ui::DragDropTypes::DRAG_COPY, result);
 646 }
 647
 648 namespace {
 649
 650 void RejectAfterMouseReleaseStep2(TestDragDropClient* client) {
 651   EXPECT_TRUE(client->IsMoveLoopRunning());
 652
 653   XID toplevel = 1;
 654   ClientMessageEventCollector collector(toplevel, client);
 655   client->SetTopmostXWindowAndMoveMouse(toplevel);
 656
 657   std::vector<XClientMessageEvent> events = collector.PopAllEvents();
 658   ASSERT_EQ(2u, events.size());
 659   EXPECT_TRUE(client->MessageHasType(events[0], "XdndEnter"));
 660   EXPECT_TRUE(client->MessageHasType(events[1], "XdndPosition"));
 661
 662   client->OnStatus(toplevel, true, client->GetAtom("XdndActionCopy"));
 663   EXPECT_FALSE(collector.HasEvents());
 664
 665   // Send another mouse move such that there is a pending XdndPosition.
 666   client->SetTopmostXWindowAndMoveMouse(toplevel);
 667   events = collector.PopAllEvents();
 668   ASSERT_EQ(1u, events.size());
 669   EXPECT_TRUE(client->MessageHasType(events[0], "XdndPosition"));
 670
 671   client->OnMouseReleased();
 672   // Reject the drop.
 673   client->OnStatus(toplevel, false, None);
 674
 675   events = collector.PopAllEvents();
 676   ASSERT_EQ(1u, events.size());
 677   EXPECT_TRUE(client->MessageHasType(events[0], "XdndLeave"));
 678   EXPECT_FALSE(client->IsMoveLoopRunning());
 679 }
 680
 681 void RejectAfterMouseReleaseStep3(TestDragDropClient* client) {
 682   EXPECT_TRUE(client->IsMoveLoopRunning());
 683
 684   XID toplevel = 2;
 685   ClientMessageEventCollector collector(toplevel, client);
 686   client->SetTopmostXWindowAndMoveMouse(toplevel);
 687
 688   std::vector<XClientMessageEvent> events = collector.PopAllEvents();
 689   ASSERT_EQ(2u, events.size());
 690   EXPECT_TRUE(client->MessageHasType(events[0], "XdndEnter"));
 691   EXPECT_TRUE(client->MessageHasType(events[1], "XdndPosition"));
 692
 693   client->OnStatus(toplevel, true, client->GetAtom("XdndActionCopy"));
 694   EXPECT_FALSE(collector.HasEvents());
 695
 696   client->OnMouseReleased();
 697   events = collector.PopAllEvents();
 698   ASSERT_EQ(1u, events.size());
 699   EXPECT_TRUE(client->MessageHasType(events[0], "XdndDrop"));
 700
 701   EXPECT_TRUE(client->IsMoveLoopRunning());
 702   client->OnFinished(toplevel, false, None);
 703   EXPECT_FALSE(client->IsMoveLoopRunning());
 704 }
 705
 706 }  // namespace
 707
 708 // Test that the source sends XdndLeave instead of XdndDrop if the drag
 709 // operation is rejected after the mouse is released.
 710 TEST_F(DesktopDragDropClientAuraX11Test, RejectAfterMouseRelease) {
 711   base::MessageLoop::current()->PostTask(
 712       FROM_HERE,
 713       base::Bind(&RejectAfterMouseReleaseStep2, client()));
 714   int result = StartDragAndDrop();
 715   EXPECT_EQ(ui::DragDropTypes::DRAG_NONE, result);
 716
 717   // Repeat the test but reject the drop in the XdndFinished message instead.
 718   base::MessageLoop::current()->PostTask(
 719       FROM_HERE,
 720       base::Bind(&RejectAfterMouseReleaseStep3, client()));
 721   result = StartDragAndDrop();
 722   EXPECT_EQ(ui::DragDropTypes::DRAG_NONE, result);
 723 }
 724
 725 }  // namespace views