Revert 245031 "This CL"

ash/wm/dock/docked_window_layout_manager.cc

 // Copyright (c) 2013 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/dock/docked_window_layout_manager.h"
 
 #include "ash/ash_switches.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_constants.h"
@@ skipping 504 matching lines @@
   if (is_dragged_window_docked_)
     OnDraggedWindowUndocked();
   DCHECK (!is_dragged_window_docked_);
   // Stop observing a window unless it is docked container's child in which
   // case it needs to keep being observed after the drag completes.
   if (dragged_window_->parent() != dock_container_) {
     dragged_window_->RemoveObserver(this);
     wm::GetWindowState(dragged_window_)->RemoveObserver(this);
     if (last_active_window_ == dragged_window_)
       last_active_window_ = NULL;
-
-    views::corewm::SetWindowShowAnimationDuration(dragged_window_,
-                                                  base::TimeDelta());
   } else {
     // If this is the first window that got docked by a move update alignment.
     if (alignment_ == DOCKED_ALIGNMENT_NONE)
       alignment_ = GetEdgeNearestWindow(dragged_window_);
     // A window is no longer dragged and is a child.
     // When a window becomes a child at drag start this is
     // the only opportunity we will have to enforce a window
     // count limit so do it here.
     MaybeMinimizeChildrenExcept(dragged_window_);
-
-    views::corewm::SetWindowShowAnimationDuration(dragged_window_,
-        base::TimeDelta::FromMilliseconds(kFadeDurationMs));
   }
   dragged_window_ = NULL;
   dragged_bounds_ = gfx::Rect();
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
   RecordUmaAction(action, source);
 }
 
 void DockedWindowLayoutManager::SetShelf(Shelf* shelf) {
   DCHECK(!shelf_);
@@ skipping 116 matching lines @@
   // A window can be added without proper bounds when window is moved to another
   // display via API or due to display configuration change, so the alignment
   // is set based on which edge is closer in the new display.
   if (alignment_ == DOCKED_ALIGNMENT_NONE)
     alignment_ = GetEdgeNearestWindow(child);
   MaybeMinimizeChildrenExcept(child);
   child->AddObserver(this);
   wm::GetWindowState(child)->AddObserver(this);
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
-  views::corewm::SetWindowShowAnimationDuration(child,
-      base::TimeDelta::FromMilliseconds(kFadeDurationMs));
 }
 
 void DockedWindowLayoutManager::OnWindowRemovedFromLayout(aura::Window* child) {
   if (IsPopupOrTransient(child))
     return;
   // Dragged windows are stopped being observed by FinishDragging and do not
   // change alignment during the drag. They also cannot be set to be the
   // |last_active_window_|.
   if (child == dragged_window_)
     return;
   // If this is the last window, set alignment and maximize the workspace.
   if (!IsAnyWindowDocked()) {
     alignment_ = DOCKED_ALIGNMENT_NONE;
     UpdateDockedWidth(0);
   }
   if (last_active_window_ == child)
     last_active_window_ = NULL;
   child->RemoveObserver(this);
   wm::GetWindowState(child)->RemoveObserver(this);
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
-  views::corewm::SetWindowShowAnimationDuration(child, base::TimeDelta());
 }
 
 void DockedWindowLayoutManager::OnChildWindowVisibilityChanged(
     aura::Window* child,
     bool visible) {
   if (IsPopupOrTransient(child))
     return;
   if (visible)
     wm::GetWindowState(child)->Restore();
   Relayout();
@@ skipping 118 matching lines @@
 
 void DockedWindowLayoutManager::OnWindowBoundsChanged(
     aura::Window* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
   // Only relayout if the dragged window would get docked.
   if (window == dragged_window_ && is_dragged_window_docked_)
     Relayout();
 }
 
+void DockedWindowLayoutManager::OnWindowVisibilityChanging(
+    aura::Window* window, bool visible) {
+  if (IsPopupOrTransient(window))
+    return;
+  int animation_type = views::corewm::WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT;
+  if (visible) {
+    animation_type = views::corewm::WINDOW_VISIBILITY_ANIMATION_TYPE_DROP;
+    views::corewm::SetWindowVisibilityAnimationDuration(
+        window, base::TimeDelta::FromMilliseconds(kFadeDurationMs));
+  } else if (wm::GetWindowState(window)->IsMinimized()) {
+    animation_type = WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE;
+  }
+  views::corewm::SetWindowVisibilityAnimationType(window, animation_type);
+}
+
 void DockedWindowLayoutManager::OnWindowDestroying(aura::Window* window) {
   if (dragged_window_ == window) {
     FinishDragging(DOCKED_ACTION_NONE, DOCKED_ACTION_SOURCE_UNKNOWN);
     DCHECK(!dragged_window_);
     DCHECK(!is_dragged_window_docked_);
   }
   if (window == last_active_window_)
     last_active_window_ = NULL;
   RecordUmaAction(DOCKED_ACTION_CLOSE, DOCKED_ACTION_SOURCE_UNKNOWN);
 }
@@ skipping 38 matching lines @@
   while (iter != children.rend()) {
     aura::Window* window(*iter++);
     if (window == child || !IsUsedByLayout(window))
       continue;
     int room_needed = GetWindowHeightCloseTo(window, 0) +
         (gap_needed ? kMinDockGap : 0);
     gap_needed = true;
     if (available_room > room_needed) {
       available_room -= room_needed;
     } else {
-      // Slow down the minimize animation.
-      views::corewm::SetWindowHideAnimationDuration(
-          window,
+      // Slow down minimizing animations. Lock duration so that it is not
+      // overridden by other ScopedLayerAnimationSettings down the stack.
+      ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
+      settings.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(kMinimizeDurationMs));
+      settings.LockTransitionDuration();
       wm::GetWindowState(window)->Minimize();
-      views::corewm::SetWindowHideAnimationDuration(window, base::TimeDelta());
     }
   }
 }
 
 void DockedWindowLayoutManager::MinimizeDockedWindow(
     wm::WindowState* window_state) {
-  aura::Window* window = window_state->window();
-  DCHECK(!IsPopupOrTransient(window));
-  views::corewm::SetWindowVisibilityAnimationType(window,
-      ash::WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE);
-  window->Hide();
-  views::corewm::SetWindowVisibilityAnimationType(window,
-      views::corewm::WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT);
+  DCHECK(!IsPopupOrTransient(window_state->window()));
+  window_state->window()->Hide();
   if (window_state->IsActive())
     window_state->Deactivate();
   RecordUmaAction(DOCKED_ACTION_MINIMIZE, DOCKED_ACTION_SOURCE_UNKNOWN);
 }
 
 void DockedWindowLayoutManager::RestoreDockedWindow(
     wm::WindowState* window_state) {
   aura::Window* window = window_state->window();
   DCHECK(!IsPopupOrTransient(window));
   // Always place restored window at the bottom shuffling the other windows up.
@@ skipping 382 matching lines @@
 void DockedWindowLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& keyboard_bounds) {
   // This bounds change will have caused a change to the Shelf which does not
   // propagate automatically to this class, so manually recalculate bounds.
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::KEYBOARD_BOUNDS_CHANGING);
 }
 
 }  // namespace internal
 }  // namespace ash