MacViews: Implement Tab Dragging

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/auto_reset.h"
@@ skipping 65 matching lines @@
 // Distance from the next/previous stacked before before we consider the tab
 // close enough to trigger moving.
 const int kStackedDistance = 36;
 
 // A dragged window is forced to be a bit smaller than maximized bounds during a
 // drag. This prevents the dragged browser widget from getting maximized at
 // creation and makes it easier to drag tabs out of a restored window that had
 // maximized size.
 const int kMaximizedWindowInset = 10;  // DIPs.
 
+// Whether a new browser window created during a drag is destroyed immediately
+// once it is associated with a new tab strip. If false, windows created during
+// the drag are destroyed only when the drag ends.
+#if 0 && defined(OS_MACOSX)
+const bool windows_destroy_during_drag = false;
+#else
+const bool windows_destroy_during_drag = true;
+#endif
+
 #if defined(USE_ASH)
 void SetWindowPositionManaged(gfx::NativeWindow window, bool value) {
   ash::wm::GetWindowState(window)->set_window_position_managed(value);
 }
 
 // Returns true if |tab_strip| browser window is docked.
 bool IsDockedOrSnapped(const TabStrip* tab_strip) {
   DCHECK(tab_strip);
   ash::wm::WindowState* window_state =
       ash::wm::GetWindowState(tab_strip->GetWidget()->GetNativeWindow());
@@ skipping 176 matching lines @@
   //     synchronous on desktop Linux, so use that.
   // - Ash
   //     Releasing capture on Ash cancels gestures so avoid it.
 #if defined(OS_LINUX)
   can_release_capture_ = false;
 #else
   can_release_capture_ =
       (host_desktop_type_ != chrome::HOST_DESKTOP_TYPE_ASH);
 #endif
   start_point_in_screen_ = gfx::Point(source_tab_offset, mouse_offset.y());
+  DLOG(INFO) << "TabDragController::Init/mouse offset -> point_in_window="
+      << mouse_offset.ToString() << " -> "
+      << start_point_in_screen_.ToString();
   views::View::ConvertPointToScreen(source_tab, &start_point_in_screen_);
+  DLOG(INFO) << " --> in screen=" << start_point_in_screen_.ToString();
+
   event_source_ = event_source;
   mouse_offset_ = mouse_offset;
   move_behavior_ = move_behavior;
   last_point_in_screen_ = start_point_in_screen_;
   last_move_screen_loc_ = start_point_in_screen_.x();
   initial_tab_positions_ = source_tabstrip->GetTabXCoordinates();
 
   GetModel(source_tabstrip_)->AddObserver(this);
 
   drag_data_.resize(tabs.size());
@@ skipping 51 matching lines @@
 void TabDragController::Drag(const gfx::Point& point_in_screen) {
   TRACE_EVENT1("views", "TabDragController::Drag",
                "point_in_screen", point_in_screen.ToString());
 
   bring_to_front_timer_.Stop();
   move_stacked_timer_.Stop();
 
   if (waiting_for_run_loop_to_exit_)
     return;
 
+  DLOG(INFO) << "Started_drag = " << started_drag_;
+
   if (!started_drag_) {
     if (!CanStartDrag(point_in_screen))
       return;  // User hasn't dragged far enough yet.
 
+    DLOG(INFO) << "STARTING!";
+
     // On windows SaveFocus() may trigger a capture lost, which destroys us.
     {
       base::WeakPtr<TabDragController> ref(weak_factory_.GetWeakPtr());
       SaveFocus();
       if (!ref)
         return;
     }
+    DLOG(INFO) << "Starting drag";
     started_drag_ = true;
     Attach(source_tabstrip_, gfx::Point());
     if (static_cast<int>(drag_data_.size()) ==
         GetModel(source_tabstrip_)->count()) {
       if (was_source_maximized_ || was_source_fullscreen_) {
         did_restore_window_ = true;
         // When all tabs in a maximized browser are dragged the browser gets
         // restored during the drag and maximized back when the drag ends.
         views::Widget* widget = GetAttachedBrowserWidget();
         const int last_tabstrip_width = attached_tabstrip_->tab_area_width();
@@ skipping 147 matching lines @@
     return;
   old_focused_view->GetFocusManager()->SetFocusedView(old_focused_view);
 }
 
 bool TabDragController::CanStartDrag(const gfx::Point& point_in_screen) const {
   // Determine if the mouse has moved beyond a minimum elasticity distance in
   // any direction from the starting point.
   static const int kMinimumDragDistance = 10;
   int x_offset = abs(point_in_screen.x() - start_point_in_screen_.x());
   int y_offset = abs(point_in_screen.y() - start_point_in_screen_.y());
-  return sqrt(pow(static_cast<float>(x_offset), 2) +
+  bool result = sqrt(pow(static_cast<float>(x_offset), 2) +
               pow(static_cast<float>(y_offset), 2)) > kMinimumDragDistance;
+  DLOG(INFO) << start_point_in_screen_.ToString() << " , " << point_in_screen.ToString();
+  DLOG(INFO) << "can start = " << result;
+  return result;
 }
 
 void TabDragController::ContinueDragging(const gfx::Point& point_in_screen) {
   TRACE_EVENT1("views", "TabDragController::ContinueDragging",
                "point_in_screen", point_in_screen.ToString());
+  DLOG(INFO) << "ContinueDragging... point_in_screen=" << point_in_screen.ToString();
 
   DCHECK(attached_tabstrip_);
 
   TabStrip* target_tabstrip = detach_behavior_ == DETACHABLE ?
       GetTargetTabStripForPoint(point_in_screen) : source_tabstrip_;
   bool tab_strip_changed = (target_tabstrip != attached_tabstrip_);
 
   if (attached_tabstrip_) {
     int move_delta = point_in_screen.x() - last_point_in_screen_.x();
     if (move_delta > 0)
@@ skipping 57 matching lines @@
     // observer so we don't get notified and process the event.
     if (host_desktop_type_ == chrome::HOST_DESKTOP_TYPE_ASH) {
       move_loop_widget_->RemoveObserver(this);
       move_loop_widget_ = NULL;
     }
     views::Widget* browser_widget = GetAttachedBrowserWidget();
     // Need to release the drag controller before starting the move loop as it's
     // going to trigger capture lost, which cancels drag.
     attached_tabstrip_->ReleaseDragController();
     target_tabstrip->OwnDragController(this);
+    if (!windows_destroy_during_drag) {
+      Detach(DONT_RELEASE_CAPTURE);
+      Attach(target_tabstrip, point_in_screen);
+      // Move the tabs into position.
+      // MoveAttached(point_in_screen);  // assumes !is_dragging_window_
+      return DRAG_BROWSER_RESULT_CONTINUE;
+    }
+
     // Disable animations so that we don't see a close animation on aero.
     browser_widget->SetVisibilityChangedAnimationsEnabled(false);
     if (can_release_capture_)
       browser_widget->ReleaseCapture();
     else
       target_tabstrip->GetWidget()->SetCapture(attached_tabstrip_);
 
     // The window is going away. Since the drag is still on going we don't want
     // that to effect the position of any windows.
     SetWindowPositionManaged(browser_widget->GetNativeWindow(), false);
@@ skipping 195 matching lines @@
     return DETACH_AFTER;
   return DETACH_ABOVE_OR_BELOW;
 }
 
 TabStrip* TabDragController::GetTargetTabStripForPoint(
     const gfx::Point& point_in_screen) {
   TRACE_EVENT1("views", "TabDragController::GetTargetTabStripForPoint",
                "point_in_screen", point_in_screen.ToString());
 
   if (move_only() && attached_tabstrip_) {
+    DLOG(INFO) << "MoveOnly";
     // move_only() is intended for touch, in which case we only want to detach
     // if the touch point moves significantly in the vertical distance.
     gfx::Rect tabstrip_bounds = GetViewScreenBounds(attached_tabstrip_);
     if (DoesRectContainVerticalPointExpanded(tabstrip_bounds,
                                              kTouchVerticalDetachMagnetism,
                                              point_in_screen.y()))
       return attached_tabstrip_;
   }
   gfx::NativeWindow local_window =
       GetLocalProcessWindow(point_in_screen, is_dragging_window_);
@@ skipping 47 matching lines @@
                "point_in_screen", point_in_screen.ToString());
 
   DCHECK(!attached_tabstrip_);  // We should already have detached by the time
                                 // we get here.
 
   attached_tabstrip_ = attached_tabstrip;
 
   std::vector<Tab*> tabs =
       GetTabsMatchingDraggedContents(attached_tabstrip_);
 
+  bool acquire_capture = true;
+
   if (tabs.empty()) {
     // Transitioning from detached to attached to a new tabstrip. Add tabs to
     // the new model.
 
     selection_model_before_attach_.Copy(attached_tabstrip->GetSelectionModel());
 
     // Inserting counts as a move. We don't want the tabs to jitter when the
     // user moves the tab immediately after attaching it.
     last_move_screen_loc_ = point_in_screen.x();
 
@@ skipping 19 matching lines @@
         DCHECK_EQ(1u, drag_data_.size());
         add_types |= TabStripModel::ADD_ACTIVE;
       }
       if (drag_data_[i].pinned)
         add_types |= TabStripModel::ADD_PINNED;
       GetModel(attached_tabstrip_)->InsertWebContentsAt(
           index + i, drag_data_[i].contents, add_types);
     }
 
     tabs = GetTabsMatchingDraggedContents(attached_tabstrip_);
+
+    // If the windows are kept, there's no need to re-acquire capture. Instead,
+    // the TabDragController remains in a MoveLoop.
+    acquire_capture = windows_destroy_during_drag;
   }
   DCHECK_EQ(tabs.size(), drag_data_.size());
   for (size_t i = 0; i < drag_data_.size(); ++i)
     drag_data_[i].attached_tab = tabs[i];
 
   attached_tabstrip_->StartedDraggingTabs(tabs);
 
   ResetSelection(GetModel(attached_tabstrip_));
 
   // The size of the dragged tab may have changed. Adjust the x offset so that
   // ratio of mouse_offset_ to original width is maintained.
   std::vector<Tab*> 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);
 
   // 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.
-  attached_tabstrip_->GetWidget()->SetCapture(attached_tabstrip_);
+  if (acquire_capture)
+    attached_tabstrip_->GetWidget()->SetCapture(attached_tabstrip_);
   attached_tabstrip_->OwnDragController(this);
 }
 
 void TabDragController::Detach(ReleaseCapture release_capture) {
   TRACE_EVENT1("views", "TabDragController::Detach",
                "release_capture", release_capture);
 
   attach_index_ = -1;
 
   // When the user detaches we assume they want to reorder.
@@ skipping 777 matching lines @@
       Profile::FromBrowserContext(drag_data_[0].contents->GetBrowserContext());
   Browser::CreateParams create_params(Browser::TYPE_TABBED,
                                       profile,
                                       host_desktop_type_);
   create_params.initial_bounds = new_bounds;
   Browser* browser = new Browser(create_params);
   is_dragging_new_browser_ = true;
   SetWindowPositionManaged(browser->window()->GetNativeWindow(), false);
   // If the window is created maximized then the bounds we supplied are ignored.
   // We need to reset them again so they are honored.
+  DLOG(INFO) << "SetBounds -> " << new_bounds.ToString();
   browser->window()->SetBounds(new_bounds);
 
   return browser;
 }
 
 gfx::Point TabDragController::GetCursorScreenPoint() {
 #if defined(USE_ASH)
   if (host_desktop_type_ == chrome::HOST_DESKTOP_TYPE_ASH &&
       event_source_ == EVENT_SOURCE_TOUCH &&
       aura::Env::GetInstance()->is_touch_down()) {
@@ skipping 48 matching lines @@
        it != browser_list->end(); ++it) {
     if ((*it)->tab_strip_model()->empty())
       exclude.insert((*it)->window()->GetNativeWindow());
   }
 #endif
   return GetLocalProcessWindowAtPoint(host_desktop_type_,
                                       screen_point,
                                       exclude);
 
 }