Improving window auto management between workspaces

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 29 matching lines @@
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(USE_ASH)
 #include "ash/shell.h"
 #include "ash/wm/property_util.h"
+#include "ash/wm/window_util.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/gestures/gesture_recognizer.h"
 #endif
 
 using content::OpenURLParams;
 using content::UserMetricsAction;
 using content::WebContents;
 
 static const int kHorizontalMoveThreshold = 16;  // Pixels.
@@ skipping 124 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(DockView);
 };
 
 void SetTrackedByWorkspace(gfx::NativeWindow window, bool value) {
 #if defined(USE_ASH)
   ash::SetTrackedByWorkspace(window, value);
 #endif
 }
 
+void SetWindowPositionManaged(gfx::NativeWindow window, bool value) {
+#if defined(USE_ASH)
+  ash::wm::SetWindowPositionManaged(window, value);
+#endif
+}
+
 bool ShouldDetachIntoNewBrowser() {
 #if defined(USE_AURA)
   return true;
 #else
   return CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kTabBrowserDragging);
 #endif
 }
 
 // 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) {
   int upper_threshold = bounds.bottom() + vertical_adjustment;
   int lower_threshold = bounds.y() - vertical_adjustment;
   return y >= lower_threshold && y <= upper_threshold;
 }
 
+// WidgetObserver implementation that resets the window position managed
+// property on Show.
+// We're forced to do this here since BrowserFrameAura resets the 'window
+// position managed' property during a show and we need the property set to
+// false before WorkspaceLayoutManager2 sees the visibility change.
+class WindowPositionManagedUpdater : public views::WidgetObserver {
+ public:
+  virtual void OnWidgetVisibilityChanged(views::Widget* widget,
+                                         bool visible) OVERRIDE {
+    SetWindowPositionManaged(widget->GetNativeView(), false);
+  }
+};
+
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // DockDisplayer
 
 // DockDisplayer is responsible for giving the user a visual indication of a
 // possible dock position (as represented by DockInfo). DockDisplayer shows
 // a window with a DockView in it. Two animations are used that correspond to
 // the state of DockInfo::in_enable_area.
 class TabDragController::DockDisplayer : public ui::AnimationDelegate {
@@ skipping 142 matching lines @@
 TabDragController::~TabDragController() {
   if (instance_ == this)
     instance_ = NULL;
 
   if (destroyed_)
     *destroyed_ = true;
 
   if (move_loop_widget_) {
     move_loop_widget_->RemoveObserver(this);
     SetTrackedByWorkspace(move_loop_widget_->GetNativeView(), true);
+    SetWindowPositionManaged(move_loop_widget_->GetNativeView(), true);
   }
 
   if (source_tabstrip_ && detach_into_browser_)
     GetModel(source_tabstrip_)->RemoveObserver(this);
 
   MessageLoopForUI::current()->RemoveObserver(this);
 
   // Need to delete the view here manually _before_ we reset the dragged
   // contents to NULL, otherwise if the view is animating to its destination
   // bounds, it won't be able to clean up properly since its cleanup routine
@@ skipping 436 matching lines @@
     target_tabstrip->OwnDragController(this);
     // Disable animations so that we don't see a close animation on aero.
     browser_widget->SetVisibilityChangedAnimationsEnabled(false);
     // For aura we can't release capture, otherwise it'll cancel a gesture.
     // Instead we have to directly change capture.
 #if !defined(USE_ASH)
     browser_widget->ReleaseCapture();
 #else
     target_tabstrip->GetWidget()->SetCapture(attached_tabstrip_);
 #endif
+    // 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->GetNativeView(), false);
+
     // EndMoveLoop is going to snap the window back to its original location.
     // Hide it so users don't see this.
     browser_widget->Hide();
     browser_widget->EndMoveLoop();
 
     // Ideally we would always swap the tabs now, but on windows it seems that
     // running the move loop implicitly activates the window when done, leading
     // to all sorts of flicker. So, on windows, instead we process the move
     // after the loop completes. But on chromeos, we can do tab swapping now to
     // avoid the tab flashing issue(crbug.com/116329).
@@ skipping 450 matching lines @@
       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);
 
+  WindowPositionManagedUpdater updater;
+  dragged_browser_view->GetWidget()->AddObserver(&updater);
   browser->window()->Show();
+  dragged_browser_view->GetWidget()->RemoveObserver(&updater);
+
   browser->window()->Activate();
   dragged_browser_view->GetWidget()->SetVisibilityChangedAnimationsEnabled(
       true);
   RunMoveLoop(drag_offset);
 }
 
 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;
@@ skipping 236 matching lines @@
 
   bring_to_front_timer_.Stop();
   move_stacked_timer_.Stop();
 
   if (is_dragging_window_) {
     // SetTrackedByWorkspace() may call us back (by way of the window bounds
     // changing). Set |waiting_for_run_loop_to_exit_| here so that if that
     // happens we ignore it.
     waiting_for_run_loop_to_exit_ = true;
 
-    if (type == NORMAL || (type == TAB_DESTROYED && drag_data_.size() > 1))
+    if (type == NORMAL || (type == TAB_DESTROYED && drag_data_.size() > 1)) {
       SetTrackedByWorkspace(GetAttachedBrowserWidget()->GetNativeView(), true);
+      SetWindowPositionManaged(GetAttachedBrowserWidget()->GetNativeView(),
+                               true);
+    }
 
     // End the nested drag loop.
     GetAttachedBrowserWidget()->EndMoveLoop();
   }
 
   // Hide the current dock controllers.
   for (size_t i = 0; i < dock_controllers_.size(); ++i) {
     // Be sure and clear the controller first, that way if Hide ends up
     // deleting the controller it won't call us back.
     dock_controllers_[i]->clear_controller();
@@ skipping 392 matching lines @@
     default:
       break; // Nothing to do for DETACH_ABOVE_OR_BELOW.
   }
 
   *drag_offset = point_in_screen.Subtract(new_bounds.origin());
 
   Browser::CreateParams create_params(drag_data_[0].contents->profile());
   create_params.initial_bounds = new_bounds;
   Browser* browser = new Browser(create_params);
   SetTrackedByWorkspace(browser->window()->GetNativeWindow(), false);
+  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.
   browser->window()->SetBounds(new_bounds);
   return browser;
 }
 
 gfx::Point TabDragController::GetCursorScreenPoint() {
 #if defined(USE_ASH)
   views::Widget* widget = GetAttachedBrowserWidget();
   DCHECK(widget);
@@ skipping 14 matching lines @@
 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;
 }