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_fullscreen_ || was_source_maximized_) {
+        views::Widget* widget = GetAttachedBrowserWidget();
+        WindowPositionManagedUpdater updater;
+        widget->AddObserver(&updater);
+        widget->SetVisibilityChangedAnimationsEnabled(false);
+        widget->Hide();

[varkha, 2013/11/21 16:59:35]

I need to see if this breaks non-metro Windows.

+        std::vector<gfx::Rect> drag_bounds = CalculateBoundsForDraggedTabs();
+        gfx::Rect new_bounds(CalculateDraggedBrowserBounds(source_tabstrip_,
+                                                           point_in_screen,
+                                                           &drag_bounds));
+        widget->Restore();
+        widget->SetBounds(new_bounds);
+        widget->Show();
+        widget->RemoveObserver(&updater);
+        widget->SetVisibilityChangedAnimationsEnabled(true);
+
+        // Mouse handler was lost when the browser widget was hidden.
+        // Reestablish the event handler.
+        static_cast<views::internal::RootView*>(
+            widget->GetRootView())->SetMouseHandler(attached_tabstrip_);
+      }
       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());
     new_bounds.set_width(
         std::max(max_size.width() / 2, new_bounds.width()));
     new_bounds.set_height(
         std::max(max_size.height() / 2, new_bounds.width()));
   }
   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);
       OffsetX(-(*drag_bounds)[0].x(), drag_bounds);
       break;
     }
+    case DETACH_BEFORE:

[sky, 2013/11/21 16:43:07]

Why are you changing this?

[varkha, 2013/11/21 16:59:35]

It does not seem to break the existing case and makes correct x-offset for the
case when the widget is not born with empty origin as in my case when the
existing browser gets restored.

[sky, 2013/11/21 17:15:35]

I wanted dragging up/down to appear to tear a new window from the existing
window. Which means the position should remain the same.

[varkha, 2013/11/21 17:23:10]

That is what it seems to be doing (still in the old case as well as with the new
case).

[varkha, 2013/11/21 20:34:48]

I understand now - the case I broke was dragging tabs out of a non-maximized
browser (I guess I was too focused on maximized state to notice - my bad). I
reverted this part and correct for that offset elsewhere.

     default:
-      break; // Nothing to do for DETACH_ABOVE_OR_BELOW.
+      new_bounds.set_x(point_in_screen.x() - center.x());
+      new_bounds.Offset(-mouse_offset_.x(), 0);
+      break;
   }
 
   // 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();
 }