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),
+      animation_group_id_(0),
+      last_progressed_fraction_(0.0) {
 }
 
 LayerAnimationSequence::LayerAnimationSequence(LayerAnimationElement* element)

[sky, 2013/02/19 17:06:56]

Can we get rid of this and only have one constructor?

[ajuma, 2013/02/20 16:09:10]

Constructing a one-element sequence seems common enough that I think it's worth
keeping this constructor (there are several existing callers of this constructor
scattered across ui/ and ash/). If you feel strongly about removing this
constructor, how about I do this in a separate CL (either a follow-up or one
that lands before this one, whichever you prefer)?

     : is_cyclic_(false),
-      last_element_(0) {
+      last_element_(0),
+      waiting_for_group_start_(false),
+      animation_group_id_(0),
+      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_);

[sky, 2013/02/19 17:06:56]

How come this is only done for the first element?

[ajuma, 2013/02/20 16:09:10]

To avoid making an extra pass over the sequence, this is set when starting each
element. To make this more clear, this is now being passed as an argument to
LayerAnimationElement::Start().

+  elements_[0]->ProgressToEffectiveStart(delegate);
+}
+
 void LayerAnimationSequence::Progress(base::TimeTicks now,
                                       LayerAnimationDelegate* delegate) {
+  DCHECK(start_time_ != base::TimeTicks());

[sky, 2013/02/19 17:06:56]

DCHECK_NE

[ajuma, 2013/02/20 16:09:10]

This won't compile, since values passed to DCHECK_NE need to have
operator<<(ostream, ...) defined (this is used when logging failures), but
base::TimeTicks doesn't define this.

   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_ =

[sky, 2013/02/19 17:06:56]

Should this be reset early on to make sure it it set to 0?

[ajuma, 2013/02/20 16:09:10]

Done. This is now reset in ::Start.

+        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;
+    animation_group_id_ = 0;
     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;
+    animation_group_id_ = 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() {
+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));
 }
 
 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