ash: Improved window maximize/restore animations

ash/wm/workspace/workspace_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/workspace/workspace_manager.h"
 
 #include <algorithm>
 
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
@@ skipping 12 matching lines @@
 #include "ui/aura/window.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/transform.h"
 
 namespace {
 
-// Returns a list of all the windows with layers in |result|.
+// Returns a list of all the windows with layers in |result|.  Optionally
+// ignores the window |ignore_window|.
 void BuildWindowList(const std::vector<aura::Window*>& windows,
+                     aura::Window* ignore_window,
                      std::vector<aura::Window*>* result) {
   for (size_t i = 0; i < windows.size(); ++i) {
+    if (windows[i] == ignore_window)
+      continue;
     if (windows[i]->layer())
       result->push_back(windows[i]);
-    BuildWindowList(windows[i]->transient_children(), result);
+    BuildWindowList(windows[i]->transient_children(), ignore_window, result);
   }
 }
 
 }
 
 namespace ash {
 namespace internal {
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManager, public:
 
 WorkspaceManager::WorkspaceManager(aura::Window* contents_view)
     : contents_view_(contents_view),
       active_workspace_(NULL),
-      ignored_window_(NULL),
+      maximize_restore_window_(NULL),
       grid_size_(0),
       shelf_(NULL) {
   DCHECK(contents_view);
 }
 
 WorkspaceManager::~WorkspaceManager() {
   std::vector<Workspace*> copy_to_delete(workspaces_);
   STLDeleteElements(&copy_to_delete);
 }
 
@@ skipping 140 matching lines @@
     else
       active_workspace_ = NULL;
   }
 }
 
 void WorkspaceManager::SetVisibilityOfWorkspaceWindows(
     ash::internal::Workspace* workspace,
     AnimateChangeType change_type,
     bool value) {
   std::vector<aura::Window*> children;
-  BuildWindowList(workspace->windows(), &children);
+  BuildWindowList(workspace->windows(), maximize_restore_window_, &children);
   SetWindowLayerVisibility(children, change_type, value);
 }
 
 void WorkspaceManager::SetWindowLayerVisibility(
     const std::vector<aura::Window*>& windows,
     AnimateChangeType change_type,
     bool value) {
   for (size_t i = 0; i < windows.size(); ++i) {
     ui::Layer* layer = windows[i]->layer();
     // Only show the layer for windows that want to be visible.
@@ skipping 56 matching lines @@
        i != workspaces_.end();
        ++i) {
     if ((*i)->Contains(window))
       return i - workspaces_.begin();
   }
   return -1;
 }
 
 void WorkspaceManager::SetWindowBounds(aura::Window* window,
                                        const gfx::Rect& bounds) {
-  ignored_window_ = window;
   window->SetBounds(bounds);
-  ignored_window_ = NULL;
 }
 
 void WorkspaceManager::OnTypeOfWorkspacedNeededChanged(aura::Window* window) {
   DCHECK(IsManagedWindow(window));
   Workspace* current_workspace = FindBy(window);
   DCHECK(current_workspace);
   Workspace* new_workspace = NULL;
   if (Workspace::TypeForWindow(window) == Workspace::TYPE_MAXIMIZED) {
     // Unmaximized -> maximized; create a new workspace.
     current_workspace->RemoveWindow(window);
     new_workspace = CreateWorkspace(Workspace::TYPE_MAXIMIZED);
     new_workspace->AddWindowAfter(window, NULL);
   } else {
     // Maximized -> unmaximized; move window to unmaximized workspace.
     new_workspace = GetManagedWorkspace();
     current_workspace->RemoveWindow(window);
     if (!new_workspace)
       new_workspace = CreateWorkspace(Workspace::TYPE_MANAGED);
     new_workspace->AddWindowAfter(window, NULL);
   }
+  maximize_restore_window_ = window;
   SetActiveWorkspace(new_workspace);
+  maximize_restore_window_ = NULL;
   // Delete at the end so that we don't attempt to switch to another
   // workspace in RemoveWorkspace().
   CleanupWorkspace(current_workspace);
 }
 
 Workspace* WorkspaceManager::GetManagedWorkspace() {
   for (size_t i = 0; i < workspaces_.size(); ++i) {
     if (workspaces_[i]->type() == Workspace::TYPE_MANAGED)
       return workspaces_[i];
   }
@@ skipping 10 matching lines @@
   return workspace;
 }
 
 void WorkspaceManager::CleanupWorkspace(Workspace* workspace) {
   if (workspace->type() != Workspace::TYPE_MANAGED && workspace->is_empty())
     delete workspace;
 }
 
 }  // namespace internal
 }  // namespace ash