Compact layout mananger animates windows rather than the default container layer.

ash/wm/compact_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/compact_layout_manager.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_util.h"
+#include "base/memory/scoped_vector.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/compositor/layer_animation_sequence.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace internal {
 
 namespace {
 
 typedef std::vector<aura::Window*> WindowList;
 typedef std::vector<aura::Window*>::const_iterator WindowListConstIter;
 
 // Convenience method to get the layer of this container.
 ui::Layer* GetDefaultContainerLayer() {
   return Shell::GetInstance()->GetContainer(
       internal::kShellWindowId_DefaultContainer)->layer();
 }
 
 // Whether it is a window that should be animated on entrance.
 bool ShouldAnimateOnEntrance(aura::Window* window) {
   return window &&
       window->type() == aura::client::WINDOW_TYPE_NORMAL &&
       window_util::IsWindowMaximized(window);
 }
 
-// Adjust layer bounds to grow or shrink in |delta_width|.
-void AdjustContainerLayerWidth(int delta_width) {
-  gfx::Rect bounds(GetDefaultContainerLayer()->bounds());
-  bounds.set_width(bounds.width() + delta_width);
-  GetDefaultContainerLayer()->SetBounds(bounds);
-  GetDefaultContainerLayer()->GetCompositor()->WidgetSizeChanged(
-      GetDefaultContainerLayer()->bounds().size());
-}
 }  // namespace
 
 /////////////////////////////////////////////////////////////////////////////
 // CompactLayoutManager, public:
 
 CompactLayoutManager::CompactLayoutManager()
     : status_area_widget_(NULL),
       current_window_(NULL) {
 }
 
 CompactLayoutManager::~CompactLayoutManager() {
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // CompactLayoutManager, LayoutManager overrides:
 
 void CompactLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
   BaseLayoutManager::OnWindowAddedToLayout(child);
   UpdateStatusAreaVisibility();
-  if (windows().size() > 1 &&
-      child->type() == aura::client::WINDOW_TYPE_NORMAL) {
-    // The first window is already contained in the current layer,
-    // add subsequent windows to layer bounds calculation.
-    AdjustContainerLayerWidth(child->bounds().width());
-  }
 }
 
 void CompactLayoutManager::OnWillRemoveWindowFromLayout(aura::Window* child) {
   BaseLayoutManager::OnWillRemoveWindowFromLayout(child);
   UpdateStatusAreaVisibility();
-  if (windows().size() > 1 && ShouldAnimateOnEntrance(child))
-    AdjustContainerLayerWidth(-child->bounds().width());
-
   if (child == current_window_) {
     LayoutWindows(current_window_);
     SwitchToReplacementWindow();
   }
 }
 
 void CompactLayoutManager::OnChildWindowVisibilityChanged(aura::Window* child,
                                                           bool visible) {
   BaseLayoutManager::OnChildWindowVisibilityChanged(child, visible);
   UpdateStatusAreaVisibility();
@@ skipping 44 matching lines @@
     }
     // Always animate to |window| when there is a stacking change.
     AnimateSlideTo(window->bounds().x());
   }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // CompactLayoutManager, AnimationDelegate overrides:
 
 void CompactLayoutManager::OnImplicitAnimationsCompleted() {
-  if (!GetDefaultContainerLayer()->GetAnimator()->is_animating())
-    HideWindows();
+  HideWindows();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // CompactLayoutManager, private:
 
 void CompactLayoutManager::UpdateStatusAreaVisibility() {
   if (!status_area_widget_)
     return;
   // Full screen windows should hide the status area widget.
   bool has_fullscreen = window_util::HasFullscreenWindow(windows());
   bool widget_visible = status_area_widget_->IsVisible();
   if (has_fullscreen && widget_visible)
     status_area_widget_->Hide();
   else if (!has_fullscreen && !widget_visible)
     status_area_widget_->Show();
 }
 
 void CompactLayoutManager::AnimateSlideTo(int offset_x) {
-  ui::ScopedLayerAnimationSettings settings(
-      GetDefaultContainerLayer()->GetAnimator());
-  settings.AddObserver(this);
+  // If we were waiting for another implicit animation to complete, forget
+  // about it since we're about to start observing a new animation.
+  StopObservingImplicitAnimations();
+  ScopedVector<ui::ScopedLayerAnimationSettings> settings;

[sky, 2012/02/13 22:21:13]

Is there a reason you're creating this outside the for loop? Shouldn't it be
simpler to declare on the stack around line 163ish?

   ui::Transform transform;
-  transform.ConcatTranslate(-offset_x, 0);
-  GetDefaultContainerLayer()->SetTransform(transform);  // Will be animated!
+  transform.SetTranslateX(-offset_x);
+  ShellDelegate* shell_delegate = ash::Shell::GetInstance()->delegate();
+  const WindowList& windows_list = shell_delegate->GetCycleWindowList(
+      ShellDelegate::SOURCE_KEYBOARD,
+      ShellDelegate::ORDER_LINEAR);
+  for (WindowListConstIter const_it = windows_list.begin();
+       const_it != windows_list.end();
+       ++const_it) {
+    settings.push_back(new ui::ScopedLayerAnimationSettings(
+        (*const_it)->layer()->GetAnimator()));
+    settings[settings.size() - 1]->AddObserver(this);
+    (*const_it)->layer()->SetTransform(transform);

[alicet1, 2012/02/13 22:32:46]

I'm not sure this will work properly -- this will set all windows in the cycle
list to slide to -offset_x. if you have 3 windows, how does alt-tabbing through
them shows the fast sliding from window 3 -> window 1?

+  }
 }
 
 void CompactLayoutManager::LayoutWindows(aura::Window* skip) {
   ShellDelegate* shell_delegate = ash::Shell::GetInstance()->delegate();
   const WindowList& windows_list = shell_delegate->GetCycleWindowList(
       ShellDelegate::SOURCE_KEYBOARD,
       ShellDelegate::ORDER_LINEAR);
   int new_x = 0;
   for (WindowListConstIter const_it = windows_list.begin();
        const_it != windows_list.end();
@@ skipping 54 matching lines @@
 void CompactLayoutManager::SwitchToReplacementWindow() {
   current_window_ = FindReplacementWindow(current_window_);
   if (current_window_) {
     ActivateWindow(current_window_);
     AnimateSlideTo(current_window_->bounds().x());
   }
 }
 
 }  // namespace internal
 }  // namespace ash