Revert 164652 - speculative revert - this change may have caused print dialog test failures on XP.

Re-vamped the entire window auto positioning logic

As long as the user did not move / resize the window:

A single visible window (browser / app) on the screen will always be centered.
When a second visible (browser / app) window joins in, both will be pushed into opposite corners.
When more windows get piled up, they go every time into the opposite side of the currently active window.

When the user has resized / moved a window, it will be treated as a visible (browser / app) window, but it will not get moved - the others will however.


Addressing bug: Moving last remaining tabbed window back into screen center


BUG=153431, 150879, 153302
TEST=unit-tests & visual

Committed: http://src.chromium.org/viewvc/chrome?view=rev&revision=164352

Review URL: https://chromiumcodereview.appspot.com/11085053

TBR=skuhne@chromium.org
Review URL: https://codereview.chromium.org/11343028

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@164772 0039d316-1c4b-4281-b951-d872f2087c98

15 files changed, 23 insertions, 566 deletions

diff --git a/ash/ash.gyp b/ash/ash.gyp
index 9a16531..e4c8c2a 100644
--- a/ash/ash.gyp
+++ b/ash/ash.gyp
@@ -385,8 +385,6 @@
         'wm/window_util.h',
         'wm/workspace_controller.cc',
         'wm/workspace_controller.h',
-        'wm/workspace/auto_window_management.cc',
-        'wm/workspace/auto_window_management.h',
         'wm/workspace/colored_window_controller.cc',
         'wm/workspace/colored_window_controller.h',
         'wm/workspace/desktop_background_fade_controller.cc',
diff --git a/ash/ash_switches.cc b/ash/ash_switches.cc
index 6094cf0..836d5f7 100644
--- a/ash/ash_switches.cc
+++ b/ash/ash_switches.cc
@@ -25,10 +25,6 @@ const char kAshCopyHostBackgroundAtBoot[] = "ash-copy-host-background-at-boot";
 // Enable keyboard shortcuts useful for debugging.
 const char kAshDebugShortcuts[] = "ash-debug-shortcuts";
 
-// Disable support for auto window placement.
-const char kAshDisableAutoWindowPlacement[] =
-    "ash-enable-auto-window-placement";
-
 // Disables boot animation v2, go back to v1.
 const char kAshDisableBootAnimation2[] = "ash-disable-boot-animation2";
 
diff --git a/ash/ash_switches.h b/ash/ash_switches.h
index 5ed521f..b3e1e24 100644
--- a/ash/ash_switches.h
+++ b/ash/ash_switches.h
@@ -20,7 +20,6 @@ ASH_EXPORT extern const char kAshBootAnimationFunction3[];
 ASH_EXPORT extern const char kAshConstrainPointerToRoot[];
 ASH_EXPORT extern const char kAshCopyHostBackgroundAtBoot[];
 ASH_EXPORT extern const char kAshDebugShortcuts[];
-ASH_EXPORT extern const char kAshDisableAutoWindowPlacement[];
 ASH_EXPORT extern const char kAshDisablePanelFitting[];
 ASH_EXPORT extern const char kAshDisableBootAnimation2[];
 ASH_EXPORT extern const char kAshEnableAdvancedGestures[];
diff --git a/ash/wm/property_util.cc b/ash/wm/property_util.cc
index 6352797..d52b196 100644
--- a/ash/wm/property_util.cc
+++ b/ash/wm/property_util.cc
@@ -48,7 +48,7 @@ void SetTrackedByWorkspace(aura::Window* window, bool value) {
   window->SetProperty(internal::kWindowTrackedByWorkspaceKey, value);
 }
 
-bool GetTrackedByWorkspace(const aura::Window* window) {
+bool GetTrackedByWorkspace(aura::Window* window) {
   return window->GetProperty(internal::kWindowTrackedByWorkspaceKey);
 }
 
@@ -56,7 +56,7 @@ void SetIgnoredByShelf(aura::Window* window, bool value) {
   window->SetProperty(internal::kIgnoredByShelfKey, value);
 }
 
-bool GetIgnoredByShelf(const aura::Window* window) {
+bool GetIgnoredByShelf(aura::Window* window) {
   return window->GetProperty(internal::kIgnoredByShelfKey);
 }
 
diff --git a/ash/wm/property_util.h b/ash/wm/property_util.h
index 48f6e53..dde0335 100644
--- a/ash/wm/property_util.h
+++ b/ash/wm/property_util.h
@@ -50,14 +50,14 @@ enum WindowPersistsAcrossAllWorkspacesType {
 // Sets whether |window| is ignored when determining whether the shelf should
 // be darkened when overlapped.
 ASH_EXPORT void SetIgnoredByShelf(aura::Window* window, bool value);
-ASH_EXPORT bool GetIgnoredByShelf(const aura::Window* window);
+ASH_EXPORT bool GetIgnoredByShelf(aura::Window* window);
 
 // Sets whether the specified window is tracked by workspace code. Default is
 // true. If set to false the workspace does not switch the current workspace,
 // nor does it attempt to impose constraints on the bounds of the window. This
 // is intended for tab dragging.
 ASH_EXPORT void SetTrackedByWorkspace(aura::Window* window, bool value);
-ASH_EXPORT bool GetTrackedByWorkspace(const aura::Window* window);
+ASH_EXPORT bool GetTrackedByWorkspace(aura::Window* window);
 
 // Makes |window| persist across all workspaces. The default is controlled
 // by SetDefaultPersistsAcrossAllWorkspaces().
diff --git a/ash/wm/window_properties.cc b/ash/wm/window_properties.cc
index 560d14f..6aad28a 100644
--- a/ash/wm/window_properties.cc
+++ b/ash/wm/window_properties.cc
@@ -40,11 +40,9 @@ DEFINE_OWNED_WINDOW_PROPERTY_KEY(ui_controls::UIControlsAura,
                                  kUIControlsKey,
                                  NULL);
 DEFINE_WINDOW_PROPERTY_KEY(bool, kUsesScreenCoordinatesKey, false);
-DEFINE_WINDOW_PROPERTY_KEY(bool, kUserChangedWindowPositionOrSizeKey, false);
 DEFINE_WINDOW_PROPERTY_KEY(ash::WindowPersistsAcrossAllWorkspacesType,
                            kWindowPersistsAcrossAllWorkspacesKey,
                            WINDOW_PERSISTS_ACROSS_ALL_WORKSPACES_VALUE_DEFAULT);
-DEFINE_WINDOW_PROPERTY_KEY(bool, kWindowPositionManagedKey, false);
 DEFINE_WINDOW_PROPERTY_KEY(bool, kWindowTrackedByWorkspaceKey, true);
 
 }  // namespace internal
diff --git a/ash/wm/window_properties.h b/ash/wm/window_properties.h
index ae5a9c9..8677359 100644
--- a/ash/wm/window_properties.h
+++ b/ash/wm/window_properties.h
@@ -67,22 +67,12 @@ ASH_EXPORT extern const aura::WindowProperty<bool>* const
 extern const aura::WindowProperty<ui_controls::UIControlsAura*>* const
     kUIControlsKey;
 
-// A property key to remember if a windows position or size was changed by a
-// user.
-ASH_EXPORT extern const aura::WindowProperty<bool>* const
-    kUserChangedWindowPositionOrSizeKey;
-
 // Property to tell if the container uses the screen coordinates.
 extern const aura::WindowProperty<bool>* const kUsesScreenCoordinatesKey;
 
 extern const aura::WindowProperty<WindowPersistsAcrossAllWorkspacesType>* const
     kWindowPersistsAcrossAllWorkspacesKey;
 
-// A property key to remember if a windows position can be managed by the
-// workspace manager or not.
-ASH_EXPORT extern const aura::WindowProperty<bool>* const
-    kWindowPositionManagedKey;
-
 // True if the window is controlled by the workspace manager.
 extern const aura::WindowProperty<bool>* const
     kWindowTrackedByWorkspaceKey;
diff --git a/ash/wm/window_util.cc b/ash/wm/window_util.cc
index 97e2761..b3a9b5d 100644
--- a/ash/wm/window_util.cc
+++ b/ash/wm/window_util.cc
@@ -6,7 +6,6 @@
 
 #include <vector>
 
-#include "ash/ash_constants.h"
 #include "ash/shell.h"
 #include "ash/wm/activation_controller.h"
 #include "ash/wm/window_properties.h"
@@ -74,11 +73,11 @@ bool CanActivateWindow(aura::Window* window) {
   return client && client->CanActivateWindow(window);
 }
 
-bool CanMaximizeWindow(const aura::Window* window) {
+bool CanMaximizeWindow(aura::Window* window) {
   return window->GetProperty(aura::client::kCanMaximizeKey);
 }
 
-bool IsWindowNormal(const aura::Window* window) {
+bool IsWindowNormal(aura::Window* window) {
   return IsWindowStateNormal(window->GetProperty(aura::client::kShowStateKey));
 }
 
@@ -86,17 +85,17 @@ bool IsWindowStateNormal(ui::WindowShowState state) {
   return state == ui::SHOW_STATE_NORMAL || state == ui::SHOW_STATE_DEFAULT;
 }
 
-bool IsWindowMaximized(const aura::Window* window) {
+bool IsWindowMaximized(aura::Window* window) {
   return window->GetProperty(aura::client::kShowStateKey) ==
       ui::SHOW_STATE_MAXIMIZED;
 }
 
-bool IsWindowMinimized(const aura::Window* window) {
+bool IsWindowMinimized(aura::Window* window) {
   return window->GetProperty(aura::client::kShowStateKey) ==
       ui::SHOW_STATE_MINIMIZED;
 }
 
-bool IsWindowFullscreen(const aura::Window* window) {
+bool IsWindowFullscreen(aura::Window* window) {
   return window->GetProperty(aura::client::kShowStateKey) ==
       ui::SHOW_STATE_FULLSCREEN;
 }
@@ -154,23 +153,5 @@ void DeepDeleteLayers(ui::Layer* layer) {
   delete layer;
 }
 
-bool IsWindowPositionManaged(const aura::Window* window) {
-  return window->GetProperty(ash::internal::kWindowPositionManagedKey);
-}
-
-void SetWindowPositionManaged(aura::Window* window, bool managed) {
-  window->SetProperty(ash::internal::kWindowPositionManagedKey, managed);
-}
-
-bool HasUserChangedWindowPositionOrSize(const aura::Window* window) {
-  return window->GetProperty(
-      ash::internal::kUserChangedWindowPositionOrSizeKey);
-}
-
-void SetUserHasChangedWindowPositionOrSize(aura::Window* window, bool changed) {
-  window->SetProperty(ash::internal::kUserChangedWindowPositionOrSizeKey,
-                      changed);
-}
-
 }  // namespace wm
 }  // namespace ash
diff --git a/ash/wm/window_util.h b/ash/wm/window_util.h
index 7a9e3f0..081a40e 100644
--- a/ash/wm/window_util.h
+++ b/ash/wm/window_util.h
@@ -39,22 +39,22 @@ ASH_EXPORT aura::Window* GetActivatableWindow(aura::Window* window);
 ASH_EXPORT bool IsActiveWindowFullscreen();
 
 // Returns true if |window| can be maximized.
-ASH_EXPORT bool CanMaximizeWindow(const aura::Window* window);
+ASH_EXPORT bool CanMaximizeWindow(aura::Window* window);
 
 // Returns true if |window| is normal or default.
-ASH_EXPORT bool IsWindowNormal(const aura::Window* window);
+ASH_EXPORT bool IsWindowNormal(aura::Window* window);
 
 // Returns true if |state| is normal or default.
-ASH_EXPORT bool IsWindowStateNormal(const ui::WindowShowState state);
+ASH_EXPORT bool IsWindowStateNormal(ui::WindowShowState state);
 
 // Returns true if |window| is in the maximized state.
-ASH_EXPORT bool IsWindowMaximized(const aura::Window* window);
+ASH_EXPORT bool IsWindowMaximized(aura::Window* window);
 
 // Returns true if |window| is minimized.
-ASH_EXPORT bool IsWindowMinimized(const aura::Window* window);
+ASH_EXPORT bool IsWindowMinimized(aura::Window* window);
 
 // Returns true if |window| is in the fullscreen state.
-ASH_EXPORT bool IsWindowFullscreen(const aura::Window* window);
+ASH_EXPORT bool IsWindowFullscreen(aura::Window* window);
 
 // Maximizes |window|, which must not be NULL.
 ASH_EXPORT void MaximizeWindow(aura::Window* window);
@@ -86,19 +86,6 @@ ASH_EXPORT ui::Layer* RecreateWindowLayers(aura::Window* window,
 // Deletes |layer| and all its child layers.
 ASH_EXPORT void DeepDeleteLayers(ui::Layer* layer);
 
-// Returns true if |window|'s position can automatically be managed.
-ASH_EXPORT bool IsWindowPositionManaged(const aura::Window* window);
-
-// Change the |window|'s position manageability to |managed|.
-ASH_EXPORT void SetWindowPositionManaged(aura::Window* window, bool managed);
-
-// Returns true if the user has changed the |window|'s position or size.
-ASH_EXPORT bool HasUserChangedWindowPositionOrSize(const aura::Window* window);
-
-// Marks a |window|'s coordinates to be changed by a user.
-ASH_EXPORT void SetUserHasChangedWindowPositionOrSize(aura::Window* window,
-                                                      bool changed);
-
 }  // namespace wm
 }  // namespace ash
 
diff --git a/ash/wm/workspace/auto_window_management.cc b/ash/wm/workspace/auto_window_management.cc
deleted file mode 100644
index ea2f89f..0000000
--- a/ash/wm/workspace/auto_window_management.cc
+++ /dev/null
@@ -1,178 +0,0 @@
-// 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 "ash/wm/workspace/auto_window_management.h"
-
-#include "ash/ash_switches.h"
-#include "ash/shell.h"
-#include "ash/wm/property_util.h"
-#include "ash/wm/window_animations.h"
-#include "ash/wm/window_util.h"
-#include "base/command_line.h"
-#include "ui/aura/window.h"
-#include "ui/aura/client/aura_constants.h"
-#include "ui/compositor/layer_animator.h"
-#include "ui/compositor/scoped_layer_animation_settings.h"
-#include "ui/gfx/screen.h"
-
-namespace ash {
-namespace internal {
-
-namespace {
-
-// The time in milliseconds which should be used to visually move a window
-// through an automatic "intelligent" window management option.
-const int kWindowAutoMoveDurationMS = 125;
-
-// Check if any management should be performed (with a given |window|).
-bool UseAutoWindowMagerForWindow(const aura::Window* window) {
-  return !CommandLine::ForCurrentProcess()->HasSwitch(
-             switches::kAshDisableAutoWindowPlacement) &&
-         GetTrackedByWorkspace(window) &&
-         wm::IsWindowPositionManaged(window);
-}
-
-// Check if a given |window| can be managed. This includes that it's state is
-// not minimized/maximized/the user has changed it's size by hand already.
-// It furthermore checks for the WindowIsManaged status.
-bool WindowPositionCanBeManaged(const aura::Window* window) {
-  return (wm::IsWindowPositionManaged(window) &&
-          !wm::IsWindowMinimized(window) &&
-          !wm::IsWindowMaximized(window) &&
-          !wm::HasUserChangedWindowPositionOrSize(window));
-}
-
-// Given a |window|, return the only |other_window| which has an impact on
-// the automated windows location management. If there is more then one window,
-// false is returned, but the |other_window| will be set to the first one
-// found.
-// If the return value is true a single window was found.
-bool GetOtherVisibleAndManageableWindow(const aura::Window* window,
-                                        aura::Window** other_window) {
-  *other_window = NULL;
-  const aura::Window::Windows& windows = window->parent()->children();
-  // Find a single open managed window.
-  for (size_t i = 0; i < windows.size(); i++) {
-    aura::Window* iterated_window = windows[i];
-    if (window != iterated_window &&
-        iterated_window->type() == aura::client::WINDOW_TYPE_NORMAL &&
-        iterated_window->TargetVisibility() &&
-        wm::IsWindowPositionManaged(iterated_window)) {
-      // Bail if we find a second usable window.
-      if (*other_window)
-        return false;
-      *other_window = iterated_window;
-    }
-  }
-  return *other_window != NULL;
-}
-
-// Get the work area for a given |window|.
-gfx::Rect GetWorkAreaForWindow(const aura::Window* window) {
-  gfx::Rect work_area = gfx::Rect(window->parent()->bounds().size());
-  work_area.Inset(Shell::GetScreen()->GetDisplayMatching(
-      work_area).GetWorkAreaInsets());
-  return work_area;
-}
-
-// Move the given |bounds| on the available |parent_width| to the
-// direction. If |move_right| is true, the rectangle gets moved to the right
-// corner, otherwise to the left one.
-bool MoveRectToOneSide(int parent_width, bool move_right, gfx::Rect* bounds) {
-  if (move_right) {
-    if (parent_width > bounds->right()) {
-      bounds->set_x(parent_width - bounds->width());
-      return true;
-    }
-  } else {
-    if (0 < bounds->x()) {
-      bounds->set_x(0);
-      return true;
-    }
-  }
-  return false;
-}
-
-// Move a |window| to a new |bound|. Animate if desired by user.
-// Note: The function will do nothing if the bounds did not change.
-void SetBoundsAnimated(aura::Window* window, const gfx::Rect& bounds) {
-  if (bounds == window->GetTargetBounds())
-    return;
-
-  if (window->GetProperty(aura::client::kAnimationsDisabledKey) ||
-      CommandLine::ForCurrentProcess()->HasSwitch(
-          ash::switches::kAshWindowAnimationsDisabled)) {
-    window->SetBounds(bounds);
-    return;
-  }
-
-  ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
-  settings.SetTransitionDuration(
-      base::TimeDelta::FromMilliseconds(kWindowAutoMoveDurationMS));
-  window->SetBounds(bounds);
-}
-
-} // namespace
-
-void RearrangeVisibleWindowOnHideOrRemove(const aura::Window* removed_window) {
-  if (!UseAutoWindowMagerForWindow(removed_window))
-    return;
-  // Find a single open browser window.
-  aura::Window* other_shown_window = NULL;
-  if (!GetOtherVisibleAndManageableWindow(removed_window,
-                                          &other_shown_window) ||
-      !WindowPositionCanBeManaged(other_shown_window))
-    return;
-  // Center the window (only in x).
-  gfx::Rect work_area = GetWorkAreaForWindow(removed_window);
-  gfx::Rect bounds = other_shown_window->bounds();
-  bounds.set_x((work_area.width() - bounds.width()) / 2);
-  SetBoundsAnimated(other_shown_window, bounds);
-}
-
-void RearrangeVisibleWindowOnShow(aura::Window* added_window) {
-  if (!UseAutoWindowMagerForWindow(added_window) ||
-      wm::HasUserChangedWindowPositionOrSize(added_window) ||
-      !added_window->TargetVisibility())
-    return;
-  // Find a single open managed window.
-  aura::Window* other_shown_window = NULL;
-  if (!GetOtherVisibleAndManageableWindow(added_window,
-                                          &other_shown_window)) {
-    // It could be that this window is the first window joining the workspace.
-    if (!WindowPositionCanBeManaged(added_window) || other_shown_window)
-      return;
-
-    // If so we have to make sure it is centered.
-    gfx::Rect work_area = GetWorkAreaForWindow(added_window);
-    gfx::Rect bounds = added_window->bounds();
-    bounds.set_x((work_area.width() - bounds.width()) / 2);
-    added_window->SetBounds(bounds);
-    return;
-  }
-
-  // When going from one to two windows both windows loose their "positioned
-  // by user" flags.
-  ash::wm::SetUserHasChangedWindowPositionOrSize(added_window, false);
-  ash::wm::SetUserHasChangedWindowPositionOrSize(other_shown_window, false);
-
-  if (WindowPositionCanBeManaged(other_shown_window)) {
-    gfx::Rect work_area = GetWorkAreaForWindow(added_window);
-
-    // Push away the other window.
-    gfx::Rect other_bounds = other_shown_window->bounds();
-    bool move_right = other_bounds.CenterPoint().x() < work_area.width() / 2;
-    if (MoveRectToOneSide(work_area.width(), move_right, &other_bounds))
-      SetBoundsAnimated(other_shown_window, other_bounds);
-
-    // Push the new window also to the opposite location (if needed).
-    // Since it is just coming into view, we do not need to animate it.
-    gfx::Rect added_bounds = added_window->bounds();
-    if (MoveRectToOneSide(work_area.width(), !move_right, &added_bounds))
-      added_window->SetBounds(added_bounds);
-  }
-}
-
-} // namespace internal
-} // namespace ash
diff --git a/ash/wm/workspace/auto_window_management.h b/ash/wm/workspace/auto_window_management.h
deleted file mode 100644
index 138cb54..0000000
--- a/ash/wm/workspace/auto_window_management.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// 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 "ui/aura/window.h"
-
-namespace ash {
-namespace internal {
-
-// Check if after removal or hide of the given |removed_window| an automated
-// desktop location management can be performed and rearrange accordingly.
-void RearrangeVisibleWindowOnHideOrRemove(const aura::Window* removed_window);
-
-// Check if after insertion or showing of the given |added_window| an automated
-// desktop location management can be performed and rearrange accordingly.
-void RearrangeVisibleWindowOnShow(aura::Window* added_window);
-
-} // namespace internal
-} // namespace ash
-
diff --git a/ash/wm/workspace/workspace_layout_manager2_unittest.cc b/ash/wm/workspace/workspace_layout_manager2_unittest.cc
index 13496f0..b559a3c 100644
--- a/ash/wm/workspace/workspace_layout_manager2_unittest.cc
+++ b/ash/wm/workspace/workspace_layout_manager2_unittest.cc
@@ -13,7 +13,9 @@
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window.h"
+#include "ui/gfx/display.h"
 #include "ui/gfx/insets.h"
+#include "ui/gfx/screen.h"
 
 namespace ash {
 
@@ -145,14 +147,15 @@ TEST_F(WorkspaceLayoutManager2Test, SizeToWorkArea) {
       100, 101, work_area.width() + 1, work_area.height() + 2);
   scoped_ptr<aura::Window> window(CreateTestWindow(window_bounds));
   EXPECT_EQ(gfx::Rect(gfx::Point(100, 101), work_area).ToString(),
-      window->bounds().ToString());
+            window->bounds().ToString());
 
   // Directly setting the bounds triggers a slightly different code path. Verify
   // that too.
   window->SetBounds(window_bounds);
   EXPECT_EQ(gfx::Rect(gfx::Point(100, 101), work_area).ToString(),
-      window->bounds().ToString());
+            window->bounds().ToString());
 }
 
 }  // namespace
+
 }  // namespace ash
diff --git a/ash/wm/workspace/workspace_manager2.cc b/ash/wm/workspace/workspace_manager2.cc
index 4a46cb72..68250c3 100644
--- a/ash/wm/workspace/workspace_manager2.cc
+++ b/ash/wm/workspace/workspace_manager2.cc
@@ -17,7 +17,6 @@
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
-#include "ash/wm/workspace/auto_window_management.h"
 #include "ash/wm/workspace/desktop_background_fade_controller.h"
 #include "ash/wm/workspace/workspace_animations.h"
 #include "ash/wm/workspace/workspace_layout_manager2.h"
@@ -594,14 +593,10 @@ void WorkspaceManager2::OnWindowAddedToWorkspace(Workspace2* workspace,
   // to the workspace.
   if (workspace == active_workspace_)
     UpdateShelfVisibility();
-
-  RearrangeVisibleWindowOnShow(child);
 }
 
 void WorkspaceManager2::OnWillRemoveWindowFromWorkspace(Workspace2* workspace,
                                                         Window* child) {
-  if (child->TargetVisibility())
-    RearrangeVisibleWindowOnHideOrRemove(child);
   child->ClearProperty(kWorkspaceKey);
 }
 
@@ -614,16 +609,10 @@ void WorkspaceManager2::OnWindowRemovedFromWorkspace(Workspace2* workspace,
 void WorkspaceManager2::OnWorkspaceChildWindowVisibilityChanged(
     Workspace2* workspace,
     Window* child) {
-  if (workspace->ShouldMoveToPending()) {
+  if (workspace->ShouldMoveToPending())
     MoveWorkspaceToPendingOrDelete(workspace, NULL, SWITCH_VISIBILITY_CHANGED);
-  } else {
-    if (child->TargetVisibility())
-      RearrangeVisibleWindowOnShow(child);
-    else
-      RearrangeVisibleWindowOnHideOrRemove(child);
-    if (workspace == active_workspace_)
-      UpdateShelfVisibility();
-  }
+  else if (workspace == active_workspace_)
+    UpdateShelfVisibility();
 }
 
 void WorkspaceManager2::OnWorkspaceWindowChildBoundsChanged(
diff --git a/ash/wm/workspace/workspace_manager2_unittest.cc b/ash/wm/workspace/workspace_manager2_unittest.cc
index 29e9232..70a39e6 100644
--- a/ash/wm/workspace/workspace_manager2_unittest.cc
+++ b/ash/wm/workspace/workspace_manager2_unittest.cc
@@ -1107,290 +1107,5 @@ TEST_F(WorkspaceManager2Test, DeactivateDropsToDesktop) {
   ASSERT_EQ("1 M1 active=1", StateString());
 }
 
-// Test the basic auto placement of one and or two windows in a "simulated
-// session" of sequential window operations.
-TEST_F(WorkspaceManager2Test, BasicAutoPlacing) {
-  // Test 1: In case there is no manageable window, no window should shift.
-
-  scoped_ptr<aura::Window> window1(
-      aura::test::CreateTestWindowWithId(0, NULL));
-  window1->SetBounds(gfx::Rect(16, 32, 640, 320));
-  gfx::Rect desktop_area = window1->parent()->bounds();
-
-  scoped_ptr<aura::Window> window2(
-      aura::test::CreateTestWindowWithId(1, NULL));
-  // Trigger the auto window placement function by making it visible.
-  // Note that the bounds are getting changed while it is invisible.
-  window2->Hide();
-  window2->SetBounds(gfx::Rect(32, 48, 256, 512));
-  window2->Show();
-
-  // Check the initial position of the windows is unchanged.
-  EXPECT_EQ("16,32 640x320", window1->bounds().ToString());
-  EXPECT_EQ("32,48 256x512", window2->bounds().ToString());
-
-  // Remove the second window and make sure that the first window
-  // does NOT get centered.
-  window2.reset();
-  EXPECT_EQ("16,32 640x320", window1->bounds().ToString());
-
-  // Test 2: Set up two managed windows and check their auto positioning.
-  ash::wm::SetWindowPositionManaged(window1.get(), true);
-  scoped_ptr<aura::Window> window3(
-      aura::test::CreateTestWindowWithId(2, NULL));
-  ash::wm::SetWindowPositionManaged(window3.get(), true);
-  // To avoid any auto window manager changes due to SetBounds, the window
-  // gets first hidden and then shown again.
-  window3->Hide();
-  window3->SetBounds(gfx::Rect(32, 48, 256, 512));
-  window3->Show();
-  // |window1| should be flush right and |window3| flush left.
-  EXPECT_EQ("0,32 640x320", window1->bounds().ToString());
-  EXPECT_EQ(base::IntToString(
-                desktop_area.width() - window3->bounds().width()) +
-            ",48 256x512", window3->bounds().ToString());
-
-  // After removing |window3|, |window1| should be centered again.
-  window3.reset();
-  EXPECT_EQ(
-      base::IntToString(
-          (desktop_area.width() - window1->bounds().width()) / 2) +
-      ",32 640x320", window1->bounds().ToString());
-
-  // Test 3: Set up a manageable and a non manageable window and check
-  // positioning.
-  scoped_ptr<aura::Window> window4(
-      aura::test::CreateTestWindowWithId(3, NULL));
-  // To avoid any auto window manager changes due to SetBounds, the window
-  // gets first hidden and then shown again.
-  window1->Hide();
-  window1->SetBounds(gfx::Rect(16, 32, 640, 320));
-  window4->SetBounds(gfx::Rect(32, 48, 256, 512));
-  window1->Show();
-  // |window1| should be centered and |window4| untouched.
-  EXPECT_EQ(
-      base::IntToString(
-          (desktop_area.width() - window1->bounds().width()) / 2) +
-      ",32 640x320", window1->bounds().ToString());
-  EXPECT_EQ("32,48 256x512", window4->bounds().ToString());
-
-  // Test4: A single manageable window should get centered.
-  window4.reset();
-  ash::wm::SetUserHasChangedWindowPositionOrSize(window1.get(), false);
-  // Trigger the auto window placement function by showing (and hiding) it.
-  window1->Hide();
-  window1->Show();
-  // |window1| should be centered.
-  EXPECT_EQ(
-      base::IntToString(
-          (desktop_area.width() - window1->bounds().width()) / 2) +
-      ",32 640x320", window1->bounds().ToString());
-}
-
-// Test the proper usage of user window movement interaction.
-TEST_F(WorkspaceManager2Test, TestUserMovedWindowRepositioning) {
-  scoped_ptr<aura::Window> window1(
-      aura::test::CreateTestWindowWithId(0, NULL));
-  window1->SetBounds(gfx::Rect(16, 32, 640, 320));
-  gfx::Rect desktop_area = window1->parent()->bounds();
-  scoped_ptr<aura::Window> window2(
-      aura::test::CreateTestWindowWithId(1, NULL));
-  window2->SetBounds(gfx::Rect(32, 48, 256, 512));
-  window1->Hide();
-  window2->Hide();
-  ash::wm::SetWindowPositionManaged(window1.get(), true);
-  ash::wm::SetWindowPositionManaged(window2.get(), true);
-  EXPECT_FALSE(ash::wm::HasUserChangedWindowPositionOrSize(window1.get()));
-  EXPECT_FALSE(ash::wm::HasUserChangedWindowPositionOrSize(window2.get()));
-
-  // Check that the current location gets preserved if the user has
-  // positioned it previously.
-  ash::wm::SetUserHasChangedWindowPositionOrSize(window1.get(), true);
-  window1->Show();
-  EXPECT_EQ("16,32 640x320", window1->bounds().ToString());
-  // Flag should be still set.
-  EXPECT_TRUE(ash::wm::HasUserChangedWindowPositionOrSize(window1.get()));
-  EXPECT_FALSE(ash::wm::HasUserChangedWindowPositionOrSize(window2.get()));
-
-  // Turn on the second window and make sure that both windows are now
-  // positionable again (user movement cleared).
-  window2->Show();
-
-  // |window1| should be flush right and |window3| flush left.
-  EXPECT_EQ(base::IntToString(
-                desktop_area.width() - window1->bounds().width()) +
-            ",32 640x320", window1->bounds().ToString());
-  EXPECT_EQ("0,48 256x512", window2->bounds().ToString());
-  // FLag should now be reset.
-  EXPECT_FALSE(ash::wm::HasUserChangedWindowPositionOrSize(window1.get()));
-  EXPECT_FALSE(ash::wm::HasUserChangedWindowPositionOrSize(window1.get()));
-
-  // Going back to one shown window should keep the state.
-  ash::wm::SetUserHasChangedWindowPositionOrSize(window1.get(), true);
-  window2->Hide();
-  EXPECT_EQ(base::IntToString(
-                desktop_area.width() - window1->bounds().width()) +
-            ",32 640x320", window1->bounds().ToString());
-  EXPECT_TRUE(ash::wm::HasUserChangedWindowPositionOrSize(window1.get()));
-}
-
-// Test that a window from normal to minimize will repos the remaining.
-TEST_F(WorkspaceManager2Test, ToMinimizeRepositionsRemaining) {
-  scoped_ptr<aura::Window> window1(
-      aura::test::CreateTestWindowWithId(0, NULL));
-  ash::wm::SetWindowPositionManaged(window1.get(), true);
-  window1->SetBounds(gfx::Rect(16, 32, 640, 320));
-  gfx::Rect desktop_area = window1->parent()->bounds();
-
-  scoped_ptr<aura::Window> window2(
-      aura::test::CreateTestWindowWithId(1, NULL));
-  ash::wm::SetWindowPositionManaged(window2.get(), true);
-  window2->SetBounds(gfx::Rect(32, 48, 256, 512));
-
-  ash::wm::MinimizeWindow(window1.get());
-
-  // |window2| should be centered now.
-  EXPECT_TRUE(window2->IsVisible());
-  EXPECT_TRUE(ash::wm::IsWindowNormal(window2.get()));
-  EXPECT_EQ(base::IntToString(
-                (desktop_area.width() - window2->bounds().width()) / 2) +
-            ",48 256x512", window2->bounds().ToString());
-
-  ash::wm::RestoreWindow(window1.get());
-  // |window1| should be flush right and |window3| flush left.
-  EXPECT_EQ(base::IntToString(
-                desktop_area.width() - window1->bounds().width()) +
-            ",32 640x320", window1->bounds().ToString());
-  EXPECT_EQ("0,48 256x512", window2->bounds().ToString());
-}
-
-// Test that minimizing an initially maximized window will repos the remaining.
-TEST_F(WorkspaceManager2Test, MaxToMinRepositionsRemaining) {
-  scoped_ptr<aura::Window> window1(
-      aura::test::CreateTestWindowWithId(0, NULL));
-  ash::wm::SetWindowPositionManaged(window1.get(), true);
-  gfx::Rect desktop_area = window1->parent()->bounds();
-
-  scoped_ptr<aura::Window> window2(
-      aura::test::CreateTestWindowWithId(1, NULL));
-  ash::wm::SetWindowPositionManaged(window2.get(), true);
-  window2->SetBounds(gfx::Rect(32, 48, 256, 512));
-
-  ash::wm::MaximizeWindow(window1.get());
-  ash::wm::MinimizeWindow(window1.get());
-
-  // |window2| should be centered now.
-  EXPECT_TRUE(window2->IsVisible());
-  EXPECT_TRUE(ash::wm::IsWindowNormal(window2.get()));
-  EXPECT_EQ(base::IntToString(
-                (desktop_area.width() - window2->bounds().width()) / 2) +
-            ",48 256x512", window2->bounds().ToString());
-}
-
-// Test that nomral, maximize, minimizing will repos the remaining.
-TEST_F(WorkspaceManager2Test, NormToMaxToMinRepositionsRemaining) {
-  scoped_ptr<aura::Window> window1(
-      aura::test::CreateTestWindowWithId(0, NULL));
-  window1->SetBounds(gfx::Rect(16, 32, 640, 320));
-  ash::wm::SetWindowPositionManaged(window1.get(), true);
-  gfx::Rect desktop_area = window1->parent()->bounds();
-
-  scoped_ptr<aura::Window> window2(
-      aura::test::CreateTestWindowWithId(1, NULL));
-  ash::wm::SetWindowPositionManaged(window2.get(), true);
-  window2->SetBounds(gfx::Rect(32, 48, 256, 512));
-
-  // Trigger the auto window placement function by showing (and hiding) it.
-  window1->Hide();
-  window1->Show();
-
-  // |window1| should be flush right and |window3| flush left.
-  EXPECT_EQ(base::IntToString(
-                desktop_area.width() - window1->bounds().width()) +
-            ",32 640x320", window1->bounds().ToString());
-  EXPECT_EQ("0,48 256x512", window2->bounds().ToString());
-
-  ash::wm::MaximizeWindow(window1.get());
-  ash::wm::MinimizeWindow(window1.get());
-
-  // |window2| should be centered now.
-  EXPECT_TRUE(window2->IsVisible());
-  EXPECT_TRUE(ash::wm::IsWindowNormal(window2.get()));
-  EXPECT_EQ(base::IntToString(
-                (desktop_area.width() - window2->bounds().width()) / 2) +
-            ",48 256x512", window2->bounds().ToString());
-}
-
-// Test that nomral, maximize, normal will repos the remaining.
-TEST_F(WorkspaceManager2Test, NormToMaxToNormRepositionsRemaining) {
-  scoped_ptr<aura::Window> window1(
-      aura::test::CreateTestWindowWithId(0, NULL));
-  window1->SetBounds(gfx::Rect(16, 32, 640, 320));
-  ash::wm::SetWindowPositionManaged(window1.get(), true);
-  gfx::Rect desktop_area = window1->parent()->bounds();
-
-  scoped_ptr<aura::Window> window2(
-      aura::test::CreateTestWindowWithId(1, NULL));
-  ash::wm::SetWindowPositionManaged(window2.get(), true);
-  window2->SetBounds(gfx::Rect(32, 48, 256, 512));
-
-  // Trigger the auto window placement function by showing (and hiding) it.
-  window1->Hide();
-  window1->Show();
-
-  // |window1| should be flush right and |window3| flush left.
-  EXPECT_EQ(base::IntToString(
-                desktop_area.width() - window1->bounds().width()) +
-            ",32 640x320", window1->bounds().ToString());
-  EXPECT_EQ("0,48 256x512", window2->bounds().ToString());
-
-  ash::wm::MaximizeWindow(window1.get());
-  ash::wm::RestoreWindow(window1.get());
-
-  // |window1| should be flush right and |window2| flush left.
-  EXPECT_EQ(base::IntToString(
-                desktop_area.width() - window1->bounds().width()) +
-            ",32 640x320", window1->bounds().ToString());
-  EXPECT_EQ("0,48 256x512", window2->bounds().ToString());
-}
-
-// Test that animations are triggered.
-TEST_F(WorkspaceManager2Test, AnimatedNormToMaxToNormRepositionsRemaining) {
-  ui::LayerAnimator::set_disable_animations_for_test(false);
-  scoped_ptr<aura::Window> window1(
-      aura::test::CreateTestWindowWithId(0, NULL));
-  window1->Hide();
-  window1->SetBounds(gfx::Rect(16, 32, 640, 320));
-  gfx::Rect desktop_area = window1->parent()->bounds();
-  scoped_ptr<aura::Window> window2(
-      aura::test::CreateTestWindowWithId(1, NULL));
-  window2->Hide();
-  window2->SetBounds(gfx::Rect(32, 48, 256, 512));
-
-  ash::wm::SetWindowPositionManaged(window1.get(), true);
-  ash::wm::SetWindowPositionManaged(window2.get(), true);
-  // Make sure nothing is animating.
-  window1->layer()->GetAnimator()->StopAnimating();
-  window2->layer()->GetAnimator()->StopAnimating();
-  window2->Show();
-
-  // The second window should now animate.
-  EXPECT_FALSE(window1->layer()->GetAnimator()->is_animating());
-  EXPECT_TRUE(window2->layer()->GetAnimator()->is_animating());
-  window2->layer()->GetAnimator()->StopAnimating();
-
-  window1->Show();
-  EXPECT_TRUE(window1->layer()->GetAnimator()->is_animating());
-  EXPECT_TRUE(window2->layer()->GetAnimator()->is_animating());
-
-  window1->layer()->GetAnimator()->StopAnimating();
-  window2->layer()->GetAnimator()->StopAnimating();
-  // |window1| should be flush right and |window2| flush left.
-  EXPECT_EQ(base::IntToString(
-                desktop_area.width() - window1->bounds().width()) +
-            ",32 640x320", window1->bounds().ToString());
-  EXPECT_EQ("0,48 256x512", window2->bounds().ToString());
-}
-
 }  // namespace internal
 }  // namespace ash
diff --git a/ash/wm/workspace/workspace_window_resizer.cc b/ash/wm/workspace/workspace_window_resizer.cc
index 67145f5..75372cd 100644
--- a/ash/wm/workspace/workspace_window_resizer.cc
+++ b/ash/wm/workspace/workspace_window_resizer.cc
@@ -313,7 +313,6 @@ void WorkspaceWindowResizer::Drag(const gfx::Point& location_in_parent,
 }
 
 void WorkspaceWindowResizer::CompleteDrag(int event_flags) {
-  wm::SetUserHasChangedWindowPositionOrSize(details_.window, true);
   window()->layer()->SetOpacity(details_.initial_opacity);
   drag_phantom_window_controller_.reset();
   snap_phantom_window_controller_.reset();