Support Drag and Drop across displays.

ash/drag_drop/drag_drop_controller.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 "ash/drag_drop/drag_drop_controller.h"
 
+#include "ash/drag_drop/drag_drop_tracker.h"
 #include "ash/drag_drop/drag_image_view.h"
 #include "ash/shell.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/cursor_manager.h"
 #include "base/message_loop.h"
 #include "base/run_loop.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/drag_drop_delegate.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
@@ skipping 20 matching lines @@
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // DragDropController, public:
 
 DragDropController::DragDropController()
     : drag_image_(NULL),
       drag_data_(NULL),
       drag_operation_(0),
       drag_window_(NULL),
-      drag_drop_in_progress_(false),
       should_block_during_drag_drop_(true) {
   Shell::GetInstance()->AddEnvEventFilter(this);
 }
 
 DragDropController::~DragDropController() {
   Shell::GetInstance()->RemoveEnvEventFilter(this);
   Cleanup();
   if (drag_image_.get())
     drag_image_.reset();
 }
 
 int DragDropController::StartDragAndDrop(const ui::OSExchangeData& data,
+                                         aura::RootWindow* root_window,
                                          const gfx::Point& root_location,
                                          int operation) {
-  DCHECK(!drag_drop_in_progress_);
-  // TODO(oshima): Add CaptureClient client API.
-  aura::Window* capture_window =
-      aura::client::GetCaptureWindow(Shell::GetPrimaryRootWindow());
-  if (capture_window)
-    capture_window->ReleaseCapture();
-  drag_drop_in_progress_ = true;
+  DCHECK(!IsDragDropInProgress());
+
   drag_cursor_ = ui::kCursorPointer;
+  drag_drop_tracker_.reset(new DragDropTracker(root_window));
 
   drag_data_ = &data;
   drag_operation_ = operation;
   const ui::OSExchangeDataProviderAura& provider =
       static_cast<const ui::OSExchangeDataProviderAura&>(data.provider());
 
   drag_image_.reset(new DragImageView);
   drag_image_->SetImage(provider.drag_image());
   drag_image_offset_ = provider.drag_image_offset();
   drag_image_->SetBoundsInScreen(gfx::Rect(
@@ skipping 110 matching lines @@
     delegate->OnDragExited();
 
   Cleanup();
   drag_operation_ = 0;
   StartCanceledAnimation();
   if (should_block_during_drag_drop_)
     quit_closure_.Run();
 }
 
 bool DragDropController::IsDragDropInProgress() {
-  return drag_drop_in_progress_;
+  return !!drag_drop_tracker_.get();
 }
 
 gfx::NativeCursor DragDropController::GetDragCursor() {
   return drag_cursor_;
 }
 
 bool DragDropController::PreHandleKeyEvent(aura::Window* target,
                                            ui::KeyEvent* event) {
-  if (drag_drop_in_progress_ && event->key_code() == ui::VKEY_ESCAPE) {
+  if (IsDragDropInProgress() && event->key_code() == ui::VKEY_ESCAPE) {
     DragCancel();
     return true;
   }
   return false;
 }
 
 bool DragDropController::PreHandleMouseEvent(aura::Window* target,
                                              ui::MouseEvent* event) {
-  if (!drag_drop_in_progress_)
+  if (!IsDragDropInProgress())
     return false;
-  switch (event->type()) {
+  aura::Window* translated_target = drag_drop_tracker_->GetTarget(*event);
+  if (!translated_target)
+    return false;
+  scoped_ptr<ui::MouseEvent> translated_event(
+      drag_drop_tracker_->ConvertMouseEvent(translated_target, *event));
+  switch (translated_event->type()) {
     case ui::ET_MOUSE_DRAGGED:
-      DragUpdate(target, *event);
+      DragUpdate(translated_target, *translated_event.get());
       break;
     case ui::ET_MOUSE_RELEASED:
-      Drop(target, *event);
+      Drop(translated_target, *translated_event.get());
       break;
     default:
-      // We could reach here if the user drops outside the root window.
       // We could also reach here because RootWindow may sometimes generate a
       // bunch of fake mouse events
       // (aura::RootWindow::PostMouseMoveEventAfterWindowChange).
       break;
   }
   return true;
 }
 
 ui::TouchStatus DragDropController::PreHandleTouchEvent(
     aura::Window* target,
     ui::TouchEvent* event) {
   // TODO(sad): Also check for the touch-id.
-  if (!drag_drop_in_progress_)
+  if (!IsDragDropInProgress())
     return ui::TOUCH_STATUS_UNKNOWN;
   switch (event->type()) {
     case ui::ET_TOUCH_MOVED:
       DragUpdate(target, *event);
       break;
     case ui::ET_TOUCH_RELEASED:
       Drop(target, *event);
       break;
     case ui::ET_TOUCH_CANCELLED:
       DragCancel();
@@ skipping 18 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DragDropController, private:
 
 void DragDropController::OnImplicitAnimationsCompleted() {
   DCHECK(drag_image_.get());
 
   // By the time we finish animation, another drag/drop session may have
   // started. We do not want to destroy the drag image in that case.
-  if (!drag_drop_in_progress_)
+  if (!IsDragDropInProgress())
     drag_image_.reset();
 }
 
 void DragDropController::StartCanceledAnimation() {
   aura::Window* window = drag_image_->GetWidget()->GetNativeView();
   ui::LayerAnimator* animator = window->layer()->GetAnimator();
   animator->set_preemption_strategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 
   // Stop waiting for any as yet unfinished implicit animations.
   StopObservingImplicitAnimations();
 
   ui::ScopedLayerAnimationSettings animation_setter(animator);
   animation_setter.SetTransitionDuration(kDragDropAnimationDuration);
   animation_setter.AddObserver(this);
   window->SetBounds(gfx::Rect(drag_start_location_, window->bounds().size()));
 }
 
 void DragDropController::Cleanup() {
   if (drag_window_)
     drag_window_->RemoveObserver(this);
   drag_window_ = NULL;
   drag_data_ = NULL;
-  drag_drop_in_progress_ = false;
+  drag_drop_tracker_.reset();
 }
 
 }  // namespace internal
 }  // namespace ash