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 67 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 276 matching lines @@
                           point_in_screen.x() -
                           mouse_offset_.x(), 0);
         widget->SetVisibilityChangedAnimationsEnabled(false);
         widget->Restore();
         widget->SetBounds(new_bounds);
         AdjustBrowserAndTabBoundsForDrag(last_tabstrip_width,
                                          point_in_screen,
                                          &drag_bounds);
         widget->SetVisibilityChangedAnimationsEnabled(true);
       }
-      RunMoveLoop(GetWindowOffset(point_in_screen));
+      RunMoveLoop(GetWindowOffset(start_point_in_screen_));

[themblsha, 2016/03/03 17:56:51]

Without this fix the first mouse move after pressing the button won't actually
move the window, only the second mouse move will.

This fix has the side effect that now window moves will work even with NSEvents,
that's why I've added an intermediate step and carefully check for the resulting
window bounds.

       return;
     }
   }
 
   ContinueDragging(point_in_screen);
 }
 
 void TabDragController::EndDrag(EndDragReason reason) {
   TRACE_EVENT0("views", "TabDragController::EndDrag");
 
@@ skipping 121 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;
+  return result;
 }
 
 void TabDragController::ContinueDragging(const gfx::Point& point_in_screen) {
   TRACE_EVENT1("views", "TabDragController::ContinueDragging",
                "point_in_screen", point_in_screen.ToString());
 
   DCHECK(attached_tabstrip_);
 
   TabStrip* target_tabstrip = detach_behavior_ == DETACHABLE ?
       GetTargetTabStripForPoint(point_in_screen) : source_tabstrip_;
@@ skipping 62 matching lines @@
     // observer so we don't get notified and process the event.
 #if defined(USE_ASH)
     move_loop_widget_->RemoveObserver(this);
     move_loop_widget_ = nullptr;
 #endif  // USE_ASH
     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 262 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 832 matching lines @@
   // window which was used for dragging is not hidden once all of its tabs are
   // attached to another browser window in DragBrowserToNewTabStrip().
   // TODO(pkotwicz): Fix this properly (crbug.com/358482)
   for (auto* browser : *BrowserList::GetInstance()) {
     if (browser->tab_strip_model()->empty())
       exclude.insert(browser->window()->GetNativeWindow());
   }
 #endif
   return GetLocalProcessWindowAtPoint(screen_point, exclude);
 }