Desktop Aura: Allow tab drags out of window.

chrome/browser/ui/views/tabs/tab_drag_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 "chrome/browser/ui/views/tabs/tab_drag_controller.h"
 
 #include <math.h>
 #include <set>
 
 #include "base/callback.h"
@@ skipping 466 matching lines @@
 
   if (!started_drag_) {
     if (!CanStartDrag(real_point_in_screen))
       return;  // User hasn't dragged far enough yet.
 
     started_drag_ = true;
     SaveFocus();
     Attach(source_tabstrip_, gfx::Point());
     if (detach_into_browser_ && static_cast<int>(drag_data_.size()) ==
         GetModel(source_tabstrip_)->count()) {
-      RunMoveLoop();  // Runs a nested loop, returning when done.
+      gfx::Point dragged_view_point = GetWindowOffset(point_in_screen);
+      RunMoveLoop(dragged_view_point);
       return;
     }
   }
 
   ContinueDragging(real_point_in_screen);
 }
 
 void TabDragController::EndDrag(bool canceled) {
   EndDragImpl(canceled && source_tabstrip_ ? CANCELED : NORMAL);
 }
@@ skipping 661 matching lines @@
   // ratio of mouse_offset_ to original width is maintained.
   std::vector<BaseTab*> tabs_to_source(tabs);
   tabs_to_source.erase(tabs_to_source.begin() + source_tab_index_ + 1,
                        tabs_to_source.end());
   int new_x = attached_tabstrip_->GetSizeNeededForTabs(tabs_to_source) -
       tabs[source_tab_index_]->width() +
       static_cast<int>(offset_to_width_ratio_ *
                        tabs[source_tab_index_]->width());
   mouse_offset_.set_x(new_x);
 
+  views::View* toplevel_view =
+      attached_tabstrip->GetWidget()->GetContentsView();
+  window_mouse_offset_ = point_in_screen;
+  views::View::ConvertPointFromScreen(toplevel_view, &window_mouse_offset_);
+
   // Transfer ownership of us to the new tabstrip as well as making sure the
   // window has capture. This is important so that if activation changes the
   // drag isn't prematurely canceled.
   if (detach_into_browser_) {
     attached_tabstrip_->GetWidget()->SetCapture(attached_tabstrip_);
     attached_tabstrip_->OwnDragController(this);
   }
 
   // Redirect all mouse events to the TabStrip so that the tab that originated
   // the drag can safely be deleted.
@@ skipping 80 matching lines @@
   attached_tabstrip_ = NULL;
 }
 
 void TabDragController::DetachIntoNewBrowserAndRunMoveLoop(
     const gfx::Point& point_in_screen) {
   if (GetModel(attached_tabstrip_)->count() ==
       static_cast<int>(drag_data_.size())) {
     // All the tabs in a browser are being dragged but all the tabs weren't
     // initially being dragged. For this to happen the user would have to
     // start dragging a set of tabs, the other tabs close, then detach.
-    RunMoveLoop();
+    gfx::Point dragged_view_point = GetWindowOffset(point_in_screen);
+    RunMoveLoop(dragged_view_point);
     return;
   }
 
   // Create a new browser to house the dragged tabs and have the OS run a move
   // loop.
 
   gfx::Point attached_point = GetAttachedDragPoint(point_in_screen);
 
   // Calculate the bounds for the tabs from the attached_tab_strip. We do this
   // so that the tabs don't change size when detached.
   std::vector<gfx::Rect> drag_bounds =
       CalculateBoundsForDraggedTabs(attached_point.x());
 
+  gfx::Point drag_offset;
   Browser* browser = CreateBrowserForDrag(
-      attached_tabstrip_, point_in_screen, &drag_bounds);
+      attached_tabstrip_, point_in_screen, &drag_offset, &drag_bounds);
   Detach(DONT_RELEASE_CAPTURE);
   BrowserView* dragged_browser_view =
       BrowserView::GetBrowserViewForBrowser(browser);
   dragged_browser_view->GetWidget()->SetVisibilityChangedAnimationsEnabled(
       false);
   Attach(dragged_browser_view->tabstrip(), gfx::Point());
   // TODO: come up with a cleaner way to do this.
   attached_tabstrip_->SetTabBoundsForDrag(drag_bounds);
 
   browser->window()->Show();
   browser->window()->Activate();
   dragged_browser_view->GetWidget()->SetVisibilityChangedAnimationsEnabled(
       true);
-  RunMoveLoop();
+  RunMoveLoop(drag_offset);
 }
 
-void TabDragController::RunMoveLoop() {
+void TabDragController::RunMoveLoop(const gfx::Point& drag_offset) {
   // If the user drags the whole window we'll assume they are going to attach to
   // another window and therefor want to reorder.
   move_behavior_ = REORDER;
 
   move_loop_widget_ = GetAttachedBrowserWidget();
   DCHECK(move_loop_widget_);
   move_loop_widget_->AddObserver(this);
   is_dragging_window_ = true;
   bool destroyed = false;
   destroyed_ = &destroyed;
 #if !defined(USE_ASH)
   // Running the move loop releases mouse capture on Windows, which triggers
   // destroying the drag loop. Release mouse capture ourself before this while
   // the DragController isn't owned by the TabStrip.
   attached_tabstrip_->ReleaseDragController();
   attached_tabstrip_->GetWidget()->ReleaseCapture();
   attached_tabstrip_->OwnDragController(this);
 #endif
-  views::Widget::MoveLoopResult result = move_loop_widget_->RunMoveLoop();
+  views::Widget::MoveLoopResult result =
+      move_loop_widget_->RunMoveLoop(drag_offset);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TAB_DRAG_LOOP_DONE,
       content::NotificationService::AllBrowserContextsAndSources(),
       content::NotificationService::NoDetails());
 
   if (destroyed)
     return;
   destroyed_ = NULL;
   // Under chromeos we immediately set the |move_loop_widget_| to NULL.
   if (move_loop_widget_) {
@@ skipping 577 matching lines @@
         drag_data_[i].source_model_index) {
       return false;
     }
   }
   return true;
 }
 
 Browser* TabDragController::CreateBrowserForDrag(
     TabStrip* source,
     const gfx::Point& point_in_screen,
+    gfx::Point* drag_offset,
     std::vector<gfx::Rect>* drag_bounds) {
   Browser* browser = new Browser(
       Browser::CreateParams(drag_data_[0].contents->profile()));
   gfx::Point center(0, source->height() / 2);
   views::View::ConvertPointToWidget(source, &center);
   gfx::Rect new_bounds(source->GetWidget()->GetWindowBoundsInScreen());
   new_bounds.set_y(point_in_screen.y() - center.y());
   switch (GetDetachPosition(point_in_screen)) {
     case DETACH_BEFORE:
       new_bounds.set_x(point_in_screen.x() - center.x());
       new_bounds.Offset(-mouse_offset_.x(), 0);
       break;
 
     case DETACH_AFTER: {
       gfx::Point right_edge(source->width(), 0);
       views::View::ConvertPointToWidget(source, &right_edge);
       new_bounds.set_x(point_in_screen.x() - right_edge.x());
       new_bounds.Offset(drag_bounds->back().right() - mouse_offset_.x(), 0);
       int delta = (*drag_bounds)[0].x();
       for (size_t i = 0; i < drag_bounds->size(); ++i)
         (*drag_bounds)[i].Offset(-delta, 0);
       break;
     }
 
     default:
       break; // Nothing to do for DETACH_ABOVE_OR_BELOW.
   }
 
+  *drag_offset = point_in_screen.Subtract(new_bounds.origin());
+
   SetTrackedByWorkspace(browser->window()->GetNativeWindow(), false);
   browser->window()->SetBounds(new_bounds);
   return browser;
 }
 
 gfx::Point TabDragController::GetCursorScreenPoint() {
 #if defined(USE_ASH)
   views::Widget* widget = GetAttachedBrowserWidget();
   DCHECK(widget);
   if (aura::Env::GetInstance()->is_touch_down()) {
     aura::Window* widget_window = widget->GetNativeWindow();
     DCHECK(widget_window->GetRootWindow());
     gfx::Point touch_point;
     bool got_touch_point = widget_window->GetRootWindow()->
         gesture_recognizer()->GetLastTouchPointForTarget(widget_window,
                                                          &touch_point);
     DCHECK(got_touch_point);
     return touch_point;
   }
 #endif
   return gfx::Screen::GetCursorScreenPoint();
 }
+
+gfx::Point TabDragController::GetWindowOffset(
+    const gfx::Point& point_in_screen) {
+  TabStrip* owning_tabstrip = (attached_tabstrip_ && detach_into_browser_) ?
+      attached_tabstrip_ : source_tabstrip_;
+  views::View* toplevel_view = owning_tabstrip->GetWidget()->GetContentsView();
+
+  gfx::Point offset = point_in_screen;
+  views::View::ConvertPointFromScreen(toplevel_view, &offset);
+  return offset;
+}