ash: Improved window maximize/restore animations

ash/wm/base_layout_manager.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/base_layout_manager.h"
 
+#include "ash/ash_switches.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/wm/shelf_layout_manager.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
+#include "base/command_line.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/screen.h"
 
 namespace {
 
 // Given a |window| and tentative |restore_bounds|, returns new bounds that
@@ skipping 45 matching lines @@
 
 void BaseLayoutManager::OnWindowResized() {
 }
 
 void BaseLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
   windows_.insert(child);
   child->AddObserver(this);
   // Only update the bounds if the window has a show state that depends on the
   // workspace area.
   if (wm::IsWindowMaximized(child) || wm::IsWindowFullscreen(child))
-    UpdateBoundsFromShowState(child);
+    UpdateBoundsFromShowState(child, false);
 }
 
 void BaseLayoutManager::OnWillRemoveWindowFromLayout(aura::Window* child) {
   windows_.erase(child);
   child->RemoveObserver(this);
 }
 
 void BaseLayoutManager::OnWindowRemovedFromLayout(aura::Window* child) {
 }
 
 void BaseLayoutManager::OnChildWindowVisibilityChanged(aura::Window* child,
                                                        bool visible) {
   if (visible && wm::IsWindowMinimized(child)) {
     // Attempting to show a minimized window. Unminimize it.
     child->SetProperty(aura::client::kShowStateKey,
                        child->GetProperty(internal::kRestoreShowStateKey));
     child->ClearProperty(internal::kRestoreShowStateKey);
   }
 }
 
 void BaseLayoutManager::SetChildBounds(aura::Window* child,
                                        const gfx::Rect& requested_bounds) {
   gfx::Rect child_bounds(requested_bounds);
-  // Avoid a janky resize on startup by ensuring the initial bounds fill the
-  // screen.
+  // Some windows rely on this to set their initial bounds.
   if (wm::IsWindowMaximized(child))
     child_bounds = ScreenAsh::GetMaximizedWindowBounds(child);
   else if (wm::IsWindowFullscreen(child))
     child_bounds = gfx::Screen::GetMonitorNearestWindow(child).bounds();
   SetChildBoundsDirect(child, child_bounds);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BaseLayoutManager, RootWindowObserver overrides:
 
 void BaseLayoutManager::OnRootWindowResized(const aura::RootWindow* root,
                                             const gfx::Size& old_size) {
   AdjustWindowSizesForScreenChange();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BaseLayoutManager, ash::ShellObserver overrides:
 
 void BaseLayoutManager::OnMonitorWorkAreaInsetsChanged() {
   AdjustWindowSizesForScreenChange();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BaseLayoutManager, WindowObserver overrides:
 
 void BaseLayoutManager::OnWindowPropertyChanged(aura::Window* window,
                                                 const void* key,
                                                 intptr_t old) {
   if (key == aura::client::kShowStateKey) {
-    UpdateBoundsFromShowState(window);
+    UpdateBoundsFromShowState(window, true);
     ShowStateChanged(window, static_cast<ui::WindowShowState>(old));
   }
 }
 
 void BaseLayoutManager::OnWindowDestroying(aura::Window* window) {
   if (root_window_ == window) {
     root_window_->RemoveObserver(this);
     root_window_ = NULL;
   }
 }
@@ skipping 16 matching lines @@
       wm::DeactivateWindow(window);
   } else if ((window->TargetVisibility() ||
               last_show_state == ui::SHOW_STATE_MINIMIZED) &&
              !window->layer()->visible()) {
     // The layer may be hidden if the window was previously minimized. Make
     // sure it's visible.
     window->Show();
   }
 }
 
-void BaseLayoutManager::UpdateBoundsFromShowState(aura::Window* window) {
+void BaseLayoutManager::UpdateBoundsFromShowState(aura::Window* window,
+                                                  bool animate) {
   switch (window->GetProperty(aura::client::kShowStateKey)) {
     case ui::SHOW_STATE_DEFAULT:
     case ui::SHOW_STATE_NORMAL: {
       const gfx::Rect* restore = GetRestoreBounds(window);
       if (restore) {
-        SetChildBoundsDirect(window,
+        MaybeAnimateToBounds(window,
+                             animate,
                              BoundsWithScreenEdgeVisible(window, *restore));
       }
       window->ClearProperty(aura::client::kRestoreBoundsKey);
       break;
     }
 
     case ui::SHOW_STATE_MAXIMIZED:
       SetRestoreBoundsIfNotSet(window);
-      SetChildBoundsDirect(window, ScreenAsh::GetMaximizedWindowBounds(window));
+      MaybeAnimateToBounds(window,
+                           animate,
+                           ScreenAsh::GetMaximizedWindowBounds(window));
       break;
 
     case ui::SHOW_STATE_FULLSCREEN:
       SetRestoreBoundsIfNotSet(window);
+      // Don't animate the full-screen window transition.
+      // TODO(jamescook): Use animation here.  Be sure the lock screen works.
       SetChildBoundsDirect(
           window, gfx::Screen::GetMonitorNearestWindow(window).bounds());
       break;
 
     default:
       break;
   }
 }
 
+void BaseLayoutManager::MaybeAnimateToBounds(aura::Window* window,
+                                             bool animate,
+                                             const gfx::Rect& new_bounds) {
+  // Only animate visible windows.
+  if (animate &&
+      window->TargetVisibility() &&
+      !window->GetProperty(aura::client::kAnimationsDisabledKey) &&
+      !CommandLine::ForCurrentProcess()->HasSwitch(
+          ash::switches::kAshWindowAnimationsDisabled)) {
+    CrossFadeToBounds(window, new_bounds);
+    return;
+  }
+  SetChildBoundsDirect(window, new_bounds);
+}
+
 void BaseLayoutManager::AdjustWindowSizesForScreenChange() {
   // If a user plugs an external monitor into a laptop running Aura the
   // monitor size will change.  Maximized windows need to resize to match.
   // We also do this when developers running Aura on a desktop manually resize
   // the host window.
   // We also need to do this when the work area insets changes.
   for (WindowSet::const_iterator it = windows_.begin();
        it != windows_.end();
        ++it) {
     aura::Window* window = *it;
     if (wm::IsWindowMaximized(window)) {
       SetChildBoundsDirect(window, ScreenAsh::GetMaximizedWindowBounds(window));
     } else if (wm::IsWindowFullscreen(window)) {
       SetChildBoundsDirect(
           window, gfx::Screen::GetMonitorNearestWindow(window).bounds());
     } else {
       // The work area may be smaller than the full screen.
       gfx::Rect monitor_rect =
           gfx::Screen::GetMonitorNearestWindow(window).work_area();
       // Put as much of the window as possible within the monitor area.
       window->SetBounds(window->bounds().AdjustToFit(monitor_rect));
     }
   }
 }
 
 }  // namespace internal
 }  // namespace ash