Disable animations during aura tests.

This causes all animations scheduled during a test to complete immediately.

After making this change, I noticed some code assumed that animations would not complete synchronously. Some of this code used animation observers, and I while fixing the code I have updated it to use the preferred ImplicitAnimationObserver.

BUG=None
TEST=aura_shell_unittests,aura_unittests,compositor_unittests

Review URL: https://chromiumcodereview.appspot.com/9222018

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@120074 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 57 insertions, 90 deletions

diff --git a/ash/wm/compact_layout_manager.cc b/ash/wm/compact_layout_manager.cc
index 105d04c..2be9525 100644
--- a/ash/wm/compact_layout_manager.cc
+++ b/ash/wm/compact_layout_manager.cc
@@ -140,20 +140,11 @@ void CompactLayoutManager::OnWindowStackingChanged(aura::Window* window) {
 /////////////////////////////////////////////////////////////////////////////
 // CompactLayoutManager, AnimationDelegate overrides:
 
-void CompactLayoutManager::OnLayerAnimationEnded(
-    const ui::LayerAnimationSequence* animation) {
+void CompactLayoutManager::OnImplicitAnimationsCompleted() {
   if (!GetDefaultContainerLayer()->GetAnimator()->is_animating())
     HideWindows();
 }
 
-void CompactLayoutManager::OnLayerAnimationScheduled(
-    const ui::LayerAnimationSequence* animation) {
-}
-
-void CompactLayoutManager::OnLayerAnimationAborted(
-    const ui::LayerAnimationSequence* animation) {
-}
-
 //////////////////////////////////////////////////////////////////////////////
 // CompactLayoutManager, private:
 
diff --git a/ash/wm/compact_layout_manager.h b/ash/wm/compact_layout_manager.h
index 8b4f241..9f9843a 100644
--- a/ash/wm/compact_layout_manager.h
+++ b/ash/wm/compact_layout_manager.h
@@ -25,7 +25,7 @@ namespace internal {
 // maximized, fill the screen, and only one tabbed browser window is visible at
 // a time.  The status area appears in the top-right corner of the screen.
 class ASH_EXPORT CompactLayoutManager : public BaseLayoutManager,
-                                        public ui::LayerAnimationObserver {
+                                        public ui::ImplicitAnimationObserver {
  public:
   CompactLayoutManager();
   virtual ~CompactLayoutManager();
@@ -48,13 +48,8 @@ class ASH_EXPORT CompactLayoutManager : public BaseLayoutManager,
                                        void* old) OVERRIDE;
   virtual void OnWindowStackingChanged(aura::Window* window) OVERRIDE;
 
-  // ui::LayerAnimationObserver:
-  virtual void OnLayerAnimationEnded(
-      const ui::LayerAnimationSequence* animation) OVERRIDE;
-  virtual void OnLayerAnimationScheduled(
-      const ui::LayerAnimationSequence* animation) OVERRIDE;
-  virtual void OnLayerAnimationAborted(
-      const ui::LayerAnimationSequence* animation) OVERRIDE;
+  // ui::OnImplicitAnimationsCompleted:
+  virtual void OnImplicitAnimationsCompleted() OVERRIDE;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(CompactLayoutManagerTransitionTest,
diff --git a/ash/wm/shelf_layout_manager.cc b/ash/wm/shelf_layout_manager.cc
index 1283fe5..c747c0f 100644
--- a/ash/wm/shelf_layout_manager.cc
+++ b/ash/wm/shelf_layout_manager.cc
@@ -10,6 +10,7 @@
 #include "ui/aura/root_window.h"
 #include "ui/aura/screen_aura.h"
 #include "ui/gfx/compositor/layer.h"
+#include "ui/gfx/compositor/layer_animation_observer.h"
 #include "ui/gfx/compositor/layer_animator.h"
 #include "ui/gfx/compositor/scoped_layer_animation_settings.h"
 #include "ui/views/widget/widget.h"
@@ -30,8 +31,7 @@ ui::Layer* GetLayer(views::Widget* widget) {
 
 ShelfLayoutManager::ShelfLayoutManager(views::Widget* launcher,
                                        views::Widget* status)
-    : animating_(false),
-      in_layout_(false),
+    : in_layout_(false),
       visible_(true),
       max_height_(-1),
       launcher_(launcher),
@@ -39,11 +39,9 @@ ShelfLayoutManager::ShelfLayoutManager(views::Widget* launcher,
   gfx::Rect launcher_bounds = launcher->GetWindowScreenBounds();
   gfx::Rect status_bounds = status->GetWindowScreenBounds();
   max_height_ = std::max(launcher_bounds.height(), status_bounds.height());
-  GetLayer(launcher)->GetAnimator()->AddObserver(this);
 }
 
 ShelfLayoutManager::~ShelfLayoutManager() {
-  GetLayer(launcher_)->GetAnimator()->RemoveObserver(this);
   // Without a shelf we don't need special insets anymore.
   aura::RootWindow::GetInstance()->
       screen()->set_work_area_insets(gfx::Insets());
@@ -66,19 +64,36 @@ void ShelfLayoutManager::LayoutShelf() {
 }
 
 void ShelfLayoutManager::SetVisible(bool visible) {
-  bool current_visibility = animating_ ? !visible_ : visible_;
+  ui::Layer* launcher_layer = GetLayer(launcher_);
+  ui::Layer* status_layer = GetLayer(status_);
+
+  // TODO(vollick): once visibility is animatable, use GetTargetVisibility.
+  bool current_visibility = visible_ &&
+      launcher_layer->GetTargetOpacity() > 0.0f &&
+      status_layer->GetTargetOpacity() > 0.0f;
+
   if (visible == current_visibility)
     return;  // Nothing changed.
 
   StopAnimating();
 
+  visible_ = visible;
   TargetBounds target_bounds;
   float target_opacity = visible ? 1.0f : 0.0f;
   CalculateTargetBounds(visible, &target_bounds);
-  AnimateWidgetTo(launcher_, target_bounds.launcher_bounds, target_opacity);
-  AnimateWidgetTo(status_, target_bounds.status_bounds, target_opacity);
-  animating_ = true;
-  // |visible_| is updated once the animation completes.
+
+  ui::ScopedLayerAnimationSettings launcher_animation_setter(
+      launcher_layer->GetAnimator());
+  ui::ScopedLayerAnimationSettings status_animation_setter(
+      status_layer->GetAnimator());
+
+  launcher_animation_setter.AddObserver(this);
+  status_animation_setter.AddObserver(this);
+
+  launcher_layer->SetBounds(target_bounds.launcher_bounds);
+  launcher_layer->SetOpacity(target_opacity);
+  status_layer->SetBounds(target_bounds.status_bounds);
+  status_layer->SetOpacity(target_opacity);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -109,10 +124,7 @@ void ShelfLayoutManager::SetChildBounds(aura::Window* child,
 // ShelfLayoutManager, private:
 
 void ShelfLayoutManager::StopAnimating() {
-  if (animating_) {
-    animating_ = false;
-    visible_ = !visible_;
-  }
+  StopObservingImplicitAnimations();
   GetLayer(launcher_)->GetAnimator()->StopAnimating();
   GetLayer(status_)->GetAnimator()->StopAnimating();
 }
@@ -135,23 +147,7 @@ void ShelfLayoutManager::CalculateTargetBounds(bool visible,
     target_bounds->work_area_insets = gfx::Insets(0, 0, max_height_, 0);
 }
 
-void ShelfLayoutManager::AnimateWidgetTo(views::Widget* widget,
-                                         const gfx::Rect& target_bounds,
-                                         float target_opacity) {
-  ui::Layer* layer = GetLayer(widget);
-  ui::ScopedLayerAnimationSettings animation_setter(layer->GetAnimator());
-  // Don't go through the widget, otherwise we end up back in SetChildBounds and
-  // cancel the animation/layout.
-  layer->SetBounds(target_bounds);
-  layer->SetOpacity(target_opacity);
-}
-
-void ShelfLayoutManager::OnLayerAnimationEnded(
-    const ui::LayerAnimationSequence* sequence) {
-  if (!animating_)
-    return;
-  animating_ = false;
-  visible_ = !visible_;
+void ShelfLayoutManager::OnImplicitAnimationsCompleted() {
   TargetBounds target_bounds;
   CalculateTargetBounds(visible_, &target_bounds);
   aura::RootWindow::GetInstance()->screen()->set_work_area_insets(
diff --git a/ash/wm/shelf_layout_manager.h b/ash/wm/shelf_layout_manager.h
index 3c35389..8d69cc6 100644
--- a/ash/wm/shelf_layout_manager.h
+++ b/ash/wm/shelf_layout_manager.h
@@ -28,7 +28,7 @@ namespace internal {
 // To respond to bounds changes in the status area StatusAreaLayoutManager works
 // closely with ShelfLayoutManager.
 class ASH_EXPORT ShelfLayoutManager : public aura::LayoutManager,
-                                      public ui::LayerAnimationObserver {
+                                      public ui::ImplicitAnimationObserver {
  public:
   ShelfLayoutManager(views::Widget* launcher, views::Widget* status);
   virtual ~ShelfLayoutManager();
@@ -41,7 +41,7 @@ class ASH_EXPORT ShelfLayoutManager : public aura::LayoutManager,
 
   // Sets the visibility of the shelf to |visible|.
   void SetVisible(bool visible);
-  bool visible() const { return animating_ ? !visible_ : visible_; }
+  bool visible() const { return visible_; }
 
   views::Widget* launcher() { return launcher_; }
   views::Widget* status() { return status_; }
@@ -72,21 +72,8 @@ class ASH_EXPORT ShelfLayoutManager : public aura::LayoutManager,
   void CalculateTargetBounds(bool visible,
                              TargetBounds* target_bounds);
 
-  // Animates |widget| to the specified bounds and opacity.
-  void AnimateWidgetTo(views::Widget* widget,
-                       const gfx::Rect& target_bounds,
-                       float target_opacity);
-
-  // LayerAnimationObserver overrides:
-  virtual void OnLayerAnimationEnded(
-      const ui::LayerAnimationSequence* sequence) OVERRIDE;
-  virtual void OnLayerAnimationAborted(
-      const ui::LayerAnimationSequence* sequence) OVERRIDE {}
-  virtual void OnLayerAnimationScheduled(
-      const ui::LayerAnimationSequence* sequence) OVERRIDE {}
-
-  // Are we animating?
-  bool animating_;
+  // Implementation of ImplicitAnimationObserver
+  virtual void OnImplicitAnimationsCompleted() OVERRIDE;
 
   // True when inside LayoutShelf method. Used to prevent calling LayoutShelf
   // again from SetChildBounds().
diff --git a/ash/wm/system_modal_container_layout_manager.cc b/ash/wm/system_modal_container_layout_manager.cc
index 6fdd910..e337a57 100644
--- a/ash/wm/system_modal_container_layout_manager.cc
+++ b/ash/wm/system_modal_container_layout_manager.cc
@@ -122,22 +122,14 @@ void SystemModalContainerLayoutManager::OnWindowPropertyChanged(
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// SystemModalContainerLayoutManager, ui::LayerAnimationObserver implementation:
+// SystemModalContainerLayoutManager,
+//     ui::ImplicitAnimationObserver implementation:
 
-void SystemModalContainerLayoutManager::OnLayerAnimationEnded(
-    const ui::LayerAnimationSequence* sequence) {
+void SystemModalContainerLayoutManager::OnImplicitAnimationsCompleted() {
   if (modal_screen_ && !modal_screen_->GetNativeView()->layer()->ShouldDraw())
     DestroyModalScreen();
 }
 
-void SystemModalContainerLayoutManager::OnLayerAnimationAborted(
-    const ui::LayerAnimationSequence* sequence) {
-}
-
-void SystemModalContainerLayoutManager::OnLayerAnimationScheduled(
-    const ui::LayerAnimationSequence* sequence) {
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // SystemModalContainerLayoutManager,
 //     SystemModalContainerEventFilter::Delegate implementation:
@@ -186,27 +178,33 @@ void SystemModalContainerLayoutManager::CreateModalScreen() {
       "SystemModalContainerLayoutManager.ModalScreen");
   modal_screen_->SetContentsView(new ScreenView);
   modal_screen_->GetNativeView()->layer()->SetOpacity(0.0f);
-  modal_screen_->GetNativeView()->layer()->GetAnimator()->AddObserver(this);
 
   Shell::GetInstance()->AddRootWindowEventFilter(modality_filter_.get());
 
+  StopObservingImplicitAnimations();
+
   ui::ScopedLayerAnimationSettings settings(
       modal_screen_->GetNativeView()->layer()->GetAnimator());
+  settings.AddObserver(this);
   modal_screen_->Show();
   modal_screen_->GetNativeView()->layer()->SetOpacity(0.5f);
   container_->StackChildAtTop(modal_screen_->GetNativeView());
 }
 
 void SystemModalContainerLayoutManager::DestroyModalScreen() {
-  modal_screen_->GetNativeView()->layer()->GetAnimator()->RemoveObserver(this);
+  // Stop observing the modal screen's animations.
+  StopObservingImplicitAnimations();
   modal_screen_->Close();
   modal_screen_ = NULL;
 }
 
 void SystemModalContainerLayoutManager::HideModalScreen() {
+  StopObservingImplicitAnimations();
+
   Shell::GetInstance()->RemoveRootWindowEventFilter(modality_filter_.get());
   ui::ScopedLayerAnimationSettings settings(
       modal_screen_->GetNativeView()->layer()->GetAnimator());
+  settings.AddObserver(this);
   modal_screen_->GetNativeView()->layer()->SetOpacity(0.0f);
 }
 
diff --git a/ash/wm/system_modal_container_layout_manager.h b/ash/wm/system_modal_container_layout_manager.h
index c713500..309d0f07 100644
--- a/ash/wm/system_modal_container_layout_manager.h
+++ b/ash/wm/system_modal_container_layout_manager.h
@@ -35,7 +35,7 @@ namespace internal {
 class ASH_EXPORT SystemModalContainerLayoutManager
     : public aura::LayoutManager,
       public aura::WindowObserver,
-      public ui::LayerAnimationObserver,
+      public ui::ImplicitAnimationObserver,
       public SystemModalContainerEventFilterDelegate {
  public:
   explicit SystemModalContainerLayoutManager(aura::Window* container);
@@ -55,13 +55,8 @@ class ASH_EXPORT SystemModalContainerLayoutManager
                                        const char* key,
                                        void* old) OVERRIDE;
 
-  // Overridden from ui::LayerAnimationObserver:
-  virtual void OnLayerAnimationEnded(
-      const ui::LayerAnimationSequence* sequence) OVERRIDE;
-  virtual void OnLayerAnimationAborted(
-      const ui::LayerAnimationSequence* sequence) OVERRIDE;
-  virtual void OnLayerAnimationScheduled(
-      const ui::LayerAnimationSequence* sequence) OVERRIDE;
+  // Overridden from ui::ImplicitAnimationObserver:
+  virtual void OnImplicitAnimationsCompleted() OVERRIDE;
 
   // Overridden from SystemModalContainerEventFilterDelegate:
   virtual bool CanWindowReceiveEvents(aura::Window* window) OVERRIDE;
diff --git a/ash/wm/system_modal_container_layout_manager_unittest.cc b/ash/wm/system_modal_container_layout_manager_unittest.cc
index 04198ea..e3be65d 100644
--- a/ash/wm/system_modal_container_layout_manager_unittest.cc
+++ b/ash/wm/system_modal_container_layout_manager_unittest.cc
@@ -168,10 +168,8 @@ TEST_F(SystemModalContainerLayoutManagerTest, ModalTransient) {
 
 // Tests that we can activate an unrelated window after a modal window is closed
 // for a window.
-// TODO(beng): This test is disabled pending a solution re: visibility & target
-//             visibility.
 TEST_F(SystemModalContainerLayoutManagerTest,
-       DISABLED_CanActivateAfterEndModalSession) {
+       CanActivateAfterEndModalSession) {
   scoped_ptr<aura::Window> unrelated(TestWindow::OpenTestWindow(NULL, false));
   unrelated->SetBounds(gfx::Rect(100, 100, 50, 50));
   scoped_ptr<aura::Window> parent(TestWindow::OpenTestWindow(NULL, false));
@@ -191,6 +189,8 @@ TEST_F(SystemModalContainerLayoutManagerTest,
   // Now close the transient.
   transient.reset();
 
+  MessageLoopForUI::current()->RunAllPending();
+
   // parent should now be active again.
   EXPECT_TRUE(IsActiveWindow(parent.get()));
 
diff --git a/ash/wm/visibility_controller_unittest.cc b/ash/wm/visibility_controller_unittest.cc
index aaa15a5..9fb1024 100644
--- a/ash/wm/visibility_controller_unittest.cc
+++ b/ash/wm/visibility_controller_unittest.cc
@@ -8,6 +8,7 @@
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
+#include "ui/gfx/compositor/layer_animator.h"
 
 namespace ash {
 namespace internal {
@@ -17,6 +18,9 @@ typedef test::AuraShellTestBase VisibilityControllerTest;
 // Hiding a window in an animatable container should not hide the window's layer
 // immediately.
 TEST_F(VisibilityControllerTest, AnimateHideDoesntHideWindowLayer) {
+  // We cannot disable animations for this test.
+  ui::LayerAnimator::set_disable_animations_for_test(false);
+
   scoped_ptr<aura::Window> container(
       aura::test::CreateTestWindowWithId(-1, NULL));
   SetChildWindowVisibilityChangesAnimated(container.get());
diff --git a/ash/wm/window_animations.cc b/ash/wm/window_animations.cc
index 8b8c0b1..5c4c3a4 100644
--- a/ash/wm/window_animations.cc
+++ b/ash/wm/window_animations.cc
@@ -171,7 +171,8 @@ void AnimateHideWindowCommon(aura::Window* window,
 
   // Property sets within this scope will be implicitly animated.
   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
-  settings.AddImplicitObserver(new HidingWindowAnimationObserver(window));
+  settings.AddObserver(new HidingWindowAnimationObserver(window));
+
   int duration =
       window->GetIntProperty(internal::kWindowVisibilityAnimationDurationKey);
   if (duration > 0) {