ash/drag_drop/drag_drop_controller_unittest.cc

   1 // Copyright (c) 2012 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 "ash/drag_drop/drag_drop_controller.h"
   6
   7 #include "ash/drag_drop/drag_drop_tracker.h"
   8 #include "ash/drag_drop/drag_image_view.h"
   9 #include "ash/shell.h"
  10 #include "ash/test/ash_test_base.h"
  11 #include "base/command_line.h"
  12 #include "base/location.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "ui/aura/client/capture_client.h"
  15 #include "ui/aura/root_window.h"
  16 #include "ui/aura/test/event_generator.h"
  17 #include "ui/base/clipboard/clipboard.h"
  18 #include "ui/base/clipboard/scoped_clipboard_writer.h"
  19 #include "ui/base/dragdrop/drag_drop_types.h"
  20 #include "ui/base/dragdrop/drag_utils.h"
  21 #include "ui/base/dragdrop/os_exchange_data.h"
  22 #include "ui/base/ui_base_switches.h"
  23 #include "ui/events/event.h"
  24 #include "ui/events/event_utils.h"
  25 #include "ui/events/gestures/gesture_types.h"
  26 #include "ui/gfx/animation/linear_animation.h"
  27 #include "ui/gfx/image/image_skia_rep.h"
  28 #include "ui/views/test/test_views_delegate.h"
  29 #include "ui/views/view.h"
  30 #include "ui/views/views_delegate.h"
  31 #include "ui/views/widget/native_widget_aura.h"
  32 #include "ui/views/widget/native_widget_delegate.h"
  33 #include "ui/views/widget/widget.h"
  34
  35 namespace ash {
  36 namespace test {
  37
  38 namespace {
  39
  40 // A simple view that makes sure RunShellDrag is invoked on mouse drag.
  41 class DragTestView : public views::View {
  42  public:
  43   DragTestView() : views::View() {
  44     Reset();
  45   }
  46
  47   void Reset() {
  48     num_drag_enters_ = 0;
  49     num_drag_exits_ = 0;
  50     num_drag_updates_ = 0;
  51     num_drops_ = 0;
  52     drag_done_received_ = false;
  53     long_tap_received_ = false;
  54   }
  55
  56   int VerticalDragThreshold() {
  57     return views::View::GetVerticalDragThreshold();
  58   }
  59
  60   int HorizontalDragThreshold() {
  61     return views::View::GetHorizontalDragThreshold();
  62   }
  63
  64   int num_drag_enters_;
  65   int num_drag_exits_;
  66   int num_drag_updates_;
  67   int num_drops_;
  68   bool drag_done_received_;
  69   bool long_tap_received_;
  70
  71  private:
  72   // View overrides:
  73   virtual int GetDragOperations(const gfx::Point& press_pt) OVERRIDE {
  74     return ui::DragDropTypes::DRAG_COPY;
  75   }
  76
  77   virtual void WriteDragData(const gfx::Point& p,
  78                              OSExchangeData* data) OVERRIDE {
  79     data->SetString(UTF8ToUTF16("I am being dragged"));
  80     gfx::ImageSkiaRep image_rep(gfx::Size(10, 20), 1.0f);
  81     gfx::ImageSkia image_skia(image_rep);
  82
  83     drag_utils::SetDragImageOnDataObject(
  84         image_skia, image_skia.size(), gfx::Vector2d(), data);
  85   }
  86
  87   virtual bool OnMousePressed(const ui::MouseEvent& event) OVERRIDE {
  88     return true;
  89   }
  90
  91   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
  92     if (event->type() == ui::ET_GESTURE_LONG_TAP)
  93       long_tap_received_ = true;
  94     return;
  95   }
  96
  97   virtual bool GetDropFormats(
  98       int* formats,
  99       std::set<OSExchangeData::CustomFormat>* custom_formats) OVERRIDE {
 100     *formats = ui::OSExchangeData::STRING;
 101     return true;
 102   }
 103
 104   virtual bool CanDrop(const OSExchangeData& data) OVERRIDE {
 105     return true;
 106   }
 107
 108   virtual void OnDragEntered(const ui::DropTargetEvent& event) OVERRIDE {
 109     num_drag_enters_++;
 110   }
 111
 112   virtual int OnDragUpdated(const ui::DropTargetEvent& event) OVERRIDE {
 113     num_drag_updates_++;
 114     return ui::DragDropTypes::DRAG_COPY;
 115   }
 116
 117   virtual void OnDragExited() OVERRIDE {
 118     num_drag_exits_++;
 119   }
 120
 121   virtual int OnPerformDrop(const ui::DropTargetEvent& event) OVERRIDE {
 122     num_drops_++;
 123     return ui::DragDropTypes::DRAG_COPY;
 124   }
 125
 126   virtual void OnDragDone() OVERRIDE {
 127     drag_done_received_ = true;
 128   }
 129
 130   DISALLOW_COPY_AND_ASSIGN(DragTestView);
 131 };
 132
 133 class CompletableLinearAnimation : public gfx::LinearAnimation {
 134  public:
 135   CompletableLinearAnimation(int duration,
 136                              int frame_rate,
 137                              gfx::AnimationDelegate* delegate)
 138       : gfx::LinearAnimation(duration, frame_rate, delegate),
 139         duration_(duration) {
 140   }
 141
 142   void Complete() {
 143     Step(start_time() + base::TimeDelta::FromMilliseconds(duration_));
 144   }
 145
 146  private:
 147   int duration_;
 148 };
 149
 150 class TestDragDropController : public internal::DragDropController {
 151  public:
 152   TestDragDropController() : internal::DragDropController() {
 153     Reset();
 154   }
 155
 156   void Reset() {
 157     drag_start_received_ = false;
 158     num_drag_updates_ = 0;
 159     drop_received_ = false;
 160     drag_canceled_ = false;
 161     drag_string_.clear();
 162   }
 163
 164   virtual int StartDragAndDrop(
 165       const ui::OSExchangeData& data,
 166       aura::RootWindow* root_window,
 167       aura::Window* source_window,
 168       const gfx::Point& location,
 169       int operation,
 170       ui::DragDropTypes::DragEventSource source) OVERRIDE {
 171     drag_start_received_ = true;
 172     data.GetString(&drag_string_);
 173     return DragDropController::StartDragAndDrop(
 174         data, root_window, source_window, location, operation, source);
 175   }
 176
 177   virtual void DragUpdate(aura::Window* target,
 178                           const ui::LocatedEvent& event) OVERRIDE {
 179     DragDropController::DragUpdate(target, event);
 180     num_drag_updates_++;
 181   }
 182
 183   virtual void Drop(aura::Window* target,
 184                     const ui::LocatedEvent& event) OVERRIDE {
 185     DragDropController::Drop(target, event);
 186     drop_received_ = true;
 187   }
 188
 189   virtual void DragCancel() OVERRIDE {
 190     DragDropController::DragCancel();
 191     drag_canceled_ = true;
 192   }
 193
 194   virtual gfx::LinearAnimation* CreateCancelAnimation(
 195       int duration,
 196       int frame_rate,
 197       gfx::AnimationDelegate* delegate) OVERRIDE {
 198     return new CompletableLinearAnimation(duration, frame_rate, delegate);
 199   }
 200
 201   virtual void DoDragCancel(int animation_duration_ms) OVERRIDE {
 202     DragDropController::DoDragCancel(animation_duration_ms);
 203     drag_canceled_ = true;
 204   }
 205
 206   bool drag_start_received_;
 207   int num_drag_updates_;
 208   bool drop_received_;
 209   bool drag_canceled_;
 210   base::string16 drag_string_;
 211
 212  private:
 213   DISALLOW_COPY_AND_ASSIGN(TestDragDropController);
 214 };
 215
 216 class TestNativeWidgetAura : public views::NativeWidgetAura {
 217  public:
 218   explicit TestNativeWidgetAura(views::internal::NativeWidgetDelegate* delegate)
 219       : NativeWidgetAura(delegate),
 220         check_if_capture_lost_(false) {
 221   }
 222
 223   void set_check_if_capture_lost(bool value) {
 224     check_if_capture_lost_ = value;
 225   }
 226
 227   virtual void OnCaptureLost() OVERRIDE {
 228     DCHECK(!check_if_capture_lost_);
 229     views::NativeWidgetAura::OnCaptureLost();
 230   }
 231
 232  private:
 233   bool check_if_capture_lost_;
 234
 235   DISALLOW_COPY_AND_ASSIGN(TestNativeWidgetAura);
 236 };
 237
 238 // TODO(sky): this is for debugging, remove when track down failure.
 239 void SetCheckIfCaptureLost(views::Widget* widget, bool value) {
 240   // On Windows, the DCHECK triggers when running on bot or locally through RDP,
 241   // but not when logged in locally.
 242 #if !defined(OS_WIN)
 243   static_cast<TestNativeWidgetAura*>(widget->native_widget())->
 244       set_check_if_capture_lost(value);
 245 #endif
 246 }
 247
 248 views::Widget* CreateNewWidget() {
 249   views::Widget* widget = new views::Widget;
 250   views::Widget::InitParams params;
 251   params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS;
 252   params.accept_events = true;
 253   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 254   params.parent = Shell::GetPrimaryRootWindow();
 255   params.child = true;
 256   params.native_widget = new TestNativeWidgetAura(widget);
 257   widget->Init(params);
 258   widget->Show();
 259   return widget;
 260 }
 261
 262 void AddViewToWidgetAndResize(views::Widget* widget, views::View* view) {
 263   if (!widget->GetContentsView()) {
 264     views::View* contents_view = new views::View;
 265     widget->SetContentsView(contents_view);
 266   }
 267
 268   views::View* contents_view = widget->GetContentsView();
 269   contents_view->AddChildView(view);
 270   view->SetBounds(contents_view->width(), 0, 100, 100);
 271   gfx::Rect contents_view_bounds = contents_view->bounds();
 272   contents_view_bounds.Union(view->bounds());
 273   contents_view->SetBoundsRect(contents_view_bounds);
 274   widget->SetBounds(contents_view_bounds);
 275 }
 276
 277 void DispatchGesture(ui::EventType gesture_type, gfx::Point location) {
 278   ui::GestureEvent gesture_event(
 279       gesture_type,
 280       location.x(),
 281       location.y(),
 282       0,
 283       ui::EventTimeForNow(),
 284       ui::GestureEventDetails(gesture_type, 0, 0),
 285       1);
 286   Shell::GetPrimaryRootWindow()->DispatchGestureEvent(&gesture_event);
 287 }
 288
 289 bool IsGestureEventType(ui::EventType type) {
 290   switch (type) {
 291     case ui::ET_GESTURE_SCROLL_BEGIN:
 292     case ui::ET_GESTURE_SCROLL_END:
 293     case ui::ET_GESTURE_SCROLL_UPDATE:
 294     case ui::ET_GESTURE_TAP:
 295     case ui::ET_GESTURE_TAP_CANCEL:
 296     case ui::ET_GESTURE_TAP_DOWN:
 297     case ui::ET_GESTURE_BEGIN:
 298     case ui::ET_GESTURE_END:
 299     case ui::ET_GESTURE_TWO_FINGER_TAP:
 300     case ui::ET_GESTURE_PINCH_BEGIN:
 301     case ui::ET_GESTURE_PINCH_END:
 302     case ui::ET_GESTURE_PINCH_UPDATE:
 303     case ui::ET_GESTURE_LONG_PRESS:
 304     case ui::ET_GESTURE_LONG_TAP:
 305     case ui::ET_GESTURE_MULTIFINGER_SWIPE:
 306     case ui::ET_SCROLL_FLING_CANCEL:
 307     case ui::ET_SCROLL_FLING_START:
 308       return true;
 309     default:
 310       break;
 311   }
 312   return false;
 313 }
 314
 315 }  // namespace
 316
 317 class DragDropControllerTest : public AshTestBase {
 318  public:
 319   DragDropControllerTest() : AshTestBase() {}
 320   virtual ~DragDropControllerTest() {}
 321
 322   virtual void SetUp() OVERRIDE {
 323     AshTestBase::SetUp();
 324     drag_drop_controller_.reset(new TestDragDropController);
 325     drag_drop_controller_->set_should_block_during_drag_drop(false);
 326     aura::client::SetDragDropClient(Shell::GetPrimaryRootWindow(),
 327                                     drag_drop_controller_.get());
 328     views_delegate_.reset(new views::TestViewsDelegate);
 329   }
 330
 331   virtual void TearDown() OVERRIDE {
 332     aura::client::SetDragDropClient(Shell::GetPrimaryRootWindow(), NULL);
 333     drag_drop_controller_.reset();
 334     AshTestBase::TearDown();
 335   }
 336
 337   void UpdateDragData(ui::OSExchangeData* data) {
 338     drag_drop_controller_->drag_data_ = data;
 339   }
 340
 341   aura::Window* GetDragWindow() {
 342     return drag_drop_controller_->drag_window_;
 343   }
 344
 345   aura::Window* GetDragSourceWindow() {
 346     return drag_drop_controller_->drag_source_window_;
 347   }
 348
 349   void SetDragSourceWindow(aura::Window* drag_source_window) {
 350     drag_drop_controller_->drag_source_window_ = drag_source_window;
 351     drag_source_window->AddObserver(drag_drop_controller_.get());
 352   }
 353
 354   aura::Window* GetDragImageWindow() {
 355     return drag_drop_controller_->drag_image_.get() ?
 356         drag_drop_controller_->drag_image_->GetWidget()->GetNativeWindow() :
 357         NULL;
 358   }
 359
 360   internal::DragDropTracker* drag_drop_tracker() {
 361     return drag_drop_controller_->drag_drop_tracker_.get();
 362   }
 363
 364   void CompleteCancelAnimation() {
 365     CompletableLinearAnimation* animation =
 366         static_cast<CompletableLinearAnimation*>(
 367             drag_drop_controller_->cancel_animation_.get());
 368     animation->Complete();
 369   }
 370
 371  protected:
 372   scoped_ptr<TestDragDropController> drag_drop_controller_;
 373   scoped_ptr<views::TestViewsDelegate> views_delegate_;
 374
 375  private:
 376   DISALLOW_COPY_AND_ASSIGN(DragDropControllerTest);
 377 };
 378
 379 // TODO(win_aura) http://crbug.com/154081
 380 #if defined(OS_WIN)
 381 #define MAYBE_DragDropInSingleViewTest DISABLED_DragDropInSingleViewTest
 382 #else
 383 #define MAYBE_DragDropInSingleViewTest DragDropInSingleViewTest
 384 #endif
 385 TEST_F(DragDropControllerTest, MAYBE_DragDropInSingleViewTest) {
 386   scoped_ptr<views::Widget> widget(CreateNewWidget());
 387   DragTestView* drag_view = new DragTestView;
 388   AddViewToWidgetAndResize(widget.get(), drag_view);
 389   ui::OSExchangeData data;
 390   data.SetString(UTF8ToUTF16("I am being dragged"));
 391   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
 392                                        widget->GetNativeView());
 393   generator.PressLeftButton();
 394
 395   int num_drags = 17;
 396   SetCheckIfCaptureLost(widget.get(), true);
 397   for (int i = 0; i < num_drags; ++i) {
 398     // Because we are not doing a blocking drag and drop, the original
 399     // OSDragExchangeData object is lost as soon as we return from the drag
 400     // initiation in DragDropController::StartDragAndDrop(). Hence we set the
 401     // drag_data_ to a fake drag data object that we created.
 402     if (i > 0)
 403       UpdateDragData(&data);
 404     // 7 comes from views::View::GetVerticalDragThreshold()).
 405     if (i >= 7)
 406       SetCheckIfCaptureLost(widget.get(), false);
 407
 408     generator.MoveMouseBy(0, 1);
 409
 410     // Execute any scheduled draws to process deferred mouse events.
 411     RunAllPendingInMessageLoop();
 412   }
 413
 414   generator.ReleaseLeftButton();
 415
 416   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
 417   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold(),
 418       drag_drop_controller_->num_drag_updates_);
 419   EXPECT_TRUE(drag_drop_controller_->drop_received_);
 420   EXPECT_EQ(UTF8ToUTF16("I am being dragged"),
 421       drag_drop_controller_->drag_string_);
 422
 423   EXPECT_EQ(1, drag_view->num_drag_enters_);
 424   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold(),
 425       drag_view->num_drag_updates_);
 426   EXPECT_EQ(1, drag_view->num_drops_);
 427   EXPECT_EQ(0, drag_view->num_drag_exits_);
 428   EXPECT_TRUE(drag_view->drag_done_received_);
 429 }
 430
 431 TEST_F(DragDropControllerTest, DragDropWithZeroDragUpdates) {
 432   scoped_ptr<views::Widget> widget(CreateNewWidget());
 433   DragTestView* drag_view = new DragTestView;
 434   AddViewToWidgetAndResize(widget.get(), drag_view);
 435   ui::OSExchangeData data;
 436   data.SetString(UTF8ToUTF16("I am being dragged"));
 437   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
 438                                        widget->GetNativeView());
 439   generator.PressLeftButton();
 440
 441   int num_drags = drag_view->VerticalDragThreshold() + 1;
 442   for (int i = 0; i < num_drags; ++i) {
 443     // Because we are not doing a blocking drag and drop, the original
 444     // OSDragExchangeData object is lost as soon as we return from the drag
 445     // initiation in DragDropController::StartDragAndDrop(). Hence we set the
 446     // drag_data_ to a fake drag data object that we created.
 447     if (i > 0)
 448       UpdateDragData(&data);
 449     generator.MoveMouseBy(0, 1);
 450   }
 451
 452   UpdateDragData(&data);
 453
 454   generator.ReleaseLeftButton();
 455
 456   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
 457   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold() + 1,
 458       drag_drop_controller_->num_drag_updates_);
 459   EXPECT_TRUE(drag_drop_controller_->drop_received_);
 460
 461   EXPECT_EQ(1, drag_view->num_drag_enters_);
 462   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold() + 1,
 463       drag_view->num_drag_updates_);
 464   EXPECT_EQ(1, drag_view->num_drops_);
 465   EXPECT_EQ(0, drag_view->num_drag_exits_);
 466   EXPECT_TRUE(drag_view->drag_done_received_);
 467 }
 468
 469 // TODO(win_aura) http://crbug.com/154081
 470 #if defined(OS_WIN)
 471 #define MAYBE_DragDropInMultipleViewsSingleWidgetTest DISABLED_DragDropInMultipleViewsSingleWidgetTest
 472 #else
 473 #define MAYBE_DragDropInMultipleViewsSingleWidgetTest DragDropInMultipleViewsSingleWidgetTest
 474 #endif
 475 TEST_F(DragDropControllerTest, MAYBE_DragDropInMultipleViewsSingleWidgetTest) {
 476   scoped_ptr<views::Widget> widget(CreateNewWidget());
 477   DragTestView* drag_view1 = new DragTestView;
 478   AddViewToWidgetAndResize(widget.get(), drag_view1);
 479   DragTestView* drag_view2 = new DragTestView;
 480   AddViewToWidgetAndResize(widget.get(), drag_view2);
 481
 482   ui::OSExchangeData data;
 483   data.SetString(UTF8ToUTF16("I am being dragged"));
 484
 485   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
 486   generator.MoveMouseRelativeTo(widget->GetNativeView(),
 487                                 drag_view1->bounds().CenterPoint());
 488   generator.PressLeftButton();
 489
 490   int num_drags = drag_view1->width();
 491   for (int i = 0; i < num_drags; ++i) {
 492     // Because we are not doing a blocking drag and drop, the original
 493     // OSDragExchangeData object is lost as soon as we return from the drag
 494     // initiation in DragDropController::StartDragAndDrop(). Hence we set the
 495     // drag_data_ to a fake drag data object that we created.
 496     if (i > 0)
 497       UpdateDragData(&data);
 498     generator.MoveMouseBy(1, 0);
 499
 500     // Execute any scheduled draws to process deferred mouse events.
 501     RunAllPendingInMessageLoop();
 502   }
 503
 504   generator.ReleaseLeftButton();
 505
 506   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
 507   EXPECT_EQ(num_drags - 1 - drag_view1->HorizontalDragThreshold(),
 508       drag_drop_controller_->num_drag_updates_);
 509   EXPECT_TRUE(drag_drop_controller_->drop_received_);
 510   EXPECT_EQ(UTF8ToUTF16("I am being dragged"),
 511       drag_drop_controller_->drag_string_);
 512
 513   EXPECT_EQ(1, drag_view1->num_drag_enters_);
 514   int num_expected_updates = drag_view1->bounds().width() -
 515       drag_view1->bounds().CenterPoint().x() - 2;
 516   EXPECT_EQ(num_expected_updates - drag_view1->HorizontalDragThreshold(),
 517       drag_view1->num_drag_updates_);
 518   EXPECT_EQ(0, drag_view1->num_drops_);
 519   EXPECT_EQ(1, drag_view1->num_drag_exits_);
 520   EXPECT_TRUE(drag_view1->drag_done_received_);
 521
 522   EXPECT_EQ(1, drag_view2->num_drag_enters_);
 523   num_expected_updates = num_drags - num_expected_updates - 1;
 524   EXPECT_EQ(num_expected_updates, drag_view2->num_drag_updates_);
 525   EXPECT_EQ(1, drag_view2->num_drops_);
 526   EXPECT_EQ(0, drag_view2->num_drag_exits_);
 527   EXPECT_FALSE(drag_view2->drag_done_received_);
 528 }
 529
 530 // TODO(win_aura) http://crbug.com/154081
 531 #if defined(OS_WIN)
 532 #define MAYBE_DragDropInMultipleViewsMultipleWidgetsTest DISABLED_DragDropInMultipleViewsMultipleWidgetsTest
 533 #else
 534 #define MAYBE_DragDropInMultipleViewsMultipleWidgetsTest DragDropInMultipleViewsMultipleWidgetsTest
 535 #endif
 536 TEST_F(DragDropControllerTest, MAYBE_DragDropInMultipleViewsMultipleWidgetsTest) {
 537   scoped_ptr<views::Widget> widget1(CreateNewWidget());
 538   DragTestView* drag_view1 = new DragTestView;
 539   AddViewToWidgetAndResize(widget1.get(), drag_view1);
 540   scoped_ptr<views::Widget> widget2(CreateNewWidget());
 541   DragTestView* drag_view2 = new DragTestView;
 542   AddViewToWidgetAndResize(widget2.get(), drag_view2);
 543   gfx::Rect widget1_bounds = widget1->GetClientAreaBoundsInScreen();
 544   gfx::Rect widget2_bounds = widget2->GetClientAreaBoundsInScreen();
 545   widget2->SetBounds(gfx::Rect(widget1_bounds.width(), 0,
 546       widget2_bounds.width(), widget2_bounds.height()));
 547
 548   ui::OSExchangeData data;
 549   data.SetString(UTF8ToUTF16("I am being dragged"));
 550
 551   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
 552                                        widget1->GetNativeView());
 553   generator.PressLeftButton();
 554
 555   int num_drags = drag_view1->width();
 556   for (int i = 0; i < num_drags; ++i) {
 557     // Because we are not doing a blocking drag and drop, the original
 558     // OSDragExchangeData object is lost as soon as we return from the drag
 559     // initiation in DragDropController::StartDragAndDrop(). Hence we set the
 560     // drag_data_ to a fake drag data object that we created.
 561     if (i > 0)
 562       UpdateDragData(&data);
 563     generator.MoveMouseBy(1, 0);
 564
 565     // Execute any scheduled draws to process deferred mouse events.
 566     RunAllPendingInMessageLoop();
 567   }
 568
 569   generator.ReleaseLeftButton();
 570
 571   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
 572   EXPECT_EQ(num_drags - 1 - drag_view1->HorizontalDragThreshold(),
 573       drag_drop_controller_->num_drag_updates_);
 574   EXPECT_TRUE(drag_drop_controller_->drop_received_);
 575   EXPECT_EQ(UTF8ToUTF16("I am being dragged"),
 576       drag_drop_controller_->drag_string_);
 577
 578   EXPECT_EQ(1, drag_view1->num_drag_enters_);
 579   int num_expected_updates = drag_view1->bounds().width() -
 580       drag_view1->bounds().CenterPoint().x() - 2;
 581   EXPECT_EQ(num_expected_updates - drag_view1->HorizontalDragThreshold(),
 582       drag_view1->num_drag_updates_);
 583   EXPECT_EQ(0, drag_view1->num_drops_);
 584   EXPECT_EQ(1, drag_view1->num_drag_exits_);
 585   EXPECT_TRUE(drag_view1->drag_done_received_);
 586
 587   EXPECT_EQ(1, drag_view2->num_drag_enters_);
 588   num_expected_updates = num_drags - num_expected_updates - 1;
 589   EXPECT_EQ(num_expected_updates, drag_view2->num_drag_updates_);
 590   EXPECT_EQ(1, drag_view2->num_drops_);
 591   EXPECT_EQ(0, drag_view2->num_drag_exits_);
 592   EXPECT_FALSE(drag_view2->drag_done_received_);
 593 }
 594
 595 // TODO(win_aura) http://crbug.com/154081
 596 #if defined(OS_WIN)
 597 #define MAYBE_ViewRemovedWhileInDragDropTest DISABLED_ViewRemovedWhileInDragDropTest
 598 #else
 599 #define MAYBE_ViewRemovedWhileInDragDropTest ViewRemovedWhileInDragDropTest
 600 #endif
 601 TEST_F(DragDropControllerTest, MAYBE_ViewRemovedWhileInDragDropTest) {
 602   scoped_ptr<views::Widget> widget(CreateNewWidget());
 603   scoped_ptr<DragTestView> drag_view(new DragTestView);
 604   AddViewToWidgetAndResize(widget.get(), drag_view.get());
 605   gfx::Point point = gfx::Rect(drag_view->bounds()).CenterPoint();
 606   ui::OSExchangeData data;
 607   data.SetString(UTF8ToUTF16("I am being dragged"));
 608
 609   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
 610   generator.MoveMouseToCenterOf(widget->GetNativeView());
 611   generator.PressLeftButton();
 612
 613   int num_drags_1 = 17;
 614   for (int i = 0; i < num_drags_1; ++i) {
 615     // Because we are not doing a blocking drag and drop, the original
 616     // OSDragExchangeData object is lost as soon as we return from the drag
 617     // initiation in DragDropController::StartDragAndDrop(). Hence we set the
 618     // drag_data_ to a fake drag data object that we created.
 619     if (i > 0)
 620       UpdateDragData(&data);
 621     generator.MoveMouseBy(0, 1);
 622
 623     // Execute any scheduled draws to process deferred mouse events.
 624     RunAllPendingInMessageLoop();
 625   }
 626
 627   drag_view->parent()->RemoveChildView(drag_view.get());
 628   // View has been removed. We will not get any of the following drag updates.
 629   int num_drags_2 = 23;
 630   for (int i = 0; i < num_drags_2; ++i) {
 631     UpdateDragData(&data);
 632     generator.MoveMouseBy(0, 1);
 633
 634     // Execute any scheduled draws to process deferred mouse events.
 635     RunAllPendingInMessageLoop();
 636   }
 637
 638   generator.ReleaseLeftButton();
 639
 640   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
 641   EXPECT_EQ(num_drags_1 + num_drags_2 - 1 - drag_view->VerticalDragThreshold(),
 642       drag_drop_controller_->num_drag_updates_);
 643   EXPECT_TRUE(drag_drop_controller_->drop_received_);
 644   EXPECT_EQ(UTF8ToUTF16("I am being dragged"),
 645       drag_drop_controller_->drag_string_);
 646
 647   EXPECT_EQ(1, drag_view->num_drag_enters_);
 648   EXPECT_EQ(num_drags_1 - 1 - drag_view->VerticalDragThreshold(),
 649       drag_view->num_drag_updates_);
 650   EXPECT_EQ(0, drag_view->num_drops_);
 651   EXPECT_EQ(0, drag_view->num_drag_exits_);
 652   EXPECT_TRUE(drag_view->drag_done_received_);
 653 }
 654
 655 TEST_F(DragDropControllerTest, DragLeavesClipboardAloneTest) {
 656   ui::Clipboard* cb = ui::Clipboard::GetForCurrentThread();
 657   std::string clip_str("I am on the clipboard");
 658   {
 659     // We first copy some text to the clipboard.
 660     ui::ScopedClipboardWriter scw(cb, ui::Clipboard::BUFFER_STANDARD);
 661     scw.WriteText(ASCIIToUTF16(clip_str));
 662   }
 663   EXPECT_TRUE(cb->IsFormatAvailable(ui::Clipboard::GetPlainTextFormatType(),
 664       ui::Clipboard::BUFFER_STANDARD));
 665
 666   scoped_ptr<views::Widget> widget(CreateNewWidget());
 667   DragTestView* drag_view = new DragTestView;
 668   AddViewToWidgetAndResize(widget.get(), drag_view);
 669
 670   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
 671                                        widget->GetNativeView());
 672   ui::OSExchangeData data;
 673   std::string data_str("I am being dragged");
 674   data.SetString(ASCIIToUTF16(data_str));
 675
 676   generator.PressLeftButton();
 677   generator.MoveMouseBy(0, drag_view->VerticalDragThreshold() + 1);
 678
 679   // Execute any scheduled draws to process deferred mouse events.
 680   RunAllPendingInMessageLoop();
 681
 682   // Verify the clipboard contents haven't changed
 683   std::string result;
 684   EXPECT_TRUE(cb->IsFormatAvailable(ui::Clipboard::GetPlainTextFormatType(),
 685       ui::Clipboard::BUFFER_STANDARD));
 686   cb->ReadAsciiText(ui::Clipboard::BUFFER_STANDARD, &result);
 687   EXPECT_EQ(clip_str, result);
 688   // Destory the clipboard here because ash doesn't delete it.
 689   // crbug.com/158150.
 690   ui::Clipboard::DestroyClipboardForCurrentThread();
 691 }
 692
 693 TEST_F(DragDropControllerTest, WindowDestroyedDuringDragDrop) {
 694   scoped_ptr<views::Widget> widget(CreateNewWidget());
 695   DragTestView* drag_view = new DragTestView;
 696   AddViewToWidgetAndResize(widget.get(), drag_view);
 697   aura::Window* window = widget->GetNativeView();
 698
 699   ui::OSExchangeData data;
 700   data.SetString(UTF8ToUTF16("I am being dragged"));
 701   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
 702                                        widget->GetNativeView());
 703   generator.PressLeftButton();
 704
 705   int num_drags = 17;
 706   for (int i = 0; i < num_drags; ++i) {
 707     // Because we are not doing a blocking drag and drop, the original
 708     // OSDragExchangeData object is lost as soon as we return from the drag
 709     // initiation in DragDropController::StartDragAndDrop(). Hence we set the
 710     // drag_data_ to a fake drag data object that we created.
 711     if (i > 0)
 712       UpdateDragData(&data);
 713     generator.MoveMouseBy(0, 1);
 714
 715     // Execute any scheduled draws to process deferred mouse events.
 716     RunAllPendingInMessageLoop();
 717
 718     if (i > drag_view->VerticalDragThreshold())
 719       EXPECT_EQ(window, GetDragWindow());
 720   }
 721
 722   widget->CloseNow();
 723   EXPECT_FALSE(GetDragWindow());
 724
 725   num_drags = 23;
 726   for (int i = 0; i < num_drags; ++i) {
 727     if (i > 0)
 728       UpdateDragData(&data);
 729     generator.MoveMouseBy(0, 1);
 730     // We should not crash here.
 731   }
 732
 733   generator.ReleaseLeftButton();
 734
 735   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
 736   EXPECT_TRUE(drag_drop_controller_->drop_received_);
 737 }
 738
 739 TEST_F(DragDropControllerTest, SyntheticEventsDuringDragDrop) {
 740   scoped_ptr<views::Widget> widget(CreateNewWidget());
 741   DragTestView* drag_view = new DragTestView;
 742   AddViewToWidgetAndResize(widget.get(), drag_view);
 743   ui::OSExchangeData data;
 744   data.SetString(UTF8ToUTF16("I am being dragged"));
 745   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
 746                                        widget->GetNativeView());
 747   generator.PressLeftButton();
 748
 749   int num_drags = 17;
 750   for (int i = 0; i < num_drags; ++i) {
 751     // Because we are not doing a blocking drag and drop, the original
 752     // OSDragExchangeData object is lost as soon as we return from the drag
 753     // initiation in DragDropController::StartDragAndDrop(). Hence we set the
 754     // drag_data_ to a fake drag data object that we created.
 755     if (i > 0)
 756       UpdateDragData(&data);
 757     generator.MoveMouseBy(0, 1);
 758
 759     // We send a unexpected mouse move event. Note that we cannot use
 760     // EventGenerator since it implicitly turns these into mouse drag events.
 761     // The DragDropController should simply ignore these events.
 762     gfx::Point mouse_move_location = drag_view->bounds().CenterPoint();
 763     ui::MouseEvent mouse_move(ui::ET_MOUSE_MOVED, mouse_move_location,
 764                               mouse_move_location, 0);
 765     Shell::GetPrimaryRootWindow()->AsRootWindowHostDelegate()->OnHostMouseEvent(
 766         &mouse_move);
 767   }
 768
 769   generator.ReleaseLeftButton();
 770
 771   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
 772   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold(),
 773       drag_drop_controller_->num_drag_updates_);
 774   EXPECT_TRUE(drag_drop_controller_->drop_received_);
 775   EXPECT_EQ(UTF8ToUTF16("I am being dragged"),
 776       drag_drop_controller_->drag_string_);
 777
 778   EXPECT_EQ(1, drag_view->num_drag_enters_);
 779   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold(),
 780       drag_view->num_drag_updates_);
 781   EXPECT_EQ(1, drag_view->num_drops_);
 782   EXPECT_EQ(0, drag_view->num_drag_exits_);
 783   EXPECT_TRUE(drag_view->drag_done_received_);
 784 }
 785
 786 // TODO(win_aura) http://crbug.com/154081
 787 #if defined(OS_WIN)
 788 #define MAYBE_PressingEscapeCancelsDragDrop DISABLED_PressingEscapeCancelsDragDrop
 789 #define MAYBE_CaptureLostCancelsDragDrop DISABLED_CaptureLostCancelsDragDrop
 790 #else
 791 #define MAYBE_PressingEscapeCancelsDragDrop PressingEscapeCancelsDragDrop
 792 #define MAYBE_CaptureLostCancelsDragDrop CaptureLostCancelsDragDrop
 793 #endif
 794 TEST_F(DragDropControllerTest, MAYBE_PressingEscapeCancelsDragDrop) {
 795   scoped_ptr<views::Widget> widget(CreateNewWidget());
 796   DragTestView* drag_view = new DragTestView;
 797   AddViewToWidgetAndResize(widget.get(), drag_view);
 798   ui::OSExchangeData data;
 799   data.SetString(UTF8ToUTF16("I am being dragged"));
 800   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
 801                                        widget->GetNativeView());
 802   generator.PressLeftButton();
 803
 804   int num_drags = 17;
 805   for (int i = 0; i < num_drags; ++i) {
 806     // Because we are not doing a blocking drag and drop, the original
 807     // OSDragExchangeData object is lost as soon as we return from the drag
 808     // initiation in DragDropController::StartDragAndDrop(). Hence we set the
 809     // drag_data_ to a fake drag data object that we created.
 810     if (i > 0)
 811       UpdateDragData(&data);
 812     generator.MoveMouseBy(0, 1);
 813
 814     // Execute any scheduled draws to process deferred mouse events.
 815     RunAllPendingInMessageLoop();
 816   }
 817
 818   generator.PressKey(ui::VKEY_ESCAPE, 0);
 819
 820   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
 821   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold(),
 822       drag_drop_controller_->num_drag_updates_);
 823   EXPECT_FALSE(drag_drop_controller_->drop_received_);
 824   EXPECT_TRUE(drag_drop_controller_->drag_canceled_);
 825   EXPECT_EQ(UTF8ToUTF16("I am being dragged"),
 826       drag_drop_controller_->drag_string_);
 827
 828   EXPECT_EQ(1, drag_view->num_drag_enters_);
 829   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold(),
 830       drag_view->num_drag_updates_);
 831   EXPECT_EQ(0, drag_view->num_drops_);
 832   EXPECT_EQ(1, drag_view->num_drag_exits_);
 833   EXPECT_TRUE(drag_view->drag_done_received_);
 834 }
 835
 836 TEST_F(DragDropControllerTest, MAYBE_CaptureLostCancelsDragDrop) {
 837   scoped_ptr<views::Widget> widget(CreateNewWidget());
 838   DragTestView* drag_view = new DragTestView;
 839   AddViewToWidgetAndResize(widget.get(), drag_view);
 840   ui::OSExchangeData data;
 841   data.SetString(UTF8ToUTF16("I am being dragged"));
 842   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
 843                                        widget->GetNativeView());
 844   generator.PressLeftButton();
 845
 846   int num_drags = 17;
 847   for (int i = 0; i < num_drags; ++i) {
 848     // Because we are not doing a blocking drag and drop, the original
 849     // OSDragExchangeData object is lost as soon as we return from the drag
 850     // initiation in DragDropController::StartDragAndDrop(). Hence we set the
 851     // drag_data_ to a fake drag data object that we created.
 852     if (i > 0)
 853       UpdateDragData(&data);
 854     generator.MoveMouseBy(0, 1);
 855
 856     // Execute any scheduled draws to process deferred mouse events.
 857     RunAllPendingInMessageLoop();
 858   }
 859   // Make sure the capture window won't handle mouse events.
 860   aura::Window* capture_window = drag_drop_tracker()->capture_window();
 861   ASSERT_TRUE(!!capture_window);
 862   EXPECT_EQ("0x0", capture_window->bounds().size().ToString());
 863   EXPECT_EQ(NULL,
 864             capture_window->GetEventHandlerForPoint(gfx::Point()));
 865   EXPECT_EQ(NULL,
 866             capture_window->GetTopWindowContainingPoint(gfx::Point()));
 867
 868   aura::client::GetCaptureClient(widget->GetNativeView()->GetRootWindow())->
 869       SetCapture(NULL);
 870
 871   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
 872   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold(),
 873       drag_drop_controller_->num_drag_updates_);
 874   EXPECT_FALSE(drag_drop_controller_->drop_received_);
 875   EXPECT_TRUE(drag_drop_controller_->drag_canceled_);
 876   EXPECT_EQ(UTF8ToUTF16("I am being dragged"),
 877       drag_drop_controller_->drag_string_);
 878
 879   EXPECT_EQ(1, drag_view->num_drag_enters_);
 880   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold(),
 881       drag_view->num_drag_updates_);
 882   EXPECT_EQ(0, drag_view->num_drops_);
 883   EXPECT_EQ(1, drag_view->num_drag_exits_);
 884   EXPECT_TRUE(drag_view->drag_done_received_);
 885 }
 886
 887 TEST_F(DragDropControllerTest, TouchDragDropInMultipleWindows) {
 888   CommandLine::ForCurrentProcess()->AppendSwitch(
 889       switches::kEnableTouchDragDrop);
 890   scoped_ptr<views::Widget> widget1(CreateNewWidget());
 891   DragTestView* drag_view1 = new DragTestView;
 892   AddViewToWidgetAndResize(widget1.get(), drag_view1);
 893   scoped_ptr<views::Widget> widget2(CreateNewWidget());
 894   DragTestView* drag_view2 = new DragTestView;
 895   AddViewToWidgetAndResize(widget2.get(), drag_view2);
 896   gfx::Rect widget1_bounds = widget1->GetClientAreaBoundsInScreen();
 897   gfx::Rect widget2_bounds = widget2->GetClientAreaBoundsInScreen();
 898   widget2->SetBounds(gfx::Rect(widget1_bounds.width(), 0,
 899       widget2_bounds.width(), widget2_bounds.height()));
 900
 901   ui::OSExchangeData data;
 902   data.SetString(UTF8ToUTF16("I am being dragged"));
 903
 904   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
 905                                        widget1->GetNativeView());
 906   generator.PressTouch();
 907   gfx::Point point = gfx::Rect(drag_view1->bounds()).CenterPoint();
 908   DispatchGesture(ui::ET_GESTURE_LONG_PRESS, point);
 909   // Because we are not doing a blocking drag and drop, the original
 910   // OSDragExchangeData object is lost as soon as we return from the drag
 911   // initiation in DragDropController::StartDragAndDrop(). Hence we set the
 912   // drag_data_ to a fake drag data object that we created.
 913   UpdateDragData(&data);
 914   gfx::Point gesture_location = point;
 915   int num_drags = drag_view1->width();
 916   for (int i = 0; i < num_drags; ++i) {
 917     gesture_location.Offset(1, 0);
 918     DispatchGesture(ui::ET_GESTURE_SCROLL_UPDATE, gesture_location);
 919
 920     // Execute any scheduled draws to process deferred mouse events.
 921     RunAllPendingInMessageLoop();
 922   }
 923
 924   DispatchGesture(ui::ET_GESTURE_SCROLL_END, gesture_location);
 925
 926   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
 927   EXPECT_EQ(num_drags, drag_drop_controller_->num_drag_updates_);
 928   EXPECT_TRUE(drag_drop_controller_->drop_received_);
 929   EXPECT_EQ(UTF8ToUTF16("I am being dragged"),
 930       drag_drop_controller_->drag_string_);
 931
 932   EXPECT_EQ(1, drag_view1->num_drag_enters_);
 933   int num_expected_updates = drag_view1->bounds().width() -
 934       drag_view1->bounds().CenterPoint().x() - 1;
 935   EXPECT_EQ(num_expected_updates, drag_view1->num_drag_updates_);
 936   EXPECT_EQ(0, drag_view1->num_drops_);
 937   EXPECT_EQ(1, drag_view1->num_drag_exits_);
 938   EXPECT_TRUE(drag_view1->drag_done_received_);
 939
 940   EXPECT_EQ(1, drag_view2->num_drag_enters_);
 941   num_expected_updates = num_drags - num_expected_updates;
 942   EXPECT_EQ(num_expected_updates, drag_view2->num_drag_updates_);
 943   EXPECT_EQ(1, drag_view2->num_drops_);
 944   EXPECT_EQ(0, drag_view2->num_drag_exits_);
 945   EXPECT_FALSE(drag_view2->drag_done_received_);
 946 }
 947
 948 TEST_F(DragDropControllerTest, TouchDragDropCancelsOnLongTap) {
 949   CommandLine::ForCurrentProcess()->AppendSwitch(
 950       switches::kEnableTouchDragDrop);
 951   scoped_ptr<views::Widget> widget(CreateNewWidget());
 952   DragTestView* drag_view = new DragTestView;
 953   AddViewToWidgetAndResize(widget.get(), drag_view);
 954   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
 955                                        widget->GetNativeView());
 956
 957   generator.PressTouch();
 958   gfx::Point point = gfx::Rect(drag_view->bounds()).CenterPoint();
 959   DispatchGesture(ui::ET_GESTURE_LONG_PRESS, point);
 960   DispatchGesture(ui::ET_GESTURE_LONG_TAP, point);
 961
 962   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
 963   EXPECT_TRUE(drag_drop_controller_->drag_canceled_);
 964   EXPECT_EQ(0, drag_drop_controller_->num_drag_updates_);
 965   EXPECT_FALSE(drag_drop_controller_->drop_received_);
 966   EXPECT_EQ(UTF8ToUTF16("I am being dragged"),
 967             drag_drop_controller_->drag_string_);
 968   EXPECT_EQ(0, drag_view->num_drag_enters_);
 969   EXPECT_EQ(0, drag_view->num_drops_);
 970   EXPECT_EQ(0, drag_view->num_drag_exits_);
 971   EXPECT_TRUE(drag_view->drag_done_received_);
 972 }
 973
 974 TEST_F(DragDropControllerTest, TouchDragDropLongTapGestureIsForwarded) {
 975   CommandLine::ForCurrentProcess()->AppendSwitch(
 976       switches::kEnableTouchDragDrop);
 977   scoped_ptr<views::Widget> widget(CreateNewWidget());
 978   DragTestView* drag_view = new DragTestView;
 979   AddViewToWidgetAndResize(widget.get(), drag_view);
 980   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
 981                                        widget->GetNativeView());
 982
 983   generator.PressTouch();
 984   gfx::Point point = gfx::Rect(drag_view->bounds()).CenterPoint();
 985   DispatchGesture(ui::ET_GESTURE_LONG_PRESS, point);
 986
 987   // Since we are not running inside a nested loop, the |drag_source_window_|
 988   // will get destroyed immediately. Hence we reassign it.
 989   EXPECT_EQ(NULL, GetDragSourceWindow());
 990   SetDragSourceWindow(widget->GetNativeView());
 991   EXPECT_FALSE(drag_view->long_tap_received_);
 992   DispatchGesture(ui::ET_GESTURE_LONG_TAP, point);
 993   CompleteCancelAnimation();
 994   EXPECT_TRUE(drag_view->long_tap_received_);
 995 }
 996
 997 namespace {
 998
 999 class DragImageWindowObserver : public aura::WindowObserver {
1000  public:
1001   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
1002     window_location_on_destroying_ = window->GetBoundsInScreen().origin();
1003   }
1004
1005   gfx::Point window_location_on_destroying() const {
1006     return window_location_on_destroying_;
1007   }
1008
1009  public:
1010   gfx::Point window_location_on_destroying_;
1011 };
1012
1013 }
1014
1015 // Verifies the drag image moves back to the position where drag is started
1016 // across displays when drag is cancelled.
1017 TEST_F(DragDropControllerTest, DragCancelAcrossDisplays) {
1018   if (!SupportsMultipleDisplays())
1019     return;
1020
1021   UpdateDisplay("400x400,400x400");
1022   Shell::RootWindowList root_windows =
1023       Shell::GetInstance()->GetAllRootWindows();
1024   for (Shell::RootWindowList::iterator iter = root_windows.begin();
1025        iter != root_windows.end(); ++iter) {
1026     aura::client::SetDragDropClient(*iter, drag_drop_controller_.get());
1027   }
1028
1029   ui::OSExchangeData data;
1030   data.SetString(UTF8ToUTF16("I am being dragged"));
1031   {
1032     scoped_ptr<views::Widget> widget(CreateNewWidget());
1033     aura::Window* window = widget->GetNativeWindow();
1034     drag_drop_controller_->StartDragAndDrop(
1035         data,
1036         window->GetRootWindow(),
1037         window,
1038         gfx::Point(5, 5),
1039         ui::DragDropTypes::DRAG_MOVE,
1040         ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE);
1041
1042     DragImageWindowObserver observer;
1043     ASSERT_TRUE(GetDragImageWindow());
1044     GetDragImageWindow()->AddObserver(&observer);
1045
1046     {
1047       ui::MouseEvent e(ui::ET_MOUSE_DRAGGED,
1048                        gfx::Point(200, 0),
1049                        gfx::Point(200, 0),
1050                        ui::EF_NONE);
1051       drag_drop_controller_->DragUpdate(window, e);
1052     }
1053     {
1054       ui::MouseEvent e(ui::ET_MOUSE_DRAGGED,
1055                        gfx::Point(600, 0),
1056                        gfx::Point(600, 0),
1057                        ui::EF_NONE);
1058       drag_drop_controller_->DragUpdate(window, e);
1059     }
1060
1061     drag_drop_controller_->DragCancel();
1062     CompleteCancelAnimation();
1063
1064     EXPECT_EQ("5,5", observer.window_location_on_destroying().ToString());
1065   }
1066
1067   {
1068     scoped_ptr<views::Widget> widget(CreateNewWidget());
1069     aura::Window* window = widget->GetNativeWindow();
1070     drag_drop_controller_->StartDragAndDrop(
1071         data,
1072         window->GetRootWindow(),
1073         window,
1074         gfx::Point(405, 405),
1075         ui::DragDropTypes::DRAG_MOVE,
1076         ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE);
1077     DragImageWindowObserver observer;
1078     ASSERT_TRUE(GetDragImageWindow());
1079     GetDragImageWindow()->AddObserver(&observer);
1080
1081     {
1082       ui::MouseEvent e(ui::ET_MOUSE_DRAGGED,
1083                        gfx::Point(600, 0),
1084                        gfx::Point(600, 0),
1085                        ui::EF_NONE);
1086       drag_drop_controller_->DragUpdate(window, e);
1087     }
1088     {
1089       ui::MouseEvent e(ui::ET_MOUSE_DRAGGED,
1090                        gfx::Point(200, 0),
1091                        gfx::Point(200, 0),
1092                        ui::EF_NONE);
1093       drag_drop_controller_->DragUpdate(window, e);
1094     }
1095
1096     drag_drop_controller_->DragCancel();
1097     CompleteCancelAnimation();
1098
1099     EXPECT_EQ("405,405", observer.window_location_on_destroying().ToString());
1100   }
1101   for (Shell::RootWindowList::iterator iter = root_windows.begin();
1102        iter != root_windows.end(); ++iter) {
1103     aura::client::SetDragDropClient(*iter, NULL);
1104   }
1105 }
1106
1107 }  // namespace test
1108 }  // namespace aura