Allows observers to be notified when layer animations complete.

Depends on http://codereview.chromium.org/8362006/

BUG=101595
TEST=None

Review URL: http://codereview.chromium.org/8395046

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

23 files changed, 489 insertions, 217 deletions

diff --git a/ui/aura/desktop.cc b/ui/aura/desktop.cc
index a6c909a..7595b1d 100644
--- a/ui/aura/desktop.cc
+++ b/ui/aura/desktop.cc
@@ -305,8 +305,10 @@ bool Desktop::DispatchKeyEvent(KeyEvent* event) {
       if (degrees != 0) {
         layer()->GetAnimator()->set_preemption_strategy(
             ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
-        layer()->GetAnimator()->ScheduleAnimationElement(
-            new ScreenRotation(degrees));
+        scoped_ptr<ui::LayerAnimationSequence> screen_rotation(
+            new ui::LayerAnimationSequence(new ScreenRotation(degrees)));
+        screen_rotation->AddObserver(this);
+        layer()->GetAnimator()->ScheduleAnimation(screen_rotation.release());
         return true;
       }
     }
@@ -566,6 +568,14 @@ void Desktop::OnLayerAnimationEnded(
   OnHostResized(host_->GetSize());
 }
 
+void Desktop::OnLayerAnimationScheduled(
+    const ui::LayerAnimationSequence* animation) {
+}
+
+void Desktop::OnLayerAnimationAborted(
+    const ui::LayerAnimationSequence* animation) {
+}
+
 void Desktop::SetFocusedWindow(Window* focused_window) {
   if (focused_window == focused_window_ ||
       (focused_window && !focused_window->CanFocus())) {
diff --git a/ui/aura/desktop.h b/ui/aura/desktop.h
index 9ee5c1d..7a58b48 100644
--- a/ui/aura/desktop.h
+++ b/ui/aura/desktop.h
@@ -17,6 +17,7 @@
 #include "ui/aura/window.h"
 #include "ui/base/events.h"
 #include "ui/gfx/compositor/compositor.h"
+#include "ui/gfx/compositor/layer_animation_observer.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/point.h"
 
@@ -42,7 +43,8 @@ class TouchEvent;
 // Desktop is responsible for hosting a set of windows.
 class AURA_EXPORT Desktop : public ui::CompositorDelegate,
                             public Window,
-                            public internal::FocusManager {
+                            public internal::FocusManager,
+                            public ui::LayerAnimationObserver {
  public:
   Desktop();
   virtual ~Desktop();
@@ -146,9 +148,13 @@ class AURA_EXPORT Desktop : public ui::CompositorDelegate,
   virtual internal::FocusManager* GetFocusManager() OVERRIDE;
   virtual Desktop* GetDesktop() OVERRIDE;
 
-  // Overridden from ui::LayerDelegate:
+  // Overridden from 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;
 
   // Overridden from FocusManager:
   virtual void SetFocusedWindow(Window* window) OVERRIDE;
diff --git a/ui/aura/window.cc b/ui/aura/window.cc
index 7d94342..f7291f2 100644
--- a/ui/aura/window.cc
+++ b/ui/aura/window.cc
@@ -487,8 +487,4 @@ void Window::OnPaintLayer(gfx::Canvas* canvas) {
   delegate_->OnPaint(canvas);
 }
 
-void Window::OnLayerAnimationEnded(
-    const ui::LayerAnimationSequence* animation) {
-}
-
 }  // namespace aura
diff --git a/ui/aura/window.h b/ui/aura/window.h
index ed261b4..b376914 100644
--- a/ui/aura/window.h
+++ b/ui/aura/window.h
@@ -297,8 +297,6 @@ class AURA_EXPORT Window : public ui::LayerDelegate {
 
   // Overridden from ui::LayerDelegate:
   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE;
-  virtual void OnLayerAnimationEnded(
-      const ui::LayerAnimationSequence* animation) OVERRIDE;
 
   WindowType type_;
 
diff --git a/ui/gfx/compositor/compositor.gyp b/ui/gfx/compositor/compositor.gyp
index d5fa818..5a940ae 100644
--- a/ui/gfx/compositor/compositor.gyp
+++ b/ui/gfx/compositor/compositor.gyp
@@ -45,13 +45,12 @@
         'compositor_observer.h',
         'compositor_stub.cc',
         'compositor_win.cc',
-        'dummy_layer_animation_delegate.cc',
-        'dummy_layer_animation_delegate.h',
         'layer.cc',
         'layer.h',
         'layer_animation_delegate.h',
         'layer_animation_element.cc',
         'layer_animation_element.h',
+        'layer_animation_observer.h',
         'layer_animation_sequence.cc',
         'layer_animation_sequence.h',
         'layer_animator.cc',
@@ -149,6 +148,10 @@
         'test_compositor_host.h',
         'test_compositor_host_linux.cc',
         'test_compositor_host_win.cc',
+        'test_layer_animation_delegate.cc',
+        'test_layer_animation_delegate.h',
+        'test_layer_animation_observer.cc',
+        'test_layer_animation_observer.h',
         'test_suite.cc',
         'test_suite.h',
         'test_utils.cc',
@@ -191,7 +194,7 @@
             'test_compositor.h',
             'test_texture.cc',
             'test_texture.h',
-          ],              
+          ],
         }],
       ],
     },
diff --git a/ui/gfx/compositor/dummy_layer_animation_delegate.cc b/ui/gfx/compositor/dummy_layer_animation_delegate.cc
deleted file mode 100644
index ea026dc..0000000
--- a/ui/gfx/compositor/dummy_layer_animation_delegate.cc
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright (c) 2011 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 "ui/gfx/compositor/dummy_layer_animation_delegate.h"
-
-namespace ui {
-
-DummyLayerAnimationDelegate::DummyLayerAnimationDelegate() : opacity_(1.0f) {
-}
-
-DummyLayerAnimationDelegate::DummyLayerAnimationDelegate(
-    const LayerAnimationDelegate& other)
-    : bounds_(other.GetBoundsForAnimation()),
-      transform_(other.GetTransformForAnimation()),
-      opacity_(other.GetOpacityForAnimation()) {
-}
-
-DummyLayerAnimationDelegate::~DummyLayerAnimationDelegate() {
-}
-
-void DummyLayerAnimationDelegate::SetBoundsFromAnimation(
-    const gfx::Rect& bounds) {
-  bounds_ = bounds;
-}
-
-void DummyLayerAnimationDelegate::SetTransformFromAnimation(
-    const Transform& transform) {
-  transform_ = transform;
-}
-
-void DummyLayerAnimationDelegate::SetOpacityFromAnimation(float opacity) {
-  opacity_ = opacity;
-}
-
-void DummyLayerAnimationDelegate::ScheduleDrawForAnimation() {
-}
-
-const gfx::Rect& DummyLayerAnimationDelegate::GetBoundsForAnimation() const {
-  return bounds_;
-}
-
-const Transform& DummyLayerAnimationDelegate::GetTransformForAnimation() const {
-  return transform_;
-}
-
-float DummyLayerAnimationDelegate::GetOpacityForAnimation() const {
-  return opacity_;
-}
-
-void DummyLayerAnimationDelegate::OnLayerAnimationEnded(
-    LayerAnimationSequence* sequence) {
-}
-
-}  // namespace ui
diff --git a/ui/gfx/compositor/layer.cc b/ui/gfx/compositor/layer.cc
index 4afee17..f632c65 100644
--- a/ui/gfx/compositor/layer.cc
+++ b/ui/gfx/compositor/layer.cc
@@ -654,11 +654,6 @@ float Layer::GetOpacityForAnimation() const {
   return opacity();
 }
 
-void Layer::OnLayerAnimationEnded(LayerAnimationSequence* sequence) {
-  if (delegate_)
-    delegate_->OnLayerAnimationEnded(sequence);
-}
-
 #if defined(USE_WEBKIT_COMPOSITOR)
 void Layer::CreateWebLayer() {
   web_layer_ = WebKit::WebContentLayer::create(this, this);
diff --git a/ui/gfx/compositor/layer.h b/ui/gfx/compositor/layer.h
index 1bb51e9..2d0a975 100644
--- a/ui/gfx/compositor/layer.h
+++ b/ui/gfx/compositor/layer.h
@@ -18,7 +18,7 @@
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/compositor/compositor.h"
-#include "ui/gfx/compositor/layer_animator_delegate.h"
+#include "ui/gfx/compositor/layer_animation_delegate.h"
 #include "ui/gfx/compositor/layer_delegate.h"
 
 class SkCanvas;
@@ -39,7 +39,7 @@ class Texture;
 // delete a Layer and it has children, the parent of each child layer is set to
 // NULL, but the children are not deleted.
 class COMPOSITOR_EXPORT Layer :
-    public LayerAnimatorDelegate,
+    public LayerAnimationDelegate,
     NON_EXPORTED_BASE(public WebKit::WebLayerClient),
     NON_EXPORTED_BASE(public WebKit::WebContentLayerClient) {
  public:
@@ -281,7 +281,6 @@ class COMPOSITOR_EXPORT Layer :
   virtual const gfx::Rect& GetBoundsForAnimation() const OVERRIDE;
   virtual const Transform& GetTransformForAnimation() const OVERRIDE;
   virtual float GetOpacityForAnimation() const OVERRIDE;
-  virtual void OnLayerAnimationEnded(LayerAnimationSequence* sequence) OVERRIDE;
 
 #if defined(USE_WEBKIT_COMPOSITOR)
   void CreateWebLayer();
diff --git a/ui/gfx/compositor/layer_animation_element_unittest.cc b/ui/gfx/compositor/layer_animation_element_unittest.cc
index 483817c..27940d4 100644
--- a/ui/gfx/compositor/layer_animation_element_unittest.cc
+++ b/ui/gfx/compositor/layer_animation_element_unittest.cc
@@ -11,8 +11,8 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
-#include "ui/gfx/compositor/dummy_layer_animation_delegate.h"
 #include "ui/gfx/compositor/layer_animation_delegate.h"
+#include "ui/gfx/compositor/test_layer_animation_delegate.h"
 #include "ui/gfx/compositor/test_utils.h"
 
 namespace ui {
@@ -22,7 +22,7 @@ namespace {
 // Check that the transformation element progresses the delegate as expected and
 // that the element can be reused after it completes.
 TEST(LayerAnimationElementTest, TransformElement) {
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   Transform start_transform, target_transform, middle_transform;
   start_transform.SetRotate(-90);
   target_transform.SetRotate(90);
@@ -54,7 +54,7 @@ TEST(LayerAnimationElementTest, TransformElement) {
 // Check that the bounds element progresses the delegate as expected and
 // that the element can be reused after it completes.
 TEST(LayerAnimationElementTest, BoundsElement) {
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   gfx::Rect start, target, middle;
   start = target = middle = gfx::Rect(0, 0, 50, 50);
   start.set_x(-90);
@@ -84,7 +84,7 @@ TEST(LayerAnimationElementTest, BoundsElement) {
 // Check that the opacity element progresses the delegate as expected and
 // that the element can be reused after it completes.
 TEST(LayerAnimationElementTest, OpacityElement) {
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   float start = 0.0;
   float middle = 0.5;
   float target = 1.0;
@@ -121,8 +121,8 @@ TEST(LayerAnimationElementTest, PauseElement) {
   scoped_ptr<LayerAnimationElement> element(
       LayerAnimationElement::CreatePauseElement(properties, delta));
 
-  DummyLayerAnimationDelegate delegate;
-  DummyLayerAnimationDelegate copy = delegate;
+  TestLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate copy = delegate;
 
   element->Progress(1.0, &delegate);
 
diff --git a/ui/gfx/compositor/layer_animation_observer.h b/ui/gfx/compositor/layer_animation_observer.h
new file mode 100644
index 0000000..1fe031e
--- /dev/null
+++ b/ui/gfx/compositor/layer_animation_observer.h
@@ -0,0 +1,36 @@
+// Copyright (c) 2011 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.
+
+#ifndef UI_GFX_COMPOSITOR_LAYER_ANIMATION_OBSERVER_H_
+#define UI_GFX_COMPOSITOR_LAYER_ANIMATION_OBSERVER_H_
+#pragma once
+
+#include "ui/gfx/compositor/compositor_export.h"
+
+namespace ui {
+
+class LayerAnimationSequence;
+
+// LayerAnimationObservers are notified when animations complete.
+class COMPOSITOR_EXPORT LayerAnimationObserver  {
+ public:
+  // Called when the |sequence| ends. Not called if |sequence| is aborted.
+  virtual void OnLayerAnimationEnded(
+      const LayerAnimationSequence* sequence) = 0;
+
+  // Called if |sequence| is aborted for any reason.
+  virtual void OnLayerAnimationAborted(
+      const LayerAnimationSequence* sequence) = 0;
+
+  // Called when the animation is scheduled.
+  virtual void OnLayerAnimationScheduled(
+      const LayerAnimationSequence* sequence) = 0;
+
+ protected:
+  virtual ~LayerAnimationObserver() {}
+};
+
+}  // namespace ui
+
+#endif  // UI_GFX_COMPOSITOR_LAYER_ANIMATION_OBSERVER_H_
diff --git a/ui/gfx/compositor/layer_animation_sequence.cc b/ui/gfx/compositor/layer_animation_sequence.cc
index 8f34969..f2e362b 100644
--- a/ui/gfx/compositor/layer_animation_sequence.cc
+++ b/ui/gfx/compositor/layer_animation_sequence.cc
@@ -10,6 +10,7 @@
 #include "base/debug/trace_event.h"
 #include "ui/gfx/compositor/layer_animation_delegate.h"
 #include "ui/gfx/compositor/layer_animation_element.h"
+#include "ui/gfx/compositor/layer_animation_observer.h"
 
 namespace ui {
 
@@ -65,6 +66,7 @@ void LayerAnimationSequence::Progress(base::TimeDelta elapsed,
   if (!is_cyclic_ && elapsed == duration_) {
     last_element_ = 0;
     last_start_ = base::TimeDelta::FromMilliseconds(0);
+    NotifyEnded();
   }
 }
 
@@ -85,6 +87,7 @@ void LayerAnimationSequence::Abort() {
   }
   last_element_ = 0;
   last_start_ = base::TimeDelta::FromMilliseconds(0);
+  NotifyAborted();
 }
 
 void LayerAnimationSequence::AddElement(LayerAnimationElement* element) {
@@ -106,4 +109,35 @@ bool LayerAnimationSequence::HasCommonProperty(
   return intersection.size() > 0;
 }
 
+void LayerAnimationSequence::AddObserver(LayerAnimationObserver* observer) {
+  if (!observers_.HasObserver(observer))
+    observers_.AddObserver(observer);
+}
+
+void LayerAnimationSequence::RemoveObserver(LayerAnimationObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+void LayerAnimationSequence::OnScheduled() {
+  NotifyScheduled();
+}
+
+void LayerAnimationSequence::NotifyScheduled() {
+  FOR_EACH_OBSERVER(LayerAnimationObserver,
+                    observers_,
+                    OnLayerAnimationScheduled(this));
+}
+
+void LayerAnimationSequence::NotifyEnded() {
+  FOR_EACH_OBSERVER(LayerAnimationObserver,
+                    observers_,
+                    OnLayerAnimationEnded(this));
+}
+
+void LayerAnimationSequence::NotifyAborted() {
+  FOR_EACH_OBSERVER(LayerAnimationObserver,
+                    observers_,
+                    OnLayerAnimationAborted(this));
+}
+
 }  // namespace ui
diff --git a/ui/gfx/compositor/layer_animation_sequence.h b/ui/gfx/compositor/layer_animation_sequence.h
index 4670587..6441a41 100644
--- a/ui/gfx/compositor/layer_animation_sequence.h
+++ b/ui/gfx/compositor/layer_animation_sequence.h
@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "base/memory/linked_ptr.h"
+#include "base/observer_list.h"
 #include "base/time.h"
 #include "ui/gfx/compositor/compositor_export.h"
 #include "ui/gfx/compositor/layer_animation_element.h"
@@ -16,6 +17,7 @@
 namespace ui {
 
 class LayerAnimationDelegate;
+class LayerAnimationObserver;
 
 // Contains a collection of layer animation elements to be played one after
 // another. Although it has a similar interface to LayerAnimationElement, it is
@@ -67,9 +69,26 @@ class COMPOSITOR_EXPORT LayerAnimationSequence {
   bool HasCommonProperty(
       const LayerAnimationElement::AnimatableProperties& other) const;
 
+  // These functions are used for adding or removing observers from the observer
+  // list. The observers are notified when animations end.
+  void AddObserver(LayerAnimationObserver* observer);
+  void RemoveObserver(LayerAnimationObserver* observer);
+
+  // Called when the animator schedules this sequence.
+  void OnScheduled();
+
  private:
   typedef std::vector<linked_ptr<LayerAnimationElement> > Elements;
 
+  // Notifies the observers that this sequence has been scheduled.
+  void NotifyScheduled();
+
+  // Notifies the observers that this sequence has ended.
+  void NotifyEnded();
+
+  // Notifies the observers that this sequence has been aborted.
+  void NotifyAborted();
+
   // The sum of the durations of all the elements in the sequence.
   base::TimeDelta duration_;
 
@@ -86,6 +105,9 @@ class COMPOSITOR_EXPORT LayerAnimationSequence {
   size_t last_element_;
   base::TimeDelta last_start_;
 
+  // These parties are notified when layer animations end.
+  ObserverList<LayerAnimationObserver> observers_;
+
   DISALLOW_COPY_AND_ASSIGN(LayerAnimationSequence);
 };
 
diff --git a/ui/gfx/compositor/layer_animation_sequence_unittest.cc b/ui/gfx/compositor/layer_animation_sequence_unittest.cc
index a80a5f1..ff44b58 100644
--- a/ui/gfx/compositor/layer_animation_sequence_unittest.cc
+++ b/ui/gfx/compositor/layer_animation_sequence_unittest.cc
@@ -11,9 +11,10 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
-#include "ui/gfx/compositor/dummy_layer_animation_delegate.h"
 #include "ui/gfx/compositor/layer_animation_delegate.h"
 #include "ui/gfx/compositor/layer_animation_element.h"
+#include "ui/gfx/compositor/test_layer_animation_delegate.h"
+#include "ui/gfx/compositor/test_layer_animation_observer.h"
 #include "ui/gfx/compositor/test_utils.h"
 
 namespace ui {
@@ -33,10 +34,10 @@ TEST(LayerAnimationSequenceTest, NoElement) {
 // a single element.
 TEST(LayerAnimationSequenceTest, SingleElement) {
   LayerAnimationSequence sequence;
-  DummyLayerAnimationDelegate delegate;
-  float start = 0.0;
-  float middle = 0.5;
-  float target = 1.0;
+  TestLayerAnimationDelegate delegate;
+  float start = 0.0f;
+  float middle = 0.5f;
+  float target = 1.0f;
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   sequence.AddElement(
       LayerAnimationElement::CreateOpacityElement(target, delta));
@@ -61,10 +62,10 @@ TEST(LayerAnimationSequenceTest, SingleElement) {
 // multiple elements. Note, see the layer animator tests for cyclic sequences.
 TEST(LayerAnimationSequenceTest, MultipleElement) {
   LayerAnimationSequence sequence;
-  DummyLayerAnimationDelegate delegate;
-  float start_opacity = 0.0;
-  float middle_opacity = 0.5;
-  float target_opacity = 1.0;
+  TestLayerAnimationDelegate delegate;
+  float start_opacity = 0.0f;
+  float middle_opacity = 0.5f;
+  float target_opacity = 1.0f;
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   sequence.AddElement(
       LayerAnimationElement::CreateOpacityElement(target_opacity, delta));
@@ -93,7 +94,7 @@ TEST(LayerAnimationSequenceTest, MultipleElement) {
     EXPECT_FLOAT_EQ(middle_opacity, delegate.GetOpacityForAnimation());
     sequence.Progress(base::TimeDelta::FromMilliseconds(1000), &delegate);
     EXPECT_FLOAT_EQ(target_opacity, delegate.GetOpacityForAnimation());
-    DummyLayerAnimationDelegate copy = delegate;
+    TestLayerAnimationDelegate copy = delegate;
 
     // In the middle of the pause -- nothing should have changed.
     sequence.Progress(base::TimeDelta::FromMilliseconds(1500), &delegate);
@@ -129,9 +130,9 @@ TEST(LayerAnimationSequenceTest, MultipleElement) {
 // Check that a sequence can still be aborted if it has cycled many times.
 TEST(LayerAnimationSequenceTest, AbortingCyclicSequence) {
   LayerAnimationSequence sequence;
-  DummyLayerAnimationDelegate delegate;
-  float start_opacity = 0.0;
-  float target_opacity = 1.0;
+  TestLayerAnimationDelegate delegate;
+  float start_opacity = 0.0f;
+  float target_opacity = 1.0f;
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   sequence.AddElement(
       LayerAnimationElement::CreateOpacityElement(target_opacity, delta));
@@ -157,9 +158,9 @@ TEST(LayerAnimationSequenceTest, AbortingCyclicSequence) {
 // Also check that this has no effect if the sequence is cyclic.
 TEST(LayerAnimationSequenceTest, SetTarget) {
   LayerAnimationSequence sequence;
-  DummyLayerAnimationDelegate delegate;
-  float start_opacity = 0.0;
-  float target_opacity = 1.0;
+  TestLayerAnimationDelegate delegate;
+  float start_opacity = 0.0f;
+  float target_opacity = 1.0f;
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   sequence.AddElement(
       LayerAnimationElement::CreateOpacityElement(target_opacity, delta));
@@ -175,6 +176,22 @@ TEST(LayerAnimationSequenceTest, SetTarget) {
   EXPECT_FLOAT_EQ(start_opacity, target_value.opacity);
 }
 
+TEST(LayerAnimationSequenceTest, AddObserver) {
+  base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
+  LayerAnimationSequence sequence;
+  sequence.AddElement(
+      LayerAnimationElement::CreateOpacityElement(1.0f, delta));
+  for (int i = 0; i < 2; ++i) {
+    TestLayerAnimationObserver observer;
+    TestLayerAnimationDelegate delegate;
+    sequence.AddObserver(&observer);
+    EXPECT_TRUE(!observer.last_ended_sequence());
+    sequence.Progress(delta, &delegate);
+    EXPECT_EQ(observer.last_ended_sequence(), &sequence);
+    sequence.RemoveObserver(&observer);
+  }
+}
+
 } // namespace
 
 } // namespace ui
diff --git a/ui/gfx/compositor/layer_animator.cc b/ui/gfx/compositor/layer_animator.cc
index 8004c5c..14a4bf98 100644
--- a/ui/gfx/compositor/layer_animator.cc
+++ b/ui/gfx/compositor/layer_animator.cc
@@ -10,7 +10,8 @@
 #include "ui/base/animation/animation_container.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/layer.h"
-#include "ui/gfx/compositor/layer_animator_delegate.h"
+#include "ui/gfx/compositor/layer_animation_delegate.h"
+#include "ui/gfx/compositor/layer_animation_observer.h"
 #include "ui/gfx/compositor/layer_animation_sequence.h"
 
 namespace ui {
@@ -55,8 +56,9 @@ void LayerAnimator::SetTransform(const Transform& transform) {
   if (transition_duration_ == base::TimeDelta())
     delegate_->SetTransformFromAnimation(transform);
   else
-    StartAnimationElement(LayerAnimationElement::CreateTransformElement(
-        transform, transition_duration_));
+    StartAnimation(new LayerAnimationSequence(
+        LayerAnimationElement::CreateTransformElement(
+            transform, transition_duration_)));
 }
 
 Transform LayerAnimator::GetTargetTransform() const {
@@ -69,8 +71,9 @@ void LayerAnimator::SetBounds(const gfx::Rect& bounds) {
   if (transition_duration_ == base::TimeDelta())
     delegate_->SetBoundsFromAnimation(bounds);
   else
-    StartAnimationElement(LayerAnimationElement::CreateBoundsElement(
-        bounds, transition_duration_));
+    StartAnimation(new LayerAnimationSequence(
+        LayerAnimationElement::CreateBoundsElement(
+            bounds, transition_duration_)));
 }
 
 gfx::Rect LayerAnimator::GetTargetBounds() const {
@@ -83,8 +86,9 @@ void LayerAnimator::SetOpacity(float opacity) {
   if (transition_duration_ == base::TimeDelta())
     delegate_->SetOpacityFromAnimation(opacity);
   else
-    StartAnimationElement(LayerAnimationElement::CreateOpacityElement(
-        opacity, transition_duration_));
+    StartAnimation(new LayerAnimationSequence(
+        LayerAnimationElement::CreateOpacityElement(
+            opacity, transition_duration_)));
 }
 
 float LayerAnimator::GetTargetOpacity() const {
@@ -93,12 +97,13 @@ float LayerAnimator::GetTargetOpacity() const {
   return target.opacity;
 }
 
-void LayerAnimator::SetDelegate(LayerAnimatorDelegate* delegate) {
+void LayerAnimator::SetDelegate(LayerAnimationDelegate* delegate) {
   DCHECK(delegate);
   delegate_ = delegate;
 }
 
 void LayerAnimator::StartAnimation(LayerAnimationSequence* animation) {
+  OnScheduled(animation);
   if (!StartSequenceImmediately(animation)) {
     // Attempt to preempt a running animation.
     switch (preemption_strategy_) {
@@ -126,6 +131,7 @@ void LayerAnimator::StartAnimation(LayerAnimationSequence* animation) {
 }
 
 void LayerAnimator::ScheduleAnimation(LayerAnimationSequence* animation) {
+  OnScheduled(animation);
   if (is_animating()) {
     animation_queue_.push_back(make_linked_ptr(animation));
     ProcessQueue();
@@ -162,20 +168,16 @@ void LayerAnimator::ScheduleTogether(
   UpdateAnimationState();
 }
 
-void LayerAnimator::StartAnimationElement(LayerAnimationElement* animation) {
-  StartAnimation(new LayerAnimationSequence(animation));
-}
-
-void LayerAnimator::ScheduleAnimationElement(LayerAnimationElement* animation) {
-  ScheduleAnimation(new LayerAnimationSequence(animation));
-}
-
-void LayerAnimator::ScheduleElementsTogether(
-    const std::vector<LayerAnimationElement*>& animations) {
-  std::vector<LayerAnimationSequence*> sequences;
-  for (size_t i = 0; i < animations.size(); ++i)
-    sequences.push_back(new LayerAnimationSequence(animations[i]));
-  ScheduleTogether(sequences);
+bool LayerAnimator::IsAnimatingProperty(
+    LayerAnimationElement::AnimatableProperty property) const {
+  for (AnimationQueue::const_iterator queue_iter = animation_queue_.begin();
+       queue_iter != animation_queue_.end(); ++queue_iter) {
+    if ((*queue_iter)->properties().find(property) !=
+        (*queue_iter)->properties().end()) {
+      return true;
+    }
+  }
+  return false;
 }
 
 void LayerAnimator::StopAnimatingProperty(
@@ -193,6 +195,15 @@ void LayerAnimator::StopAnimating() {
     FinishAnimation(running_animations_[0].sequence);
 }
 
+void LayerAnimator::AddObserver(LayerAnimationObserver* observer) {
+  if (!observers_.HasObserver(observer))
+    observers_.AddObserver(observer);
+}
+
+void LayerAnimator::RemoveObserver(LayerAnimationObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 LayerAnimator::ScopedSettings::ScopedSettings(LayerAnimator* animator)
     : animator_(animator),
       old_transition_duration_(animator->transition_duration_) {
@@ -201,6 +212,15 @@ LayerAnimator::ScopedSettings::ScopedSettings(LayerAnimator* animator)
 
 LayerAnimator::ScopedSettings::~ScopedSettings() {
   animator_->transition_duration_ = old_transition_duration_;
+  std::set<LayerAnimationObserver*>::const_iterator i = observers_.begin();
+  for (;i != observers_.end(); ++i)
+    animator_->RemoveObserver(*i);
+}
+
+void LayerAnimator::ScopedSettings::AddObserver(
+    LayerAnimationObserver* observer) {
+  observers_.insert(observer);
+  animator_->AddObserver(observer);
 }
 
 void LayerAnimator::ScopedSettings::SetTransitionDuration(
@@ -277,7 +297,6 @@ void LayerAnimator::RemoveAnimation(LayerAnimationSequence* sequence) {
 
 void LayerAnimator::FinishAnimation(LayerAnimationSequence* sequence) {
   sequence->Progress(sequence->duration(), delegate());
-  delegate()->OnLayerAnimationEnded(sequence);
   RemoveAnimation(sequence);
   ProcessQueue();
   UpdateAnimationState();
@@ -293,7 +312,6 @@ void LayerAnimator::FinishAnyAnimationWithZeroDuration() {
     if (running_animations_[i].sequence->duration() == base::TimeDelta()) {
       running_animations_[i].sequence->Progress(
           running_animations_[i].sequence->duration(), delegate());
-      delegate()->OnLayerAnimationEnded(running_animations_[i].sequence);
       RemoveAnimation(running_animations_[i].sequence);
     } else {
       ++i;
@@ -356,7 +374,6 @@ void LayerAnimator::RemoveAllAnimationsWithACommonProperty(
       } else {
         running_animations_[i].sequence->Progress(
             running_animations_[i].sequence->duration(), delegate());
-        delegate()->OnLayerAnimationEnded(running_animations_[i].sequence);
       }
       RemoveAnimation(running_animations_[i].sequence);
     } else {
@@ -384,7 +401,6 @@ void LayerAnimator::ImmediatelySetNewTarget(LayerAnimationSequence* sequence) {
   const bool abort = false;
   RemoveAllAnimationsWithACommonProperty(sequence, abort);
   sequence->Progress(sequence->duration(), delegate());
-  delegate()->OnLayerAnimationEnded(sequence);
   RemoveAnimation(sequence);
 }
 
@@ -500,4 +516,15 @@ void LayerAnimator::GetTargetValue(
   }
 }
 
+void LayerAnimator::OnScheduled(LayerAnimationSequence* sequence) {
+  if (observers_.might_have_observers()) {
+    ObserverListBase<LayerAnimationObserver>::Iterator it(observers_);
+    LayerAnimationObserver* obs;
+    while ((obs = it.GetNext()) != NULL) {
+      sequence->AddObserver(obs);
+    }
+  }
+  sequence->OnScheduled();
+}
+
 }  // namespace ui
diff --git a/ui/gfx/compositor/layer_animator.h b/ui/gfx/compositor/layer_animator.h
index e6751ff..4fca4e5 100644
--- a/ui/gfx/compositor/layer_animator.h
+++ b/ui/gfx/compositor/layer_animator.h
@@ -7,10 +7,12 @@
 #pragma once
 
 #include <deque>
+#include <set>
 #include <vector>
 
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/observer_list.h"
 #include "base/time.h"
 #include "ui/base/animation/animation_container_element.h"
 #include "ui/gfx/compositor/compositor_export.h"
@@ -24,7 +26,8 @@ namespace ui {
 class Animation;
 class Layer;
 class LayerAnimationSequence;
-class LayerAnimatorDelegate;
+class LayerAnimationDelegate;
+class LayerAnimationObserver;
 class Transform;
 
 // When a property of layer needs to be changed it is set by way of
@@ -62,7 +65,7 @@ class COMPOSITOR_EXPORT LayerAnimator : public AnimationContainerElement {
 
   // Sets the layer animation delegate the animator is associated with. The
   // animator does not own the delegate.
-  void SetDelegate(LayerAnimatorDelegate* delegate);
+  void SetDelegate(LayerAnimationDelegate* delegate);
 
   // Sets the animation preemption strategy. This determines the behaviour if
   // a property is set during an animation. The default is
@@ -85,18 +88,16 @@ class COMPOSITOR_EXPORT LayerAnimator : public AnimationContainerElement {
   // animation sequences.
   void ScheduleTogether(const std::vector<LayerAnimationSequence*>& animations);
 
-  // These are cover functions that create sequences for you to wrap the given
-  // elements. These sequences are then passed to the corresponding function
-  // above.
-  void StartAnimationElement(LayerAnimationElement* element);
-  void ScheduleAnimationElement(LayerAnimationElement* element);
-  void ScheduleElementsTogether(
-      const std::vector<LayerAnimationElement*>& element);
-
   // Returns true if there is an animation in the queue (animations remain in
-  // the queue until they complete).
+  // the queue until they complete, so this includes running animations).
   bool is_animating() const { return !animation_queue_.empty(); }
 
+  // Returns true if there is an animation in the queue that animates the given
+  // property (animations remain in the queue until they complete, so this
+  // includes running animations).
+  bool IsAnimatingProperty(
+      LayerAnimationElement::AnimatableProperty property) const;
+
   // Stops animating the given property. No effect if there is no running
   // animation for the given property. Skips to the final state of the
   // animation.
@@ -112,6 +113,11 @@ class COMPOSITOR_EXPORT LayerAnimator : public AnimationContainerElement {
   }
   base::TimeTicks get_last_step_time_for_test() { return last_step_time_; }
 
+  // These functions are used for adding or removing observers from the observer
+  // list. The observers are notified when animations end.
+  void AddObserver(LayerAnimationObserver* observer);
+  void RemoveObserver(LayerAnimationObserver* observer);
+
   // Scoped settings allow you to temporarily change the animator's settings and
   // these changes are reverted when the object is destroyed. NOTE: when the
   // settings object is created, it applies the default transition duration
@@ -121,20 +127,22 @@ class COMPOSITOR_EXPORT LayerAnimator : public AnimationContainerElement {
     explicit ScopedSettings(LayerAnimator* animator);
     virtual ~ScopedSettings();
 
+    void AddObserver(LayerAnimationObserver* observer);
     void SetTransitionDuration(base::TimeDelta duration);
 
    private:
     LayerAnimator* animator_;
     base::TimeDelta old_transition_duration_;
+    std::set<LayerAnimationObserver*> observers_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedSettings);
   };
 
  protected:
-  LayerAnimatorDelegate* delegate() { return delegate_; }
+  LayerAnimationDelegate* delegate() { return delegate_; }
 
  private:
-  friend class TransientSettings;
+  friend class ScopedSettings;
 
   // We need to keep track of the start time of every running animation.
   struct RunningAnimation {
@@ -211,11 +219,15 @@ class COMPOSITOR_EXPORT LayerAnimator : public AnimationContainerElement {
   // allowed to finish.
   void GetTargetValue(LayerAnimationElement::TargetValue* target) const;
 
+  // Called whenever an animation is added to the animation queue. Either by
+  // starting the animation or adding to the queue.
+  void OnScheduled(LayerAnimationSequence* sequence);
+
   // This is the queue of animations to run.
   AnimationQueue animation_queue_;
 
   // The target of all layer animations.
-  LayerAnimatorDelegate* delegate_;
+  LayerAnimationDelegate* delegate_;
 
   // The currently running animations.
   RunningAnimations running_animations_;
@@ -236,6 +248,10 @@ class COMPOSITOR_EXPORT LayerAnimator : public AnimationContainerElement {
   // and allows for manual stepping.
   bool disable_timer_for_test_;
 
+  // Observers are notified when layer animations end, are scheduled or are
+  // aborted.
+  ObserverList<LayerAnimationObserver> observers_;
+
   DISALLOW_COPY_AND_ASSIGN(LayerAnimator);
 };
 
diff --git a/ui/gfx/compositor/layer_animator_delegate.h b/ui/gfx/compositor/layer_animator_delegate.h
deleted file mode 100644
index 173584f..0000000
--- a/ui/gfx/compositor/layer_animator_delegate.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) 2011 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.
-
-#ifndef UI_GFX_COMPOSITOR_LAYER_ANIMATOR_DELEGATE_H_
-#define UI_GFX_COMPOSITOR_LAYER_ANIMATOR_DELEGATE_H_
-#pragma once
-
-#include "ui/gfx/rect.h"
-#include "ui/gfx/transform.h"
-#include "ui/gfx/compositor/compositor_export.h"
-#include "ui/gfx/compositor/layer_animation_delegate.h"
-
-namespace ui {
-
-class LayerAnimationSequence;
-
-// Layer animators interact with the layers using this interface.
-class COMPOSITOR_EXPORT LayerAnimatorDelegate : public LayerAnimationDelegate {
- public:
-  // Called when the |sequence| ends. Not called if |sequence| is aborted.
-  virtual void OnLayerAnimationEnded(LayerAnimationSequence* sequence) = 0;
-
-  // if this becomes necessary, this would be the appropriate place to add
-  // notifications about elements starting or ending, or sequences starting.
-
- protected:
-  virtual ~LayerAnimatorDelegate() {}
-};
-
-}  // namespace ui
-
-#endif  // UI_GFX_COMPOSITOR_LAYER_ANIMATOR_DELEGATE_H_
diff --git a/ui/gfx/compositor/layer_animator_unittest.cc b/ui/gfx/compositor/layer_animator_unittest.cc
index e92d7c5..7d957cf 100644
--- a/ui/gfx/compositor/layer_animator_unittest.cc
+++ b/ui/gfx/compositor/layer_animator_unittest.cc
@@ -11,10 +11,11 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
-#include "ui/gfx/compositor/dummy_layer_animation_delegate.h"
 #include "ui/gfx/compositor/layer_animation_delegate.h"
 #include "ui/gfx/compositor/layer_animation_element.h"
 #include "ui/gfx/compositor/layer_animation_sequence.h"
+#include "ui/gfx/compositor/test_layer_animation_delegate.h"
+#include "ui/gfx/compositor/test_layer_animation_observer.h"
 #include "ui/gfx/compositor/test_utils.h"
 
 namespace ui {
@@ -27,7 +28,7 @@ TEST(LayerAnimatorTest, ImplicitAnimation) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateImplicitAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
   base::TimeTicks now = base::TimeTicks::Now();
   animator->SetOpacity(0.5);
@@ -41,7 +42,7 @@ TEST(LayerAnimatorTest, ImplicitAnimation) {
 TEST(LayerAnimatorTest, NoImplicitAnimation) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
   base::TimeTicks now = base::TimeTicks::Now();
   animator->SetOpacity(0.5);
@@ -54,7 +55,7 @@ TEST(LayerAnimatorTest, NoImplicitAnimation) {
 TEST(LayerAnimatorTest, StopAnimatingProperty) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateImplicitAnimator());
   animator->set_disable_timer_for_test(true);
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
   base::TimeTicks now = base::TimeTicks::Now();
   double target_opacity(0.5);
@@ -74,7 +75,7 @@ TEST(LayerAnimatorTest, StopAnimatingProperty) {
 TEST(LayerAnimatorTest, StopAnimating) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateImplicitAnimator());
   animator->set_disable_timer_for_test(true);
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
   base::TimeTicks now = base::TimeTicks::Now();
   double target_opacity(0.5);
@@ -94,7 +95,7 @@ TEST(LayerAnimatorTest, ScheduleAnimationThatCanRunImmediately) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_opacity(0.0);
@@ -131,7 +132,7 @@ TEST(LayerAnimatorTest, ScheduleTwoAnimationsThatCanRunImmediately) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_opacity(0.0);
@@ -181,7 +182,7 @@ TEST(LayerAnimatorTest, ScheduleTwoAnimationsOnSameProperty) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_opacity(0.0);
@@ -233,7 +234,7 @@ TEST(LayerAnimatorTest, ScheduleBlockedAnimation) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_opacity(0.0);
@@ -311,7 +312,7 @@ TEST(LayerAnimatorTest, ScheduleTogether) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_opacity(0.0);
@@ -364,7 +365,7 @@ TEST(LayerAnimatorTest, StartAnimationThatCanRunImmediately) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_opacity(0.0);
@@ -399,7 +400,7 @@ TEST(LayerAnimatorTest, StartAnimationThatCanRunImmediately) {
 TEST(LayerAnimatorTest, PreemptBySettingNewTarget) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_opacity(0.0);
@@ -428,7 +429,7 @@ TEST(LayerAnimatorTest, PreemptByImmediatelyAnimatingToNewTarget) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_opacity(0.0);
@@ -480,7 +481,7 @@ TEST(LayerAnimatorTest, PreemptEnqueueNewAnimation) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_opacity(0.0);
@@ -533,7 +534,7 @@ TEST(LayerAnimatorTest, PreemptyByReplacingQueuedAnimations) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_opacity(0.0);
@@ -588,7 +589,7 @@ TEST(LayerAnimatorTest, CyclicSequences) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
-  DummyLayerAnimationDelegate delegate;
+  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_opacity(0.0);
@@ -643,6 +644,84 @@ TEST(LayerAnimatorTest, CyclicSequences) {
   EXPECT_FALSE(animator->is_animating());
 }
 
+TEST(LayerAnimatorTest, AddObserverExplicit) {
+  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  AnimationContainerElement* element = animator.get();
+  animator->set_disable_timer_for_test(true);
+  TestLayerAnimationObserver observer;
+  TestLayerAnimationDelegate delegate;
+  animator->SetDelegate(&delegate);
+  animator->AddObserver(&observer);
+
+  EXPECT_TRUE(!observer.last_ended_sequence());
+
+  base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
+
+  delegate.SetOpacityFromAnimation(0.0f);
+
+  LayerAnimationSequence* sequence = new LayerAnimationSequence(
+      LayerAnimationElement::CreateOpacityElement(1.0f, delta));
+
+  animator->StartAnimation(sequence);
+
+  EXPECT_EQ(observer.last_scheduled_sequence(), sequence);
+
+  base::TimeTicks start_time = animator->get_last_step_time_for_test();
+
+  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+
+  EXPECT_EQ(observer.last_ended_sequence(), sequence);
+
+  // |sequence| has been destroyed. Recreate it to test abort.
+  sequence = new LayerAnimationSequence(
+      LayerAnimationElement::CreateOpacityElement(1.0f, delta));
+
+  animator->StartAnimation(sequence);
+
+  animator.reset();
+
+  EXPECT_EQ(observer.last_aborted_sequence(), sequence);
+}
+
+TEST(LayerAnimatorTest, AddObserverImplicit) {
+  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  AnimationContainerElement* element = animator.get();
+  animator->set_disable_timer_for_test(true);
+  TestLayerAnimationObserver observer;
+  TestLayerAnimationDelegate delegate;
+  animator->SetDelegate(&delegate);
+  animator->AddObserver(&observer);
+
+  // Should not end a sequence with the default animator.
+  EXPECT_TRUE(!observer.last_ended_sequence());
+  animator->SetOpacity(1.0f);
+  base::TimeTicks start_time = base::TimeTicks::Now();
+  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  EXPECT_TRUE(!observer.last_ended_sequence());
+
+  TestLayerAnimationObserver scoped_observer;
+  {
+    LayerAnimator::ScopedSettings settings(animator.get());
+    settings.AddObserver(&scoped_observer);
+    for (int i = 0; i < 2; ++i) {
+      // reset the observer
+      scoped_observer = TestLayerAnimationObserver();
+      EXPECT_TRUE(!scoped_observer.last_ended_sequence());
+      animator->SetOpacity(1.0f);
+      start_time = animator->get_last_step_time_for_test();
+      element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+      EXPECT_FALSE(!scoped_observer.last_ended_sequence());
+    }
+  }
+
+  scoped_observer = TestLayerAnimationObserver();
+  EXPECT_TRUE(!scoped_observer.last_ended_sequence());
+  animator->SetOpacity(1.0f);
+  start_time = base::TimeTicks::Now();
+  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  EXPECT_TRUE(!scoped_observer.last_ended_sequence());
+}
+
 } // namespace
 
 } // namespace ui
diff --git a/ui/gfx/compositor/layer_delegate.h b/ui/gfx/compositor/layer_delegate.h
index 474689e..1f494b1 100644
--- a/ui/gfx/compositor/layer_delegate.h
+++ b/ui/gfx/compositor/layer_delegate.h
@@ -14,8 +14,6 @@ class Canvas;
 
 namespace ui {
 
-class LayerAnimationSequence;
-
 // A delegate interface implemented by an object that renders to a Layer.
 class COMPOSITOR_EXPORT LayerDelegate {
  public:
@@ -23,9 +21,6 @@ class COMPOSITOR_EXPORT LayerDelegate {
   // clipped to the Layer's invalid rect.
   virtual void OnPaintLayer(gfx::Canvas* canvas) = 0;
 
-  // Called when |seq| ends.
-  virtual void OnLayerAnimationEnded(const LayerAnimationSequence* seq) = 0;
-
  protected:
   virtual ~LayerDelegate() {}
 };
diff --git a/ui/gfx/compositor/layer_unittest.cc b/ui/gfx/compositor/layer_unittest.cc
index 1839cbe..fceb9c6 100644
--- a/ui/gfx/compositor/layer_unittest.cc
+++ b/ui/gfx/compositor/layer_unittest.cc
@@ -42,10 +42,6 @@ class ColoredLayer : public Layer, public LayerDelegate {
     canvas->GetSkCanvas()->drawColor(color_);
   }
 
-  virtual void OnLayerAnimationEnded(
-      const LayerAnimationSequence* animation) OVERRIDE {
-  }
-
  private:
   SkColor color_;
 };
@@ -131,9 +127,6 @@ class TestLayerDelegate : public LayerDelegate {
                      gfx::Rect(gfx::Point(), paint_size_));
     color_index_ = (color_index_ + 1) % static_cast<int>(colors_.size());
   }
-  virtual void OnLayerAnimationEnded(
-      const LayerAnimationSequence* animation) OVERRIDE {
-  }
 
  private:
   std::vector<SkColor> colors_;
@@ -160,9 +153,6 @@ class DrawTreeLayerDelegate : public LayerDelegate {
   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
     painted_ = true;
   }
-  virtual void OnLayerAnimationEnded(
-      const LayerAnimationSequence* animation) OVERRIDE {
-  }
 
   bool painted_;
 
@@ -179,9 +169,6 @@ class NullLayerDelegate : public LayerDelegate {
   // Overridden from LayerDelegate:
   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
   }
-  virtual void OnLayerAnimationEnded(
-      const LayerAnimationSequence* animation) OVERRIDE {
-  }
 
   DISALLOW_COPY_AND_ASSIGN(NullLayerDelegate);
 };
diff --git a/ui/gfx/compositor/test_layer_animation_delegate.cc b/ui/gfx/compositor/test_layer_animation_delegate.cc
new file mode 100644
index 0000000..a7aa124
--- /dev/null
+++ b/ui/gfx/compositor/test_layer_animation_delegate.cc
@@ -0,0 +1,51 @@
+// Copyright (c) 2011 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 "ui/gfx/compositor/test_layer_animation_delegate.h"
+
+namespace ui {
+
+TestLayerAnimationDelegate::TestLayerAnimationDelegate() : opacity_(1.0f) {
+}
+
+TestLayerAnimationDelegate::TestLayerAnimationDelegate(
+    const LayerAnimationDelegate& other)
+    : bounds_(other.GetBoundsForAnimation()),
+      transform_(other.GetTransformForAnimation()),
+      opacity_(other.GetOpacityForAnimation()) {
+}
+
+TestLayerAnimationDelegate::~TestLayerAnimationDelegate() {
+}
+
+void TestLayerAnimationDelegate::SetBoundsFromAnimation(
+    const gfx::Rect& bounds) {
+  bounds_ = bounds;
+}
+
+void TestLayerAnimationDelegate::SetTransformFromAnimation(
+    const Transform& transform) {
+  transform_ = transform;
+}
+
+void TestLayerAnimationDelegate::SetOpacityFromAnimation(float opacity) {
+  opacity_ = opacity;
+}
+
+void TestLayerAnimationDelegate::ScheduleDrawForAnimation() {
+}
+
+const gfx::Rect& TestLayerAnimationDelegate::GetBoundsForAnimation() const {
+  return bounds_;
+}
+
+const Transform& TestLayerAnimationDelegate::GetTransformForAnimation() const {
+  return transform_;
+}
+
+float TestLayerAnimationDelegate::GetOpacityForAnimation() const {
+  return opacity_;
+}
+
+}  // namespace ui
diff --git a/ui/gfx/compositor/dummy_layer_animation_delegate.h b/ui/gfx/compositor/test_layer_animation_delegate.h
index 69b6435..c75d2b1 100644
--- a/ui/gfx/compositor/dummy_layer_animation_delegate.h
+++ b/ui/gfx/compositor/test_layer_animation_delegate.h
@@ -2,26 +2,26 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef UI_GFX_COMPOSITOR_DUMMY_LAYER_ANIMATION_DELEGATE_H_
-#define UI_GFX_COMPOSITOR_DUMMY_LAYER_ANIMATION_DELEGATE_H_
+#ifndef UI_GFX_COMPOSITOR_TEST_LAYER_ANIMATION_DELEGATE_H_
+#define UI_GFX_COMPOSITOR_TEST_LAYER_ANIMATION_DELEGATE_H_
 #pragma once
 
 #include "base/compiler_specific.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/compositor/compositor_export.h"
-#include "ui/gfx/compositor/layer_animator_delegate.h"
+#include "ui/gfx/compositor/layer_animation_delegate.h"
 
 namespace ui {
 
 class LayerAnimationSequence;
 
-class COMPOSITOR_EXPORT DummyLayerAnimationDelegate
-    : public LayerAnimatorDelegate {
+class COMPOSITOR_EXPORT TestLayerAnimationDelegate
+    : public LayerAnimationDelegate {
  public:
-  DummyLayerAnimationDelegate();
-  DummyLayerAnimationDelegate(const LayerAnimationDelegate& other);
-  virtual ~DummyLayerAnimationDelegate();
+  TestLayerAnimationDelegate();
+  TestLayerAnimationDelegate(const LayerAnimationDelegate& other);
+  virtual ~TestLayerAnimationDelegate();
 
   // Implementation of LayerAnimationDelegate
   virtual void SetBoundsFromAnimation(const gfx::Rect& bounds) OVERRIDE;
@@ -32,9 +32,6 @@ class COMPOSITOR_EXPORT DummyLayerAnimationDelegate
   virtual const Transform& GetTransformForAnimation() const OVERRIDE;
   virtual float GetOpacityForAnimation() const OVERRIDE;
 
-  // Implementation of LayerAnimatorDelegate
-  virtual void OnLayerAnimationEnded(LayerAnimationSequence* sequence) OVERRIDE;
-
  private:
   gfx::Rect bounds_;
   Transform transform_;
@@ -45,4 +42,4 @@ class COMPOSITOR_EXPORT DummyLayerAnimationDelegate
 
 }  // namespace ui
 
-#endif  // UI_GFX_COMPOSITOR_DUMMY_LAYER_ANIMATION_DELEGATE_H_
+#endif  // UI_GFX_COMPOSITOR_TEST_LAYER_ANIMATION_DELEGATE_H_
diff --git a/ui/gfx/compositor/test_layer_animation_observer.cc b/ui/gfx/compositor/test_layer_animation_observer.cc
new file mode 100644
index 0000000..505d528
--- /dev/null
+++ b/ui/gfx/compositor/test_layer_animation_observer.cc
@@ -0,0 +1,35 @@
+// Copyright (c) 2011 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 "ui/gfx/compositor/test_layer_animation_observer.h"
+
+#include <cstddef>
+
+namespace ui {
+
+TestLayerAnimationObserver::TestLayerAnimationObserver()
+    : last_ended_sequence_(NULL),
+      last_scheduled_sequence_(NULL),
+      last_aborted_sequence_(NULL) {
+}
+
+TestLayerAnimationObserver::~TestLayerAnimationObserver() {
+}
+
+void TestLayerAnimationObserver::OnLayerAnimationEnded(
+    const LayerAnimationSequence* sequence) {
+  last_ended_sequence_ = sequence;
+}
+
+void TestLayerAnimationObserver::OnLayerAnimationScheduled(
+    const LayerAnimationSequence* sequence) {
+  last_scheduled_sequence_ = sequence;
+}
+
+void TestLayerAnimationObserver::OnLayerAnimationAborted(
+    const LayerAnimationSequence* sequence) {
+  last_aborted_sequence_ = sequence;
+}
+
+}  // namespace ui
diff --git a/ui/gfx/compositor/test_layer_animation_observer.h b/ui/gfx/compositor/test_layer_animation_observer.h
new file mode 100644
index 0000000..879c74b
--- /dev/null
+++ b/ui/gfx/compositor/test_layer_animation_observer.h
@@ -0,0 +1,57 @@
+// Copyright (c) 2011 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.
+
+#ifndef UI_GFX_COMPOSITOR_TEST_LAYER_ANIMATION_OBSERVER_
+#define UI_GFX_COMPOSITOR_TEST_LAYER_ANIMATION_OBSERVER_
+#pragma once
+
+#include "base/compiler_specific.h"
+#include "ui/gfx/compositor/compositor_export.h"
+#include "ui/gfx/compositor/layer_animation_observer.h"
+
+namespace ui {
+
+class LayerAnimationSequence;
+
+// Listens to animation ended notifications. Remembers the last sequence that
+// it was notified about.
+class COMPOSITOR_EXPORT TestLayerAnimationObserver
+    : public LayerAnimationObserver {
+ public:
+  TestLayerAnimationObserver();
+  virtual ~TestLayerAnimationObserver();
+
+  virtual void OnLayerAnimationEnded(
+      const LayerAnimationSequence* sequence) OVERRIDE;
+
+  virtual void OnLayerAnimationAborted(
+      const LayerAnimationSequence* sequence) OVERRIDE;
+
+  virtual void OnLayerAnimationScheduled(
+      const LayerAnimationSequence* sequence) OVERRIDE;
+
+
+  const LayerAnimationSequence* last_ended_sequence() const {
+    return last_ended_sequence_;
+  }
+
+  const LayerAnimationSequence* last_scheduled_sequence() const {
+    return last_scheduled_sequence_;
+  }
+
+  const LayerAnimationSequence* last_aborted_sequence() const {
+    return last_aborted_sequence_;
+  }
+
+ private:
+  const LayerAnimationSequence* last_ended_sequence_;
+  const LayerAnimationSequence* last_scheduled_sequence_;
+  const LayerAnimationSequence* last_aborted_sequence_;
+
+  // Copy and assign are allowed.
+};
+
+}  // namespace ui
+
+#endif  // UI_GFX_COMPOSITOR_TEST_LAYER_ANIMATION_OBSERVER_