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

14 files changed, 85 insertions, 134 deletions

diff --git a/ash/app_list/app_list.cc b/ash/app_list/app_list.cc
index c439bbb..ad9fd01 100644
--- a/ash/app_list/app_list.cc
+++ b/ash/app_list/app_list.cc
@@ -87,7 +87,6 @@ void AppList::SetWidget(views::Widget* widget) {
 
   if (is_visible_) {
     widget_ = widget;
-    widget_->AddObserver(this);
     GetLayer(widget_)->GetAnimator()->AddObserver(this);
     Shell::GetInstance()->AddRootWindowEventFilter(this);
 
@@ -119,13 +118,19 @@ void AppList::ScheduleAnimation() {
     return;
 
   ui::Layer* layer = GetLayer(widget_);
+
+  // Stop observing previous animation.
+  StopObservingImplicitAnimations();
+
   ui::ScopedLayerAnimationSettings app_list_animation(layer->GetAnimator());
+  app_list_animation.AddObserver(this);
   layer->SetBounds(GetPreferredBounds(is_visible_));
   layer->SetOpacity(is_visible_ ? 1.0 : 0.0);
 
   ui::Layer* default_container_layer = default_container->layer();
   ui::ScopedLayerAnimationSettings default_container_animation(
       default_container_layer->GetAnimator());
+  app_list_animation.AddObserver(this);
   default_container_layer->SetOpacity(is_visible_ ? 0.0 : 1.0);
 }
 
@@ -159,22 +164,13 @@ ui::GestureStatus AppList::PreHandleGestureEvent(
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// AppList, ui::LayerAnimationObserver implementation:
+// AppList, ui::ImplicitAnimationObserver implementation:
 
-void AppList::OnLayerAnimationEnded(
-    const ui::LayerAnimationSequence* sequence) {
+void AppList::OnImplicitAnimationsCompleted() {
   if (!is_visible_ )
     widget_->Close();
 }
 
-void AppList::OnLayerAnimationAborted(
-    const ui::LayerAnimationSequence* sequence) {
-}
-
-void AppList::OnLayerAnimationScheduled(
-    const ui::LayerAnimationSequence* sequence) {
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // AppList, views::Widget::Observer implementation:
 
diff --git a/ash/app_list/app_list.h b/ash/app_list/app_list.h
index 77b2ecd..b499498 100644
--- a/ash/app_list/app_list.h
+++ b/ash/app_list/app_list.h
@@ -20,7 +20,7 @@ namespace internal {
 // While the UI is visible, it monitors things such as app list widget's
 // activation state and desktop mouse click to auto dismiss the UI.
 class AppList : public aura::EventFilter,
-                public ui::LayerAnimationObserver,
+                public ui::ImplicitAnimationObserver,
                 public views::Widget::Observer {
  public:
   AppList();
@@ -54,13 +54,8 @@ class AppList : public aura::EventFilter,
       aura::Window* target,
       aura::GestureEvent* event) OVERRIDE;
 
-  // ui::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;
+  // ui::ImplicitAnimationObserver overrides:
+  virtual void OnImplicitAnimationsCompleted() OVERRIDE;
 
   // views::Widget::Observer overrides:
   virtual void OnWidgetClosing(views::Widget* widget) OVERRIDE;
diff --git a/ash/drag_drop/drag_drop_controller.cc b/ash/drag_drop/drag_drop_controller.cc
index 2e43ea3..c3ca96a 100644
--- a/ash/drag_drop/drag_drop_controller.cc
+++ b/ash/drag_drop/drag_drop_controller.cc
@@ -28,7 +28,7 @@ namespace {
 const gfx::Point kDragDropWidgetOffset(0, 0);
 const base::TimeDelta kDragDropAnimationDuration =
     base::TimeDelta::FromMilliseconds(250);
-}
+}  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // DragDropController, public:
@@ -47,11 +47,8 @@ DragDropController::DragDropController()
 DragDropController::~DragDropController() {
   Shell::GetInstance()->RemoveRootWindowEventFilter(this);
   Cleanup();
-  if (drag_image_.get()) {
-    aura::Window* window = drag_image_->GetWidget()->GetNativeView();
-    window->layer()->GetAnimator()->RemoveObserver(this);
+  if (drag_image_.get())
     drag_image_.reset();
-  }
 }
 
 int DragDropController::StartDragAndDrop(const ui::OSExchangeData& data,
@@ -206,14 +203,7 @@ ui::GestureStatus DragDropController::PreHandleGestureEvent(
 ////////////////////////////////////////////////////////////////////////////////
 // DragDropController, private:
 
-void DragDropController::OnLayerAnimationEnded(
-    const ui::LayerAnimationSequence* sequence) {
-  DCHECK(drag_image_.get());
-  drag_image_.reset();
-}
-
-void DragDropController::OnLayerAnimationAborted(
-    const ui::LayerAnimationSequence* sequence) {
+void DragDropController::OnImplicitAnimationsCompleted() OVERRIDE {
   DCHECK(drag_image_.get());
   drag_image_.reset();
 }
@@ -223,9 +213,13 @@ void DragDropController::StartCanceledAnimation() {
   ui::LayerAnimator* animator = window->layer()->GetAnimator();
   animator->set_preemption_strategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-  animator->AddObserver(this);
+
+  // Stop waiting for any as yet unfinished implicit animations.
+  StopObservingImplicitAnimations();
+
   ui::ScopedLayerAnimationSettings animation_setter(animator);
   animation_setter.SetTransitionDuration(kDragDropAnimationDuration);
+  animation_setter.AddObserver(this);
   window->SetBounds(gfx::Rect(drag_start_location_, window->bounds().size()));
 }
 
diff --git a/ash/drag_drop/drag_drop_controller.h b/ash/drag_drop/drag_drop_controller.h
index 0f9b257..9272257 100644
--- a/ash/drag_drop/drag_drop_controller.h
+++ b/ash/drag_drop/drag_drop_controller.h
@@ -36,8 +36,8 @@ class DragImageView;
 class ASH_EXPORT DragDropController
     : public aura::client::DragDropClient,
       public aura::EventFilter,
-      public ui::LayerAnimationObserver {
- public:
+      public ui::ImplicitAnimationObserver {
+public:
   DragDropController();
   virtual ~DragDropController();
 
@@ -69,13 +69,8 @@ class ASH_EXPORT DragDropController
  private:
   friend class ash::test::DragDropControllerTest;
 
-  // 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 {}
+  // Implementation of ImplicitAnimationObserver
+  virtual void OnImplicitAnimationsCompleted() OVERRIDE;
 
   // Helper method to start drag widget flying back animation.
   void StartCanceledAnimation();
diff --git a/ash/test/aura_shell_test_base.cc b/ash/test/aura_shell_test_base.cc
index b6011de..1486f1c 100644
--- a/ash/test/aura_shell_test_base.cc
+++ b/ash/test/aura_shell_test_base.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -6,6 +6,7 @@
 
 #include "ash/shell.h"
 #include "ash/test/test_shell_delegate.h"
+#include "ui/gfx/compositor/layer_animator.h"
 
 namespace ash {
 namespace test {
@@ -21,6 +22,9 @@ void AuraShellTestBase::SetUp() {
 
   // Creates Shell and hook with Desktop.
   ash::Shell::CreateInstance(new TestShellDelegate);
+
+  // Disable animations during tests.
+  ui::LayerAnimator::set_disable_animations_for_test(true);
 }
 
 void AuraShellTestBase::TearDown() {
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) {