Thread ui opacity animations

ui/compositor/layer_animation_sequence.cc

 // 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.
 
 #include "ui/compositor/layer_animation_sequence.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/debug/trace_event.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animation_element.h"
 #include "ui/compositor/layer_animation_observer.h"
 
 namespace ui {
 
 LayerAnimationSequence::LayerAnimationSequence()
     : is_cyclic_(false),
-      last_element_(0) {
+      last_element_(0),
+      waiting_for_group_start_(false),
+      last_progressed_fraction_(0.0) {
 }
 
 LayerAnimationSequence::LayerAnimationSequence(LayerAnimationElement* element)
     : is_cyclic_(false),
-      last_element_(0) {
+      last_element_(0),
+      waiting_for_group_start_(false),
+      last_progressed_fraction_(0.0) {
   AddElement(element);
 }
 
 LayerAnimationSequence::~LayerAnimationSequence() {
   FOR_EACH_OBSERVER(LayerAnimationObserver,
                     observers_,
                     DetachedFromSequence(this, true));
 }
 
+void LayerAnimationSequence::ProgressToEffectiveStart(
+    LayerAnimationDelegate* delegate) {
+  if (elements_.empty())
+    return;
+
+  elements_[0]->set_animation_group_id(animation_group_id_);
+  elements_[0]->ProgressToEffectiveStart(delegate);
+}
+
 void LayerAnimationSequence::Progress(base::TimeTicks now,
                                       LayerAnimationDelegate* delegate) {

[Ian Vollick, 2013/02/13 03:59:38]

If we're waiting for group start, do we need to progress at all?

[ajuma, 2013/02/13 23:28:18]

No, in this case, we shouldn't even call Progress since having a start time set
is a prerequisite for calling Progress (and, indeed, LayerAnimator doesn't call
Progress on sequences waiting for a group start).

I've added a DCHECK here that we do have a start time.

   bool redraw_required = false;
 
   if (elements_.empty())
     return;
 
   if (last_element_ == 0)
     last_start_ = start_time_;
 
   size_t current_index = last_element_ % elements_.size();
   base::TimeDelta element_duration;
   while (is_cyclic_ || last_element_ < elements_.size()) {
-    elements_[current_index]->set_start_time(last_start_);
+    elements_[current_index]->set_requested_start_time(last_start_);
+    elements_[current_index]->set_animation_group_id(animation_group_id_);
     if (!elements_[current_index]->IsFinished(now, &element_duration))
       break;
 
     // Let the element we're passing finish.
     if (elements_[current_index]->Progress(now, delegate))
       redraw_required = true;
     last_start_ += element_duration;
     ++last_element_;
+    last_progressed_fraction_ =
+        elements_[current_index]->last_progressed_fraction();
     current_index = last_element_ % elements_.size();
   }
 
   if (is_cyclic_ || last_element_ < elements_.size()) {
     if (elements_[current_index]->Progress(now, delegate))
       redraw_required = true;
+    last_progressed_fraction_ =
+        elements_[current_index]->last_progressed_fraction();
   }
 
   // Since the delegate may be deleted due to the notifications below, it is
   // important that we schedule a draw before sending them.
   if (redraw_required)
     delegate->ScheduleDrawForAnimation();
 
   if (!is_cyclic_ && last_element_ == elements_.size()) {
     last_element_ = 0;
+    waiting_for_group_start_ = false;
     NotifyEnded();
   }
 }
 
 bool LayerAnimationSequence::IsFinished(base::TimeTicks time) {
-  if (is_cyclic_)
+  if (is_cyclic_ || waiting_for_group_start_)
     return false;
 
   if (elements_.empty())
     return true;
 
   if (last_element_ == 0)
     last_start_ = start_time_;
 
   base::TimeTicks current_start = last_start_;
   size_t current_index = last_element_;
   base::TimeDelta element_duration;
   while (current_index < elements_.size()) {
-    elements_[current_index]->set_start_time(current_start);
+    elements_[current_index]->set_requested_start_time(current_start);
     if (!elements_[current_index]->IsFinished(time, &element_duration))
       break;
 
     current_start += element_duration;
     ++current_index;
   }
 
   return (current_index == elements_.size());
 }
 
 void LayerAnimationSequence::ProgressToEnd(LayerAnimationDelegate* delegate) {
   bool redraw_required = false;
 
   if (elements_.empty())
     return;
 
   size_t current_index = last_element_ % elements_.size();
   while (current_index < elements_.size()) {
     if (elements_[current_index]->ProgressToEnd(delegate))
       redraw_required = true;
+    last_progressed_fraction_ =
+        elements_[current_index]->last_progressed_fraction();
     ++current_index;
     ++last_element_;
   }
 
   if (redraw_required)
     delegate->ScheduleDrawForAnimation();
 
   if (!is_cyclic_) {
     last_element_ = 0;
+    waiting_for_group_start_ = false;
     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() {
+void LayerAnimationSequence::Abort(LayerAnimationDelegate* delegate) {
   size_t current_index = last_element_ % elements_.size();
   while (current_index < elements_.size()) {
-    elements_[current_index]->Abort();
+    elements_[current_index]->Abort(delegate);
     ++current_index;
   }
   last_element_ = 0;
+  waiting_for_group_start_ = false;
   NotifyAborted();
 }
 
 void LayerAnimationSequence::AddElement(LayerAnimationElement* element) {
   properties_.insert(element->properties().begin(),
                      element->properties().end());
   elements_.push_back(make_linked_ptr(element));

[Ian Vollick, 2013/02/13 03:59:38]

Since we early out in LayerAnimation::OnThreadedAnimationStarted if we're not
waiting for group start, should we maybe set waiting_for_group_start_ to true
here if the first element is threaded?

[ajuma, 2013/02/13 23:28:18]

Only sequences started by LayerAnimator::ScheduleTogether or
LayerAnimator::StartTogether need to wait for a group start (whenever the group
contains at least one sequence whose first element is threaded). The early out
in OnThreadedAnimationStarted just prevents notifying the other sequences in the
same group, which makes sense when there aren't actually any other sequences in
the group since the group has size 1.

 }
 
 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;
 }
 
+bool LayerAnimationSequence::IsFirstElementThreaded() const {
+  if (!elements_.empty())
+    return elements_[0]->IsThreaded();
+
+  return false;
+}
+
 void LayerAnimationSequence::AddObserver(LayerAnimationObserver* observer) {
   if (!observers_.HasObserver(observer)) {
     observers_.AddObserver(observer);
     observer->AttachedToSequence(this);
   }
 }
 
 void LayerAnimationSequence::RemoveObserver(LayerAnimationObserver* observer) {
   observers_.RemoveObserver(observer);
   observer->DetachedFromSequence(this, true);
 }
 
+void LayerAnimationSequence::OnThreadedAnimationStarted(
+    const cc::AnimationEvent& event) {
+  if (elements_.empty() || event.groupId != animation_group_id_)
+    return;
+
+  size_t current_index = last_element_ % elements_.size();
+  const LayerAnimationElement::AnimatableProperties& element_properties =
+    elements_[current_index]->properties();
+  LayerAnimationElement::AnimatableProperty event_property =
+      LayerAnimationElement::ToAnimatableProperty(event.targetProperty);
+  DCHECK(element_properties.find(event_property) != element_properties.end());
+  elements_[current_index]->set_effective_start_time(
+      base::TimeTicks::FromInternalValue(
+          event.monotonicTime * base::Time::kMicrosecondsPerSecond));
+}
+
 void LayerAnimationSequence::OnScheduled() {
   NotifyScheduled();
 }
 
 void LayerAnimationSequence::OnAnimatorDestroyed() {
   if (observers_.might_have_observers()) {
     ObserverListBase<LayerAnimationObserver>::Iterator it(observers_);
     LayerAnimationObserver* obs;
     while ((obs = it.GetNext()) != NULL) {
       if (!obs->RequiresNotificationWhenAnimatorDestroyed()) {
@@ skipping 17 matching lines @@
                     OnLayerAnimationEnded(this));
 }
 
 void LayerAnimationSequence::NotifyAborted() {
   FOR_EACH_OBSERVER(LayerAnimationObserver,
                     observers_,
                     OnLayerAnimationAborted(this));
 }
 
 }  // namespace ui