Allows observers to be notified when layer animations complete.

ui/gfx/compositor/layer_animation_sequence.cc

 // 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/layer_animation_sequence.h"
 
 #include <algorithm>
 #include <iterator>
 
 #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 {
 
 LayerAnimationSequence::LayerAnimationSequence()
     : is_cyclic_(false),
       last_element_(0) {
 }
 
 LayerAnimationSequence::LayerAnimationSequence(LayerAnimationElement* element)
     : is_cyclic_(false),
@@ skipping 35 matching lines @@
     if (elements_[current_index]->duration() > base::TimeDelta()) {
       t = (elapsed - last_start_).InMillisecondsF() /
           elements_[current_index]->duration().InMillisecondsF();
     }
     elements_[current_index]->Progress(t, delegate);
   }
 
   if (!is_cyclic_ && elapsed == duration_) {
     last_element_ = 0;
     last_start_ = base::TimeDelta::FromMilliseconds(0);
+    NotifyEnded();
   }
 }
 
 void LayerAnimationSequence::GetTargetValue(
     LayerAnimationElement::TargetValue* target) const {
   if (is_cyclic_)
     return;
 
   for (size_t i = last_element_; i < elements_.size(); ++i)
     elements_[i]->GetTargetValue(target);
 }
 
 void LayerAnimationSequence::Abort() {
   size_t current_index = last_element_ % elements_.size();
   while (current_index < elements_.size()) {
     elements_[current_index]->Abort();
     ++current_index;
   }
   last_element_ = 0;
   last_start_ = base::TimeDelta::FromMilliseconds(0);
+  NotifyAborted();
 }
 
 void LayerAnimationSequence::AddElement(LayerAnimationElement* element) {
   // Update duration and properties.
   duration_ += element->duration();
   properties_.insert(element->properties().begin(),
                      element->properties().end());
   elements_.push_back(make_linked_ptr(element));
 }
 
 bool LayerAnimationSequence::HasCommonProperty(
     const LayerAnimationElement::AnimatableProperties& other) const {
   LayerAnimationElement::AnimatableProperties intersection;
   std::insert_iterator<LayerAnimationElement::AnimatableProperties> ii(
       intersection, intersection.begin());
   std::set_intersection(properties_.begin(), properties_.end(),
                         other.begin(), other.end(),
                         ii);
   return intersection.size() > 0;
 }
 
+void LayerAnimationSequence::AddObserver(LayerAnimationObserver* observer) {
+  if (!observers_.HasObserver(observer))

[sky, 2011/10/28 22:11:38]

Don't do this, there's a DCHECK that you don't add an observer twice in
observer_list.

+    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