Restores maximized browser before dragging a tab

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 192 matching lines @@
 #endif
 }
 
 void SetWindowPositionManaged(gfx::NativeWindow window, bool value) {
 #if defined(USE_ASH)
   ash::wm::GetWindowState(window)->set_window_position_managed(value);
 #endif
 }
 
 // Returns true if |tab_strip| browser window is docked.
-bool IsDocked(const TabStrip* tab_strip) {
+bool IsDockedOrSnapped(const TabStrip* tab_strip) {
 #if defined(USE_ASH)
   DCHECK(tab_strip);
-  return ash::wm::GetWindowState(
-      tab_strip->GetWidget()->GetNativeWindow())->IsDocked();
+  ash::wm::WindowState* window_state =
+      ash::wm::GetWindowState(tab_strip->GetWidget()->GetNativeWindow());
+  return window_state->IsDocked() ||
+      window_state->window_show_type() == ash::wm::SHOW_TYPE_LEFT_SNAPPED ||
+      window_state->window_show_type() == ash::wm::SHOW_TYPE_RIGHT_SNAPPED;
 #endif
   return false;
 }
 
 // Returns true if |bounds| contains the y-coordinate |y|. The y-coordinate
 // of |bounds| is adjusted by |vertical_adjustment|.
 bool DoesRectContainVerticalPointExpanded(
     const gfx::Rect& bounds,
     int vertical_adjustment,
     int y) {
@@ skipping 311 matching lines @@
     {
       base::WeakPtr<TabDragController> ref(weak_factory_.GetWeakPtr());
       SaveFocus();
       if (!ref)
         return;
     }
     started_drag_ = true;
     Attach(source_tabstrip_, gfx::Point());
     if (detach_into_browser_ && static_cast<int>(drag_data_.size()) ==
         GetModel(source_tabstrip_)->count()) {
+      if (was_source_maximized_ || was_source_fullscreen_) {
+        // 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();
+        std::vector<gfx::Rect> drag_bounds = CalculateBoundsForDraggedTabs();

[sky, 2013/11/21 23:29:29]

Does this do the right thing if you have lots of tab selected? Why not just
layout as they normally would in this case?

This code should also be ash and non-windows only as windows does the right
thing already.

[varkha, 2013/11/22 02:57:16]

Thanks for noticing this. I think I was missing a part that scales tabs and
shifts the browser window. I have extracted that part into a function and added
the call here.

Isn't the current behavior on Windows Ash / Metro that the maximized tab is
still dragged maximized? I wanted to size it so that a user could see where to
dock if necessary. Is this different from Chrome OS?

+        OffsetX(GetAttachedDragPoint(point_in_screen).x(), &drag_bounds);
+        gfx::Rect new_bounds(CalculateDraggedBrowserBounds(source_tabstrip_,
+                                                           point_in_screen,
+                                                           &drag_bounds));
+        new_bounds.Offset(-widget->GetRestoredBounds().x() +
+                          point_in_screen.x() -
+                          mouse_offset_.x(), 0);
+        widget->SetVisibilityChangedAnimationsEnabled(false);
+        widget->Restore();
+        widget->SetBounds(new_bounds);
+        widget->SetVisibilityChangedAnimationsEnabled(true);
+      }
       RunMoveLoop(GetWindowOffset(point_in_screen));
       return;
     }
   }
 
   ContinueDragging(point_in_screen);
 }
 
 void TabDragController::EndDrag(EndDragReason reason) {
   TRACE_EVENT0("views", "TabDragController::EndDrag");
@@ skipping 1368 matching lines @@
     GetModel(source_tabstrip_)->InsertWebContentsAt(
         data->source_model_index, data->contents,
         (data->pinned ? TabStripModel::ADD_PINNED : 0));
   }
 }
 
 void TabDragController::CompleteDrag() {
   DCHECK(started_drag_);
 
   if (attached_tabstrip_) {
-    if (is_dragging_new_browser_) {
-      if (IsDocked(attached_tabstrip_)) {
-        DCHECK_EQ(host_desktop_type_, chrome::HOST_DESKTOP_TYPE_ASH);
-        was_source_maximized_ = false;
-        was_source_fullscreen_ = false;
-      }
-      // If source window was maximized - maximize the new window as well.
-      if (was_source_maximized_)
-        attached_tabstrip_->GetWidget()->Maximize();
+    if (IsDockedOrSnapped(attached_tabstrip_)) {
+      DCHECK_EQ(host_desktop_type_, chrome::HOST_DESKTOP_TYPE_ASH);
+      was_source_maximized_ = false;
+      was_source_fullscreen_ = false;
+    }
+    // If source window was maximized - maximize the new window as well.
+    if (was_source_maximized_ || was_source_fullscreen_)
+      GetAttachedBrowserWidget()->Maximize();
 #if defined(USE_ASH)
-      if (was_source_fullscreen_ &&
-          host_desktop_type_ == chrome::HOST_DESKTOP_TYPE_ASH) {
-        // In fullscreen mode it is only possible to get here if the source
-        // was in "immersive fullscreen" mode, so toggle it back on.
-        ash::accelerators::ToggleFullscreen();
-      }
+    if (was_source_fullscreen_ &&
+        host_desktop_type_ == chrome::HOST_DESKTOP_TYPE_ASH) {
+      // In fullscreen mode it is only possible to get here if the source
+      // was in "immersive fullscreen" mode, so toggle it back on.
+      ash::accelerators::ToggleFullscreen();
+    }
 #endif
-    } else {
-      // When dragging results in maximized or fullscreen browser window getting
-      // docked, restore it.
-      if ((was_source_fullscreen_ || was_source_maximized_) &&
-          (IsDocked(attached_tabstrip_))) {
-        DCHECK_EQ(host_desktop_type_, chrome::HOST_DESKTOP_TYPE_ASH);
-        attached_tabstrip_->GetWidget()->Restore();
-      }
-    }
     attached_tabstrip_->StoppedDraggingTabs(
         GetTabsMatchingDraggedContents(attached_tabstrip_),
         initial_tab_positions_,
         move_behavior_ == MOVE_VISIBILE_TABS,
         true);
   } else {
     if (dock_info_.type() != DockInfo::NONE) {
       switch (dock_info_.type()) {
         case DockInfo::LEFT_OF_WINDOW:
           content::RecordAction(UserMetricsAction("DockingWindow_Left"));
@@ skipping 268 matching lines @@
 bool TabDragController::AreTabsConsecutive() {
   for (size_t i = 1; i < drag_data_.size(); ++i) {
     if (drag_data_[i - 1].source_model_index + 1 !=
         drag_data_[i].source_model_index) {
       return false;
     }
   }
   return true;
 }
 
-Browser* TabDragController::CreateBrowserForDrag(
+gfx::Rect TabDragController::CalculateDraggedBrowserBounds(
     TabStrip* source,
     const gfx::Point& point_in_screen,
-    gfx::Vector2d* drag_offset,
     std::vector<gfx::Rect>* drag_bounds) {
   gfx::Point center(0, source->height() / 2);
   views::View::ConvertPointToWidget(source, &center);
   gfx::Rect new_bounds(source->GetWidget()->GetRestoredBounds());
   if (source->GetWidget()->IsMaximized()) {
     // If the restore bounds is really small, we don't want to honor it
     // (dragging a really small window looks wrong), instead make sure the new
     // window is at least 50% the size of the old.
     const gfx::Size max_size(
         source->GetWidget()->GetWindowBoundsInScreen().size());
@@ skipping 18 matching lines @@
     }
     default:
       break; // Nothing to do for DETACH_ABOVE_OR_BELOW.
   }
 
   // To account for the extra vertical on restored windows that is absent on
   // maximized windows, add an additional vertical offset extracted from the tab
   // strip.
   if (source->GetWidget()->IsMaximized())
     new_bounds.Offset(0, -source->button_v_offset());
+  return new_bounds;
+}
 
+Browser* TabDragController::CreateBrowserForDrag(
+    TabStrip* source,
+    const gfx::Point& point_in_screen,
+    gfx::Vector2d* drag_offset,
+    std::vector<gfx::Rect>* drag_bounds) {
+  gfx::Rect new_bounds(CalculateDraggedBrowserBounds(source,
+                                                     point_in_screen,
+                                                     drag_bounds));
   *drag_offset = point_in_screen - new_bounds.origin();
 
   Profile* profile =
       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;
@@ skipping 29 matching lines @@
 gfx::Vector2d 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 point = point_in_screen;
   views::View::ConvertPointFromScreen(toplevel_view, &point);
   return point.OffsetFromOrigin();
 }