Defer maximize mode bounds updates until after exiting overview.

ash/wm/window_animations.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 "ash/wm/window_animations.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 49 matching lines @@
 
 // Scales for AshWindow above/below current workspace.
 const float kLayerScaleAboveSize = 1.1f;
 const float kLayerScaleBelowSize = .9f;
 
 int64 Round64(float f) {
   return static_cast<int64>(f + 0.5f);
 }
 
 base::TimeDelta GetCrossFadeDuration(aura::Window* window,
-                                     const gfx::Rect& old_bounds,
+                                     const gfx::RectF& old_bounds,
                                      const gfx::Rect& new_bounds) {
   if (::wm::WindowAnimationsDisabled(window))
     return base::TimeDelta();
 
-  int old_area = old_bounds.width() * old_bounds.height();
+  int old_area = static_cast<int>(old_bounds.width() * old_bounds.height());
   int new_area = new_bounds.width() * new_bounds.height();
   int max_area = std::max(old_area, new_area);
   // Avoid divide by zero.
   if (max_area == 0)
     return base::TimeDelta::FromMilliseconds(kCrossFadeDurationMS);
 
   int delta_area = std::abs(old_area - new_area);
   // If the area didn't change, the animation is instantaneous.
   if (delta_area == 0)
     return base::TimeDelta::FromMilliseconds(kCrossFadeDurationMS);
@@ skipping 234 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(CrossFadeObserver);
 };
 
 base::TimeDelta CrossFadeAnimation(
     aura::Window* window,
     scoped_ptr<ui::LayerTreeOwner> old_layer_owner,
     gfx::Tween::Type tween_type) {
   DCHECK(old_layer_owner->root());
   const gfx::Rect old_bounds(old_layer_owner->root()->bounds());
+  gfx::RectF old_transformed_bounds(old_bounds);
+  gfx::Transform old_transform(old_layer_owner->root()->transform());
+  gfx::Transform old_transform_in_root;
+  old_transform_in_root.Translate(old_bounds.x(), old_bounds.y());
+  old_transform_in_root.PreconcatTransform(old_transform);
+  old_transform_in_root.Translate(-old_bounds.x(), -old_bounds.y());
+  old_transform_in_root.TransformRect(&old_transformed_bounds);
   const gfx::Rect new_bounds(window->bounds());
   const bool old_on_top = (old_bounds.width() > new_bounds.width());
 
   // Shorten the animation if there's not much visual movement.
   const base::TimeDelta duration = GetCrossFadeDuration(window,
-                                                        old_bounds, new_bounds);
+      old_transformed_bounds, new_bounds);
 
   // Scale up the old layer while translating to new position.
   {
     ui::Layer* old_layer = old_layer_owner->root();
     old_layer->GetAnimator()->StopAnimating();
+    old_layer->SetTransform(old_transform);
     ui::ScopedLayerAnimationSettings settings(old_layer->GetAnimator());
 
     // Animation observer owns the old layer and deletes itself.
     settings.AddObserver(new CrossFadeObserver(window, old_layer_owner.Pass()));
     settings.SetTransitionDuration(duration);
     settings.SetTweenType(tween_type);
     gfx::Transform out_transform;
     float scale_x = static_cast<float>(new_bounds.width()) /
         static_cast<float>(old_bounds.width());
     float scale_y = static_cast<float>(new_bounds.height()) /
         static_cast<float>(old_bounds.height());
     out_transform.Translate(new_bounds.x() - old_bounds.x(),
                             new_bounds.y() - old_bounds.y());
     out_transform.Scale(scale_x, scale_y);
     old_layer->SetTransform(out_transform);
     if (old_on_top) {
       // The old layer is on top, and should fade out.  The new layer below will
       // stay opaque to block the desktop.
       old_layer->SetOpacity(kWindowAnimation_HideOpacity);
     }
     // In tests |old_layer| is deleted here, as animations have zero duration.
     old_layer = NULL;
   }
 
   // Set the new layer's current transform, such that the user sees a scaled
   // version of the window with the original bounds at the original position.
   gfx::Transform in_transform;
-  const float scale_x = static_cast<float>(old_bounds.width()) /
+  const float scale_x = old_transformed_bounds.width() /
       static_cast<float>(new_bounds.width());
-  const float scale_y = static_cast<float>(old_bounds.height()) /
+  const float scale_y = old_transformed_bounds.height() /
       static_cast<float>(new_bounds.height());
-  in_transform.Translate(old_bounds.x() - new_bounds.x(),
-                               old_bounds.y() - new_bounds.y());
+  in_transform.Translate(old_transformed_bounds.x() - new_bounds.x(),
+                         old_transformed_bounds.y() - new_bounds.y());
   in_transform.Scale(scale_x, scale_y);
   window->layer()->SetTransform(in_transform);
   if (!old_on_top) {
     // The new layer is on top and should fade in.  The old layer below will
     // stay opaque and block the desktop.
     window->layer()->SetOpacity(kWindowAnimation_HideOpacity);
   }
   {
     // Animate the new layer to the identity transform, so the window goes to
     // its newly set bounds.
@@ skipping 118 matching lines @@
     case SHELF_ALIGNMENT_LEFT:
       return gfx::Rect(work_area.x(), work_area.y(), 0, 0);
     case SHELF_ALIGNMENT_RIGHT:
       return gfx::Rect(work_area.right(), work_area.y(), 0, 0);
   }
   NOTREACHED();
   return gfx::Rect();
 }
 
 }  // namespace ash