ui/compositor/layer_animation_sequence.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/compositor/layer_animation_sequence.h"
   6
   7 #include <algorithm>
   8 #include <iterator>
   9
  10 #include "base/trace_event/trace_event.h"
  11 #include "cc/animation/animation_id_provider.h"
  12 #include "ui/compositor/layer_animation_delegate.h"
  13 #include "ui/compositor/layer_animation_element.h"
  14 #include "ui/compositor/layer_animation_observer.h"
  15
  16 namespace ui {
  17
  18 LayerAnimationSequence::LayerAnimationSequence()
  19     : properties_(LayerAnimationElement::UNKNOWN),
  20       is_cyclic_(false),
  21       last_element_(0),
  22       waiting_for_group_start_(false),
  23       animation_group_id_(0),
  24       last_progressed_fraction_(0.0),
  25       weak_ptr_factory_(this) {
  26 }
  27
  28 LayerAnimationSequence::LayerAnimationSequence(LayerAnimationElement* element)
  29     : properties_(LayerAnimationElement::UNKNOWN),
  30       is_cyclic_(false),
  31       last_element_(0),
  32       waiting_for_group_start_(false),
  33       animation_group_id_(0),
  34       last_progressed_fraction_(0.0),
  35       weak_ptr_factory_(this) {
  36   AddElement(element);
  37 }
  38
  39 LayerAnimationSequence::~LayerAnimationSequence() {
  40   FOR_EACH_OBSERVER(LayerAnimationObserver,
  41                     observers_,
  42                     DetachedFromSequence(this, true));
  43 }
  44
  45 void LayerAnimationSequence::Start(LayerAnimationDelegate* delegate) {
  46   DCHECK(start_time_ != base::TimeTicks());
  47   last_progressed_fraction_ = 0.0;
  48   if (elements_.empty())
  49     return;
  50
  51   elements_[0]->set_requested_start_time(start_time_);
  52   elements_[0]->Start(delegate, animation_group_id_);
  53 }
  54
  55 void LayerAnimationSequence::Progress(base::TimeTicks now,
  56                                       LayerAnimationDelegate* delegate) {
  57   DCHECK(start_time_ != base::TimeTicks());
  58   bool redraw_required = false;
  59
  60   if (elements_.empty())
  61     return;
  62
  63   if (last_element_ == 0)
  64     last_start_ = start_time_;
  65
  66   size_t current_index = last_element_ % elements_.size();
  67   base::TimeDelta element_duration;
  68   while (is_cyclic_ || last_element_ < elements_.size()) {
  69     elements_[current_index]->set_requested_start_time(last_start_);
  70     if (!elements_[current_index]->IsFinished(now, &element_duration))
  71       break;
  72
  73     // Let the element we're passing finish.
  74     if (elements_[current_index]->ProgressToEnd(delegate))
  75       redraw_required = true;
  76     last_start_ += element_duration;
  77     ++last_element_;
  78     last_progressed_fraction_ =
  79         elements_[current_index]->last_progressed_fraction();
  80     current_index = last_element_ % elements_.size();
  81   }
  82
  83   if (is_cyclic_ || last_element_ < elements_.size()) {
  84     if (!elements_[current_index]->Started()) {
  85       animation_group_id_ = cc::AnimationIdProvider::NextGroupId();
  86       elements_[current_index]->Start(delegate, animation_group_id_);
  87     }
  88     base::WeakPtr<LayerAnimationSequence> alive(weak_ptr_factory_.GetWeakPtr());
  89     if (elements_[current_index]->Progress(now, delegate))
  90       redraw_required = true;
  91     if (!alive)
  92       return;
  93     last_progressed_fraction_ =
  94         elements_[current_index]->last_progressed_fraction();
  95   }
  96
  97   // Since the delegate may be deleted due to the notifications below, it is
  98   // important that we schedule a draw before sending them.
  99   if (redraw_required)
 100     delegate->ScheduleDrawForAnimation();
 101
 102   if (!is_cyclic_ && last_element_ == elements_.size()) {
 103     last_element_ = 0;
 104     waiting_for_group_start_ = false;
 105     animation_group_id_ = 0;
 106     NotifyEnded();
 107   }
 108 }
 109
 110 bool LayerAnimationSequence::IsFinished(base::TimeTicks time) {
 111   if (is_cyclic_ || waiting_for_group_start_)
 112     return false;
 113
 114   if (elements_.empty())
 115     return true;
 116
 117   if (last_element_ == 0)
 118     last_start_ = start_time_;
 119
 120   base::TimeTicks current_start = last_start_;
 121   size_t current_index = last_element_;
 122   base::TimeDelta element_duration;
 123   while (current_index < elements_.size()) {
 124     elements_[current_index]->set_requested_start_time(current_start);
 125     if (!elements_[current_index]->IsFinished(time, &element_duration))
 126       break;
 127
 128     current_start += element_duration;
 129     ++current_index;
 130   }
 131
 132   return (current_index == elements_.size());
 133 }
 134
 135 void LayerAnimationSequence::ProgressToEnd(LayerAnimationDelegate* delegate) {
 136   bool redraw_required = false;
 137
 138   if (elements_.empty())
 139     return;
 140
 141   size_t current_index = last_element_ % elements_.size();
 142   while (current_index < elements_.size()) {
 143     if (elements_[current_index]->ProgressToEnd(delegate))
 144       redraw_required = true;
 145     last_progressed_fraction_ =
 146         elements_[current_index]->last_progressed_fraction();
 147     ++current_index;
 148     ++last_element_;
 149   }
 150
 151   if (redraw_required)
 152     delegate->ScheduleDrawForAnimation();
 153
 154   if (!is_cyclic_) {
 155     last_element_ = 0;
 156     waiting_for_group_start_ = false;
 157     animation_group_id_ = 0;
 158     NotifyEnded();
 159   }
 160 }
 161
 162 void LayerAnimationSequence::GetTargetValue(
 163     LayerAnimationElement::TargetValue* target) const {
 164   if (is_cyclic_)
 165     return;
 166
 167   for (size_t i = last_element_; i < elements_.size(); ++i)
 168     elements_[i]->GetTargetValue(target);
 169 }
 170
 171 void LayerAnimationSequence::Abort(LayerAnimationDelegate* delegate) {
 172   size_t current_index = last_element_ % elements_.size();
 173   while (current_index < elements_.size()) {
 174     elements_[current_index]->Abort(delegate);
 175     ++current_index;
 176   }
 177   last_element_ = 0;
 178   waiting_for_group_start_ = false;
 179   NotifyAborted();
 180 }
 181
 182 void LayerAnimationSequence::AddElement(LayerAnimationElement* element) {
 183   properties_ |= element->properties();
 184   elements_.push_back(make_linked_ptr(element));
 185 }
 186
 187 bool LayerAnimationSequence::HasConflictingProperty(
 188     LayerAnimationElement::AnimatableProperties other) const {
 189   return (properties_ & other) != LayerAnimationElement::UNKNOWN;
 190 }
 191
 192 bool LayerAnimationSequence::IsFirstElementThreaded() const {
 193   if (!elements_.empty())
 194     return elements_[0]->IsThreaded();
 195
 196   return false;
 197 }
 198
 199 void LayerAnimationSequence::AddObserver(LayerAnimationObserver* observer) {
 200   if (!observers_.HasObserver(observer)) {
 201     observers_.AddObserver(observer);
 202     observer->AttachedToSequence(this);
 203   }
 204 }
 205
 206 void LayerAnimationSequence::RemoveObserver(LayerAnimationObserver* observer) {
 207   observers_.RemoveObserver(observer);
 208   observer->DetachedFromSequence(this, true);
 209 }
 210
 211 void LayerAnimationSequence::OnThreadedAnimationStarted(
 212     const cc::AnimationEvent& event) {
 213   if (elements_.empty() || event.group_id != animation_group_id_)
 214     return;
 215
 216   size_t current_index = last_element_ % elements_.size();
 217   LayerAnimationElement::AnimatableProperties element_properties =
 218     elements_[current_index]->properties();
 219   LayerAnimationElement::AnimatableProperty event_property =
 220       LayerAnimationElement::ToAnimatableProperty(event.target_property);
 221   DCHECK(element_properties & event_property);
 222   elements_[current_index]->set_effective_start_time(event.monotonic_time);
 223 }
 224
 225 void LayerAnimationSequence::OnScheduled() {
 226   NotifyScheduled();
 227 }
 228
 229 void LayerAnimationSequence::OnAnimatorDestroyed() {
 230   if (observers_.might_have_observers()) {
 231     ObserverListBase<LayerAnimationObserver>::Iterator it(&observers_);
 232     LayerAnimationObserver* obs;
 233     while ((obs = it.GetNext()) != NULL) {
 234       if (!obs->RequiresNotificationWhenAnimatorDestroyed()) {
 235         // Remove the observer, but do not allow notifications to be sent.
 236         observers_.RemoveObserver(obs);
 237         obs->DetachedFromSequence(this, false);
 238       }
 239     }
 240   }
 241 }
 242
 243 size_t LayerAnimationSequence::size() const {
 244   return elements_.size();
 245 }
 246
 247 LayerAnimationElement* LayerAnimationSequence::FirstElement() const {
 248   if (elements_.empty()) {
 249     return NULL;
 250   }
 251
 252   return elements_[0].get();
 253 }
 254
 255 void LayerAnimationSequence::NotifyScheduled() {
 256   FOR_EACH_OBSERVER(LayerAnimationObserver,
 257                     observers_,
 258                     OnLayerAnimationScheduled(this));
 259 }
 260
 261 void LayerAnimationSequence::NotifyEnded() {
 262   FOR_EACH_OBSERVER(LayerAnimationObserver,
 263                     observers_,
 264                     OnLayerAnimationEnded(this));
 265 }
 266
 267 void LayerAnimationSequence::NotifyAborted() {
 268   FOR_EACH_OBSERVER(LayerAnimationObserver,
 269                     observers_,
 270                     OnLayerAnimationAborted(this));
 271 }
 272
 273 LayerAnimationElement* LayerAnimationSequence::CurrentElement() const {
 274   if (elements_.empty())
 275     return NULL;
 276
 277   size_t current_index = last_element_ % elements_.size();
 278   return elements_[current_index].get();
 279 }
 280
 281 }  // namespace ui