Revert 120092 - Reland 120074 -- 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

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=120074

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

TBR=vollick@google.com
Review URL: https://chromiumcodereview.appspot.com/9320018

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

9 files changed, 90 insertions, 57 deletions

diff --git a/ash/wm/compact_layout_manager.cc b/ash/wm/compact_layout_manager.cc
index 2be9525..105d04c 100644
--- a/ash/wm/compact_layout_manager.cc
+++ b/ash/wm/compact_layout_manager.cc
@@ -140,11 +140,20 @@ void CompactLayoutManager::OnWindowStackingChanged(aura::Window* window) {
 /////////////////////////////////////////////////////////////////////////////
 // CompactLayoutManager, AnimationDelegate overrides:
 
-void CompactLayoutManager::OnImplicitAnimationsCompleted() {
+void CompactLayoutManager::OnLayerAnimationEnded(
+    const ui::LayerAnimationSequence* animation) {
   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 9f9843a..8b4f241 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::ImplicitAnimationObserver {
+                                        public ui::LayerAnimationObserver {
  public:
   CompactLayoutManager();
   virtual ~CompactLayoutManager();
@@ -48,8 +48,13 @@ class ASH_EXPORT CompactLayoutManager : public BaseLayoutManager,
                                        void* old) OVERRIDE;
   virtual void OnWindowStackingChanged(aura::Window* window) OVERRIDE;
 
-  // ui::OnImplicitAnimationsCompleted:
-  virtual void OnImplicitAnimationsCompleted() 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;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(CompactLayoutManagerTransitionTest,
diff --git a/ash/wm/shelf_layout_manager.cc b/ash/wm/shelf_layout_manager.cc
index c747c0f..1283fe5 100644
--- a/ash/wm/shelf_layout_manager.cc
+++ b/ash/wm/shelf_layout_manager.cc
@@ -10,7 +10,6 @@
 #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"
@@ -31,7 +30,8 @@ ui::Layer* GetLayer(views::Widget* widget) {
 
 ShelfLayoutManager::ShelfLayoutManager(views::Widget* launcher,
                                        views::Widget* status)
-    : in_layout_(false),
+    : animating_(false),
+      in_layout_(false),
       visible_(true),
       max_height_(-1),
       launcher_(launcher),
@@ -39,9 +39,11 @@ 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());
@@ -64,36 +66,19 @@ void ShelfLayoutManager::LayoutShelf() {
 }
 
 void ShelfLayoutManager::SetVisible(bool 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;
-
+  bool current_visibility = animating_ ? !visible_ : visible_;
   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);
-
-  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);
+  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.
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -124,7 +109,10 @@ void ShelfLayoutManager::SetChildBounds(aura::Window* child,
 // ShelfLayoutManager, private:
 
 void ShelfLayoutManager::StopAnimating() {
-  StopObservingImplicitAnimations();
+  if (animating_) {
+    animating_ = false;
+    visible_ = !visible_;
+  }
   GetLayer(launcher_)->GetAnimator()->StopAnimating();
   GetLayer(status_)->GetAnimator()->StopAnimating();
 }
@@ -147,7 +135,23 @@ void ShelfLayoutManager::CalculateTargetBounds(bool visible,
     target_bounds->work_area_insets = gfx::Insets(0, 0, max_height_, 0);
 }
 
-void ShelfLayoutManager::OnImplicitAnimationsCompleted() {
+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_;
   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 8d69cc6..3c35389 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::ImplicitAnimationObserver {
+                                      public ui::LayerAnimationObserver {
  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 visible_; }
+  bool visible() const { return animating_ ? !visible_ : visible_; }
 
   views::Widget* launcher() { return launcher_; }
   views::Widget* status() { return status_; }
@@ -72,8 +72,21 @@ class ASH_EXPORT ShelfLayoutManager : public aura::LayoutManager,
   void CalculateTargetBounds(bool visible,
                              TargetBounds* target_bounds);
 
-  // Implementation of ImplicitAnimationObserver
-  virtual void OnImplicitAnimationsCompleted() OVERRIDE;
+  // 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_;
 
   // 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 e337a57..6fdd910 100644
--- a/ash/wm/system_modal_container_layout_manager.cc
+++ b/ash/wm/system_modal_container_layout_manager.cc
@@ -122,14 +122,22 @@ void SystemModalContainerLayoutManager::OnWindowPropertyChanged(
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// SystemModalContainerLayoutManager,
-//     ui::ImplicitAnimationObserver implementation:
+// SystemModalContainerLayoutManager, ui::LayerAnimationObserver implementation:
 
-void SystemModalContainerLayoutManager::OnImplicitAnimationsCompleted() {
+void SystemModalContainerLayoutManager::OnLayerAnimationEnded(
+    const ui::LayerAnimationSequence* sequence) {
   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:
@@ -178,33 +186,27 @@ 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() {
-  // Stop observing the modal screen's animations.
-  StopObservingImplicitAnimations();
+  modal_screen_->GetNativeView()->layer()->GetAnimator()->RemoveObserver(this);
   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 309d0f07..c713500 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::ImplicitAnimationObserver,
+      public ui::LayerAnimationObserver,
       public SystemModalContainerEventFilterDelegate {
  public:
   explicit SystemModalContainerLayoutManager(aura::Window* container);
@@ -55,8 +55,13 @@ class ASH_EXPORT SystemModalContainerLayoutManager
                                        const char* key,
                                        void* old) OVERRIDE;
 
-  // Overridden from ui::ImplicitAnimationObserver:
-  virtual void OnImplicitAnimationsCompleted() 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 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 e3be65d..04198ea 100644
--- a/ash/wm/system_modal_container_layout_manager_unittest.cc
+++ b/ash/wm/system_modal_container_layout_manager_unittest.cc
@@ -168,8 +168,10 @@ 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,
-       CanActivateAfterEndModalSession) {
+       DISABLED_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));
@@ -189,8 +191,6 @@ 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 9fb1024..aaa15a5 100644
--- a/ash/wm/visibility_controller_unittest.cc
+++ b/ash/wm/visibility_controller_unittest.cc
@@ -8,7 +8,6 @@
 #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 {
@@ -18,9 +17,6 @@ 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 5c4c3a4..8b8c0b1 100644
--- a/ash/wm/window_animations.cc
+++ b/ash/wm/window_animations.cc
@@ -171,8 +171,7 @@ void AnimateHideWindowCommon(aura::Window* window,
 
   // Property sets within this scope will be implicitly animated.
   ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
-  settings.AddObserver(new HidingWindowAnimationObserver(window));
-
+  settings.AddImplicitObserver(new HidingWindowAnimationObserver(window));
   int duration =
       window->GetIntProperty(internal::kWindowVisibilityAnimationDurationKey);
   if (duration > 0) {