| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 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 "cc/animation/layer_animation_controller.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 #include <vector> | |
| 9 | |
| 10 #include "cc/animation/animation.h" | |
| 11 #include "cc/animation/animation_delegate.h" | |
| 12 #include "cc/animation/animation_registrar.h" | |
| 13 #include "cc/animation/keyframed_animation_curve.h" | |
| 14 #include "cc/animation/layer_animation_value_observer.h" | |
| 15 #include "cc/animation/layer_animation_value_provider.h" | |
| 16 #include "cc/animation/scroll_offset_animation_curve.h" | |
| 17 #include "cc/base/scoped_ptr_algorithm.h" | |
| 18 #include "cc/output/filter_operations.h" | |
| 19 #include "ui/gfx/geometry/box_f.h" | |
| 20 #include "ui/gfx/transform.h" | |
| 21 | |
| 22 namespace cc { | |
| 23 | |
| 24 LayerAnimationController::LayerAnimationController(int id) | |
| 25 : registrar_(0), | |
| 26 id_(id), | |
| 27 is_active_(false), | |
| 28 value_provider_(nullptr), | |
| 29 layer_animation_delegate_(nullptr), | |
| 30 needs_to_start_animations_(false), | |
| 31 scroll_offset_animation_was_interrupted_(false) { | |
| 32 } | |
| 33 | |
| 34 LayerAnimationController::~LayerAnimationController() { | |
| 35 if (registrar_) | |
| 36 registrar_->UnregisterAnimationController(this); | |
| 37 } | |
| 38 | |
| 39 scoped_refptr<LayerAnimationController> LayerAnimationController::Create( | |
| 40 int id) { | |
| 41 return make_scoped_refptr(new LayerAnimationController(id)); | |
| 42 } | |
| 43 | |
| 44 void LayerAnimationController::PauseAnimation(int animation_id, | |
| 45 base::TimeDelta time_offset) { | |
| 46 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 47 if (animations_[i]->id() == animation_id) { | |
| 48 animations_[i]->SetRunState(Animation::PAUSED, | |
| 49 time_offset + animations_[i]->start_time()); | |
| 50 } | |
| 51 } | |
| 52 } | |
| 53 | |
| 54 struct HasAnimationId { | |
| 55 explicit HasAnimationId(int id) : id_(id) {} | |
| 56 bool operator()(Animation* animation) const { | |
| 57 return animation->id() == id_; | |
| 58 } | |
| 59 | |
| 60 private: | |
| 61 int id_; | |
| 62 }; | |
| 63 | |
| 64 void LayerAnimationController::RemoveAnimation(int animation_id) { | |
| 65 auto animations_to_remove = | |
| 66 animations_.remove_if(HasAnimationId(animation_id)); | |
| 67 for (auto it = animations_to_remove; it != animations_.end(); ++it) { | |
| 68 if ((*it)->target_property() == Animation::SCROLL_OFFSET) { | |
| 69 scroll_offset_animation_was_interrupted_ = true; | |
| 70 break; | |
| 71 } | |
| 72 } | |
| 73 animations_.erase(animations_to_remove, animations_.end()); | |
| 74 UpdateActivation(NORMAL_ACTIVATION); | |
| 75 } | |
| 76 | |
| 77 struct HasAnimationIdAndProperty { | |
| 78 HasAnimationIdAndProperty(int id, Animation::TargetProperty target_property) | |
| 79 : id_(id), target_property_(target_property) {} | |
| 80 bool operator()(Animation* animation) const { | |
| 81 return animation->id() == id_ && | |
| 82 animation->target_property() == target_property_; | |
| 83 } | |
| 84 | |
| 85 private: | |
| 86 int id_; | |
| 87 Animation::TargetProperty target_property_; | |
| 88 }; | |
| 89 | |
| 90 void LayerAnimationController::RemoveAnimation( | |
| 91 int animation_id, | |
| 92 Animation::TargetProperty target_property) { | |
| 93 auto animations_to_remove = animations_.remove_if( | |
| 94 HasAnimationIdAndProperty(animation_id, target_property)); | |
| 95 if (target_property == Animation::SCROLL_OFFSET && | |
| 96 animations_to_remove != animations_.end()) | |
| 97 scroll_offset_animation_was_interrupted_ = true; | |
| 98 | |
| 99 animations_.erase(animations_to_remove, animations_.end()); | |
| 100 UpdateActivation(NORMAL_ACTIVATION); | |
| 101 } | |
| 102 | |
| 103 void LayerAnimationController::AbortAnimations( | |
| 104 Animation::TargetProperty target_property) { | |
| 105 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 106 if (animations_[i]->target_property() == target_property && | |
| 107 !animations_[i]->is_finished()) | |
| 108 animations_[i]->SetRunState(Animation::ABORTED, last_tick_time_); | |
| 109 } | |
| 110 } | |
| 111 | |
| 112 // Ensures that the list of active animations on the main thread and the impl | |
| 113 // thread are kept in sync. | |
| 114 void LayerAnimationController::PushAnimationUpdatesTo( | |
| 115 LayerAnimationController* controller_impl) { | |
| 116 DCHECK(this != controller_impl); | |
| 117 if (!has_any_animation() && !controller_impl->has_any_animation()) | |
| 118 return; | |
| 119 PurgeAnimationsMarkedForDeletion(); | |
| 120 PushNewAnimationsToImplThread(controller_impl); | |
| 121 | |
| 122 // Remove finished impl side animations only after pushing, | |
| 123 // and only after the animations are deleted on the main thread | |
| 124 // this insures we will never push an animation twice. | |
| 125 RemoveAnimationsCompletedOnMainThread(controller_impl); | |
| 126 | |
| 127 PushPropertiesToImplThread(controller_impl); | |
| 128 controller_impl->UpdateActivation(NORMAL_ACTIVATION); | |
| 129 UpdateActivation(NORMAL_ACTIVATION); | |
| 130 } | |
| 131 | |
| 132 void LayerAnimationController::Animate(base::TimeTicks monotonic_time) { | |
| 133 DCHECK(!monotonic_time.is_null()); | |
| 134 if (!HasValueObserver()) | |
| 135 return; | |
| 136 | |
| 137 if (needs_to_start_animations_) | |
| 138 StartAnimations(monotonic_time); | |
| 139 TickAnimations(monotonic_time); | |
| 140 last_tick_time_ = monotonic_time; | |
| 141 } | |
| 142 | |
| 143 void LayerAnimationController::AccumulatePropertyUpdates( | |
| 144 base::TimeTicks monotonic_time, | |
| 145 AnimationEventsVector* events) { | |
| 146 if (!events) | |
| 147 return; | |
| 148 | |
| 149 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 150 Animation* animation = animations_[i]; | |
| 151 if (!animation->is_impl_only()) | |
| 152 continue; | |
| 153 | |
| 154 if (!animation->InEffect(monotonic_time)) | |
| 155 continue; | |
| 156 | |
| 157 base::TimeDelta trimmed = | |
| 158 animation->TrimTimeToCurrentIteration(monotonic_time); | |
| 159 switch (animation->target_property()) { | |
| 160 case Animation::OPACITY: { | |
| 161 AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, id_, | |
| 162 animation->group(), Animation::OPACITY, | |
| 163 monotonic_time); | |
| 164 const FloatAnimationCurve* float_animation_curve = | |
| 165 animation->curve()->ToFloatAnimationCurve(); | |
| 166 event.opacity = float_animation_curve->GetValue(trimmed); | |
| 167 event.is_impl_only = true; | |
| 168 events->push_back(event); | |
| 169 break; | |
| 170 } | |
| 171 | |
| 172 case Animation::TRANSFORM: { | |
| 173 AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, id_, | |
| 174 animation->group(), Animation::TRANSFORM, | |
| 175 monotonic_time); | |
| 176 const TransformAnimationCurve* transform_animation_curve = | |
| 177 animation->curve()->ToTransformAnimationCurve(); | |
| 178 event.transform = transform_animation_curve->GetValue(trimmed); | |
| 179 event.is_impl_only = true; | |
| 180 events->push_back(event); | |
| 181 break; | |
| 182 } | |
| 183 | |
| 184 case Animation::FILTER: { | |
| 185 AnimationEvent event(AnimationEvent::PROPERTY_UPDATE, id_, | |
| 186 animation->group(), Animation::FILTER, | |
| 187 monotonic_time); | |
| 188 const FilterAnimationCurve* filter_animation_curve = | |
| 189 animation->curve()->ToFilterAnimationCurve(); | |
| 190 event.filters = filter_animation_curve->GetValue(trimmed); | |
| 191 event.is_impl_only = true; | |
| 192 events->push_back(event); | |
| 193 break; | |
| 194 } | |
| 195 | |
| 196 case Animation::BACKGROUND_COLOR: { | |
| 197 break; | |
| 198 } | |
| 199 | |
| 200 case Animation::SCROLL_OFFSET: { | |
| 201 // Impl-side changes to scroll offset are already sent back to the | |
| 202 // main thread (e.g. for user-driven scrolling), so a PROPERTY_UPDATE | |
| 203 // isn't needed. | |
| 204 break; | |
| 205 } | |
| 206 } | |
| 207 } | |
| 208 } | |
| 209 | |
| 210 void LayerAnimationController::UpdateState(bool start_ready_animations, | |
| 211 AnimationEventsVector* events) { | |
| 212 if (!HasActiveValueObserver()) | |
| 213 return; | |
| 214 | |
| 215 // Animate hasn't been called, this happens if an observer has been added | |
| 216 // between the Commit and Draw phases. | |
| 217 if (last_tick_time_ == base::TimeTicks()) | |
| 218 return; | |
| 219 | |
| 220 if (start_ready_animations) | |
| 221 PromoteStartedAnimations(last_tick_time_, events); | |
| 222 | |
| 223 MarkFinishedAnimations(last_tick_time_); | |
| 224 MarkAnimationsForDeletion(last_tick_time_, events); | |
| 225 | |
| 226 if (needs_to_start_animations_ && start_ready_animations) { | |
| 227 StartAnimations(last_tick_time_); | |
| 228 PromoteStartedAnimations(last_tick_time_, events); | |
| 229 } | |
| 230 | |
| 231 AccumulatePropertyUpdates(last_tick_time_, events); | |
| 232 | |
| 233 UpdateActivation(NORMAL_ACTIVATION); | |
| 234 } | |
| 235 | |
| 236 struct AffectsNoObservers { | |
| 237 bool operator()(Animation* animation) const { | |
| 238 return !animation->affects_active_observers() && | |
| 239 !animation->affects_pending_observers(); | |
| 240 } | |
| 241 }; | |
| 242 | |
| 243 void LayerAnimationController::ActivateAnimations() { | |
| 244 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 245 animations_[i]->set_affects_active_observers( | |
| 246 animations_[i]->affects_pending_observers()); | |
| 247 } | |
| 248 animations_.erase(cc::remove_if(&animations_, | |
| 249 animations_.begin(), | |
| 250 animations_.end(), | |
| 251 AffectsNoObservers()), | |
| 252 animations_.end()); | |
| 253 scroll_offset_animation_was_interrupted_ = false; | |
| 254 UpdateActivation(NORMAL_ACTIVATION); | |
| 255 } | |
| 256 | |
| 257 void LayerAnimationController::AddAnimation(scoped_ptr<Animation> animation) { | |
| 258 animations_.push_back(animation.Pass()); | |
| 259 needs_to_start_animations_ = true; | |
| 260 UpdateActivation(NORMAL_ACTIVATION); | |
| 261 } | |
| 262 | |
| 263 Animation* LayerAnimationController::GetAnimation( | |
| 264 Animation::TargetProperty target_property) const { | |
| 265 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 266 size_t index = animations_.size() - i - 1; | |
| 267 if (animations_[index]->target_property() == target_property) | |
| 268 return animations_[index]; | |
| 269 } | |
| 270 return 0; | |
| 271 } | |
| 272 | |
| 273 Animation* LayerAnimationController::GetAnimationById(int animation_id) const { | |
| 274 for (size_t i = 0; i < animations_.size(); ++i) | |
| 275 if (animations_[i]->id() == animation_id) | |
| 276 return animations_[i]; | |
| 277 return nullptr; | |
| 278 } | |
| 279 | |
| 280 bool LayerAnimationController::HasActiveAnimation() const { | |
| 281 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 282 if (!animations_[i]->is_finished()) | |
| 283 return true; | |
| 284 } | |
| 285 return false; | |
| 286 } | |
| 287 | |
| 288 bool LayerAnimationController::IsAnimatingProperty( | |
| 289 Animation::TargetProperty target_property) const { | |
| 290 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 291 if (!animations_[i]->is_finished() && | |
| 292 animations_[i]->InEffect(last_tick_time_) && | |
| 293 animations_[i]->target_property() == target_property) | |
| 294 return true; | |
| 295 } | |
| 296 return false; | |
| 297 } | |
| 298 | |
| 299 void LayerAnimationController::SetAnimationRegistrar( | |
| 300 AnimationRegistrar* registrar) { | |
| 301 if (registrar_ == registrar) | |
| 302 return; | |
| 303 | |
| 304 if (registrar_) | |
| 305 registrar_->UnregisterAnimationController(this); | |
| 306 | |
| 307 registrar_ = registrar; | |
| 308 if (registrar_) | |
| 309 registrar_->RegisterAnimationController(this); | |
| 310 | |
| 311 UpdateActivation(FORCE_ACTIVATION); | |
| 312 } | |
| 313 | |
| 314 void LayerAnimationController::NotifyAnimationStarted( | |
| 315 const AnimationEvent& event) { | |
| 316 if (event.is_impl_only) { | |
| 317 FOR_EACH_OBSERVER(LayerAnimationEventObserver, event_observers_, | |
| 318 OnAnimationStarted(event)); | |
| 319 if (layer_animation_delegate_) | |
| 320 layer_animation_delegate_->NotifyAnimationStarted( | |
| 321 event.monotonic_time, event.target_property, event.group_id); | |
| 322 return; | |
| 323 } | |
| 324 | |
| 325 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 326 if (animations_[i]->group() == event.group_id && | |
| 327 animations_[i]->target_property() == event.target_property && | |
| 328 animations_[i]->needs_synchronized_start_time()) { | |
| 329 animations_[i]->set_needs_synchronized_start_time(false); | |
| 330 if (!animations_[i]->has_set_start_time()) | |
| 331 animations_[i]->set_start_time(event.monotonic_time); | |
| 332 | |
| 333 FOR_EACH_OBSERVER(LayerAnimationEventObserver, event_observers_, | |
| 334 OnAnimationStarted(event)); | |
| 335 if (layer_animation_delegate_) | |
| 336 layer_animation_delegate_->NotifyAnimationStarted( | |
| 337 event.monotonic_time, event.target_property, event.group_id); | |
| 338 | |
| 339 return; | |
| 340 } | |
| 341 } | |
| 342 } | |
| 343 | |
| 344 void LayerAnimationController::NotifyAnimationFinished( | |
| 345 const AnimationEvent& event) { | |
| 346 if (event.is_impl_only) { | |
| 347 if (layer_animation_delegate_) | |
| 348 layer_animation_delegate_->NotifyAnimationFinished( | |
| 349 event.monotonic_time, event.target_property, event.group_id); | |
| 350 return; | |
| 351 } | |
| 352 | |
| 353 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 354 if (animations_[i]->group() == event.group_id && | |
| 355 animations_[i]->target_property() == event.target_property) { | |
| 356 animations_[i]->set_received_finished_event(true); | |
| 357 if (layer_animation_delegate_) | |
| 358 layer_animation_delegate_->NotifyAnimationFinished( | |
| 359 event.monotonic_time, event.target_property, event.group_id); | |
| 360 | |
| 361 return; | |
| 362 } | |
| 363 } | |
| 364 } | |
| 365 | |
| 366 void LayerAnimationController::NotifyAnimationAborted( | |
| 367 const AnimationEvent& event) { | |
| 368 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 369 if (animations_[i]->group() == event.group_id && | |
| 370 animations_[i]->target_property() == event.target_property) { | |
| 371 animations_[i]->SetRunState(Animation::ABORTED, event.monotonic_time); | |
| 372 } | |
| 373 } | |
| 374 } | |
| 375 | |
| 376 void LayerAnimationController::NotifyAnimationPropertyUpdate( | |
| 377 const AnimationEvent& event) { | |
| 378 bool notify_active_observers = true; | |
| 379 bool notify_pending_observers = true; | |
| 380 switch (event.target_property) { | |
| 381 case Animation::OPACITY: | |
| 382 NotifyObserversOpacityAnimated( | |
| 383 event.opacity, notify_active_observers, notify_pending_observers); | |
| 384 break; | |
| 385 case Animation::TRANSFORM: | |
| 386 NotifyObserversTransformAnimated( | |
| 387 event.transform, notify_active_observers, notify_pending_observers); | |
| 388 break; | |
| 389 default: | |
| 390 NOTREACHED(); | |
| 391 } | |
| 392 } | |
| 393 | |
| 394 void LayerAnimationController::AddValueObserver( | |
| 395 LayerAnimationValueObserver* observer) { | |
| 396 if (!value_observers_.HasObserver(observer)) | |
| 397 value_observers_.AddObserver(observer); | |
| 398 } | |
| 399 | |
| 400 void LayerAnimationController::RemoveValueObserver( | |
| 401 LayerAnimationValueObserver* observer) { | |
| 402 value_observers_.RemoveObserver(observer); | |
| 403 } | |
| 404 | |
| 405 void LayerAnimationController::AddEventObserver( | |
| 406 LayerAnimationEventObserver* observer) { | |
| 407 if (!event_observers_.HasObserver(observer)) | |
| 408 event_observers_.AddObserver(observer); | |
| 409 } | |
| 410 | |
| 411 void LayerAnimationController::RemoveEventObserver( | |
| 412 LayerAnimationEventObserver* observer) { | |
| 413 event_observers_.RemoveObserver(observer); | |
| 414 } | |
| 415 | |
| 416 bool LayerAnimationController::HasFilterAnimationThatInflatesBounds() const { | |
| 417 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 418 if (!animations_[i]->is_finished() && | |
| 419 animations_[i]->target_property() == Animation::FILTER && | |
| 420 animations_[i] | |
| 421 ->curve() | |
| 422 ->ToFilterAnimationCurve() | |
| 423 ->HasFilterThatMovesPixels()) | |
| 424 return true; | |
| 425 } | |
| 426 | |
| 427 return false; | |
| 428 } | |
| 429 | |
| 430 bool LayerAnimationController::HasTransformAnimationThatInflatesBounds() const { | |
| 431 return IsAnimatingProperty(Animation::TRANSFORM); | |
| 432 } | |
| 433 | |
| 434 bool LayerAnimationController::FilterAnimationBoundsForBox( | |
| 435 const gfx::BoxF& box, gfx::BoxF* bounds) const { | |
| 436 // TODO(avallee): Implement. | |
| 437 return false; | |
| 438 } | |
| 439 | |
| 440 bool LayerAnimationController::TransformAnimationBoundsForBox( | |
| 441 const gfx::BoxF& box, | |
| 442 gfx::BoxF* bounds) const { | |
| 443 DCHECK(HasTransformAnimationThatInflatesBounds()) | |
| 444 << "TransformAnimationBoundsForBox will give incorrect results if there " | |
| 445 << "are no transform animations affecting bounds, non-animated transform " | |
| 446 << "is not known"; | |
| 447 | |
| 448 // Compute bounds based on animations for which is_finished() is false. | |
| 449 // Do nothing if there are no such animations; in this case, it is assumed | |
| 450 // that callers will take care of computing bounds based on the owning layer's | |
| 451 // actual transform. | |
| 452 *bounds = gfx::BoxF(); | |
| 453 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 454 if (animations_[i]->is_finished() || | |
| 455 animations_[i]->target_property() != Animation::TRANSFORM) | |
| 456 continue; | |
| 457 | |
| 458 const TransformAnimationCurve* transform_animation_curve = | |
| 459 animations_[i]->curve()->ToTransformAnimationCurve(); | |
| 460 gfx::BoxF animation_bounds; | |
| 461 bool success = | |
| 462 transform_animation_curve->AnimatedBoundsForBox(box, &animation_bounds); | |
| 463 if (!success) | |
| 464 return false; | |
| 465 bounds->Union(animation_bounds); | |
| 466 } | |
| 467 | |
| 468 return true; | |
| 469 } | |
| 470 | |
| 471 bool LayerAnimationController::HasAnimationThatAffectsScale() const { | |
| 472 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 473 if (animations_[i]->is_finished() || | |
| 474 animations_[i]->target_property() != Animation::TRANSFORM) | |
| 475 continue; | |
| 476 | |
| 477 const TransformAnimationCurve* transform_animation_curve = | |
| 478 animations_[i]->curve()->ToTransformAnimationCurve(); | |
| 479 if (transform_animation_curve->AffectsScale()) | |
| 480 return true; | |
| 481 } | |
| 482 | |
| 483 return false; | |
| 484 } | |
| 485 | |
| 486 bool LayerAnimationController::HasOnlyTranslationTransforms() const { | |
| 487 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 488 if (animations_[i]->is_finished() || | |
| 489 animations_[i]->target_property() != Animation::TRANSFORM) | |
| 490 continue; | |
| 491 | |
| 492 const TransformAnimationCurve* transform_animation_curve = | |
| 493 animations_[i]->curve()->ToTransformAnimationCurve(); | |
| 494 if (!transform_animation_curve->IsTranslation()) | |
| 495 return false; | |
| 496 } | |
| 497 | |
| 498 return true; | |
| 499 } | |
| 500 | |
| 501 bool LayerAnimationController::AnimationsPreserveAxisAlignment() const { | |
| 502 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 503 if (animations_[i]->is_finished() || | |
| 504 animations_[i]->target_property() != Animation::TRANSFORM) | |
| 505 continue; | |
| 506 | |
| 507 const TransformAnimationCurve* transform_animation_curve = | |
| 508 animations_[i]->curve()->ToTransformAnimationCurve(); | |
| 509 if (!transform_animation_curve->PreservesAxisAlignment()) | |
| 510 return false; | |
| 511 } | |
| 512 | |
| 513 return true; | |
| 514 } | |
| 515 | |
| 516 bool LayerAnimationController::MaximumTargetScale(float* max_scale) const { | |
| 517 *max_scale = 0.f; | |
| 518 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 519 if (animations_[i]->is_finished() || | |
| 520 animations_[i]->target_property() != Animation::TRANSFORM) | |
| 521 continue; | |
| 522 | |
| 523 bool forward_direction = true; | |
| 524 switch (animations_[i]->direction()) { | |
| 525 case Animation::DIRECTION_NORMAL: | |
| 526 case Animation::DIRECTION_ALTERNATE: | |
| 527 forward_direction = animations_[i]->playback_rate() >= 0.0; | |
| 528 break; | |
| 529 case Animation::DIRECTION_REVERSE: | |
| 530 case Animation::DIRECTION_ALTERNATE_REVERSE: | |
| 531 forward_direction = animations_[i]->playback_rate() < 0.0; | |
| 532 break; | |
| 533 } | |
| 534 | |
| 535 const TransformAnimationCurve* transform_animation_curve = | |
| 536 animations_[i]->curve()->ToTransformAnimationCurve(); | |
| 537 float animation_scale = 0.f; | |
| 538 if (!transform_animation_curve->MaximumTargetScale(forward_direction, | |
| 539 &animation_scale)) | |
| 540 return false; | |
| 541 *max_scale = std::max(*max_scale, animation_scale); | |
| 542 } | |
| 543 | |
| 544 return true; | |
| 545 } | |
| 546 | |
| 547 void LayerAnimationController::PushNewAnimationsToImplThread( | |
| 548 LayerAnimationController* controller_impl) const { | |
| 549 // Any new animations owned by the main thread's controller are cloned and | |
| 550 // add to the impl thread's controller. | |
| 551 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 552 // If the animation is already running on the impl thread, there is no | |
| 553 // need to copy it over. | |
| 554 if (controller_impl->GetAnimationById(animations_[i]->id())) | |
| 555 continue; | |
| 556 | |
| 557 // If the animation is not running on the impl thread, it does not | |
| 558 // necessarily mean that it needs to be copied over and started; it may | |
| 559 // have already finished. In this case, the impl thread animation will | |
| 560 // have already notified that it has started and the main thread animation | |
| 561 // will no longer need | |
| 562 // a synchronized start time. | |
| 563 if (!animations_[i]->needs_synchronized_start_time()) | |
| 564 continue; | |
| 565 | |
| 566 // Scroll animations always start at the current scroll offset. | |
| 567 if (animations_[i]->target_property() == Animation::SCROLL_OFFSET) { | |
| 568 gfx::ScrollOffset current_scroll_offset; | |
| 569 if (controller_impl->value_provider_) { | |
| 570 current_scroll_offset = | |
| 571 controller_impl->value_provider_->ScrollOffsetForAnimation(); | |
| 572 } else { | |
| 573 // The owning layer isn't yet in the active tree, so the main thread | |
| 574 // scroll offset will be up-to-date. | |
| 575 current_scroll_offset = value_provider_->ScrollOffsetForAnimation(); | |
| 576 } | |
| 577 animations_[i]->curve()->ToScrollOffsetAnimationCurve()->SetInitialValue( | |
| 578 current_scroll_offset); | |
| 579 } | |
| 580 | |
| 581 // The new animation should be set to run as soon as possible. | |
| 582 Animation::RunState initial_run_state = | |
| 583 Animation::WAITING_FOR_TARGET_AVAILABILITY; | |
| 584 scoped_ptr<Animation> to_add( | |
| 585 animations_[i]->CloneAndInitialize(initial_run_state)); | |
| 586 DCHECK(!to_add->needs_synchronized_start_time()); | |
| 587 to_add->set_affects_active_observers(false); | |
| 588 controller_impl->AddAnimation(to_add.Pass()); | |
| 589 } | |
| 590 } | |
| 591 | |
| 592 static bool IsCompleted( | |
| 593 Animation* animation, | |
| 594 const LayerAnimationController* main_thread_controller) { | |
| 595 if (animation->is_impl_only()) { | |
| 596 return (animation->run_state() == Animation::WAITING_FOR_DELETION); | |
| 597 } else { | |
| 598 return !main_thread_controller->GetAnimationById(animation->id()); | |
| 599 } | |
| 600 } | |
| 601 | |
| 602 static bool AffectsActiveOnlyAndIsWaitingForDeletion(Animation* animation) { | |
| 603 return animation->run_state() == Animation::WAITING_FOR_DELETION && | |
| 604 !animation->affects_pending_observers(); | |
| 605 } | |
| 606 | |
| 607 void LayerAnimationController::RemoveAnimationsCompletedOnMainThread( | |
| 608 LayerAnimationController* controller_impl) const { | |
| 609 // Animations removed on the main thread should no longer affect pending | |
| 610 // observers, and should stop affecting active observers after the next call | |
| 611 // to ActivateAnimations. If already WAITING_FOR_DELETION, they can be removed | |
| 612 // immediately. | |
| 613 ScopedPtrVector<Animation>& animations = controller_impl->animations_; | |
| 614 for (size_t i = 0; i < animations.size(); ++i) { | |
| 615 if (IsCompleted(animations[i], this)) | |
| 616 animations[i]->set_affects_pending_observers(false); | |
| 617 } | |
| 618 animations.erase(cc::remove_if(&animations, | |
| 619 animations.begin(), | |
| 620 animations.end(), | |
| 621 AffectsActiveOnlyAndIsWaitingForDeletion), | |
| 622 animations.end()); | |
| 623 } | |
| 624 | |
| 625 void LayerAnimationController::PushPropertiesToImplThread( | |
| 626 LayerAnimationController* controller_impl) { | |
| 627 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 628 Animation* current_impl = | |
| 629 controller_impl->GetAnimationById(animations_[i]->id()); | |
| 630 if (current_impl) | |
| 631 animations_[i]->PushPropertiesTo(current_impl); | |
| 632 } | |
| 633 controller_impl->scroll_offset_animation_was_interrupted_ = | |
| 634 scroll_offset_animation_was_interrupted_; | |
| 635 scroll_offset_animation_was_interrupted_ = false; | |
| 636 } | |
| 637 | |
| 638 void LayerAnimationController::StartAnimations(base::TimeTicks monotonic_time) { | |
| 639 DCHECK(needs_to_start_animations_); | |
| 640 needs_to_start_animations_ = false; | |
| 641 // First collect running properties affecting each type of observer. | |
| 642 TargetProperties blocked_properties_for_active_observers; | |
| 643 TargetProperties blocked_properties_for_pending_observers; | |
| 644 std::vector<size_t> animations_waiting_for_target; | |
| 645 | |
| 646 animations_waiting_for_target.reserve(animations_.size()); | |
| 647 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 648 if (animations_[i]->run_state() == Animation::STARTING || | |
| 649 animations_[i]->run_state() == Animation::RUNNING) { | |
| 650 if (animations_[i]->affects_active_observers()) { | |
| 651 blocked_properties_for_active_observers.insert( | |
| 652 animations_[i]->target_property()); | |
| 653 } | |
| 654 if (animations_[i]->affects_pending_observers()) { | |
| 655 blocked_properties_for_pending_observers.insert( | |
| 656 animations_[i]->target_property()); | |
| 657 } | |
| 658 } else if (animations_[i]->run_state() == | |
| 659 Animation::WAITING_FOR_TARGET_AVAILABILITY) { | |
| 660 animations_waiting_for_target.push_back(i); | |
| 661 } | |
| 662 } | |
| 663 | |
| 664 for (size_t i = 0; i < animations_waiting_for_target.size(); ++i) { | |
| 665 // Collect all properties for animations with the same group id (they | |
| 666 // should all also be in the list of animations). | |
| 667 size_t animation_index = animations_waiting_for_target[i]; | |
| 668 Animation* animation_waiting_for_target = animations_[animation_index]; | |
| 669 // Check for the run state again even though the animation was waiting | |
| 670 // for target because it might have changed the run state while handling | |
| 671 // previous animation in this loop (if they belong to same group). | |
| 672 if (animation_waiting_for_target->run_state() == | |
| 673 Animation::WAITING_FOR_TARGET_AVAILABILITY) { | |
| 674 TargetProperties enqueued_properties; | |
| 675 bool affects_active_observers = | |
| 676 animation_waiting_for_target->affects_active_observers(); | |
| 677 bool affects_pending_observers = | |
| 678 animation_waiting_for_target->affects_pending_observers(); | |
| 679 enqueued_properties.insert( | |
| 680 animation_waiting_for_target->target_property()); | |
| 681 for (size_t j = animation_index + 1; j < animations_.size(); ++j) { | |
| 682 if (animation_waiting_for_target->group() == animations_[j]->group()) { | |
| 683 enqueued_properties.insert(animations_[j]->target_property()); | |
| 684 affects_active_observers |= | |
| 685 animations_[j]->affects_active_observers(); | |
| 686 affects_pending_observers |= | |
| 687 animations_[j]->affects_pending_observers(); | |
| 688 } | |
| 689 } | |
| 690 | |
| 691 // Check to see if intersection of the list of properties affected by | |
| 692 // the group and the list of currently blocked properties is null, taking | |
| 693 // into account the type(s) of observers affected by the group. In any | |
| 694 // case, the group's target properties need to be added to the lists of | |
| 695 // blocked properties. | |
| 696 bool null_intersection = true; | |
| 697 for (TargetProperties::iterator p_iter = enqueued_properties.begin(); | |
| 698 p_iter != enqueued_properties.end(); | |
| 699 ++p_iter) { | |
| 700 if (affects_active_observers && | |
| 701 !blocked_properties_for_active_observers.insert(*p_iter).second) | |
| 702 null_intersection = false; | |
| 703 if (affects_pending_observers && | |
| 704 !blocked_properties_for_pending_observers.insert(*p_iter).second) | |
| 705 null_intersection = false; | |
| 706 } | |
| 707 | |
| 708 // If the intersection is null, then we are free to start the animations | |
| 709 // in the group. | |
| 710 if (null_intersection) { | |
| 711 animation_waiting_for_target->SetRunState(Animation::STARTING, | |
| 712 monotonic_time); | |
| 713 for (size_t j = animation_index + 1; j < animations_.size(); ++j) { | |
| 714 if (animation_waiting_for_target->group() == | |
| 715 animations_[j]->group()) { | |
| 716 animations_[j]->SetRunState(Animation::STARTING, monotonic_time); | |
| 717 } | |
| 718 } | |
| 719 } else { | |
| 720 needs_to_start_animations_ = true; | |
| 721 } | |
| 722 } | |
| 723 } | |
| 724 } | |
| 725 | |
| 726 void LayerAnimationController::PromoteStartedAnimations( | |
| 727 base::TimeTicks monotonic_time, | |
| 728 AnimationEventsVector* events) { | |
| 729 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 730 if (animations_[i]->run_state() == Animation::STARTING && | |
| 731 animations_[i]->affects_active_observers()) { | |
| 732 animations_[i]->SetRunState(Animation::RUNNING, monotonic_time); | |
| 733 if (!animations_[i]->has_set_start_time() && | |
| 734 !animations_[i]->needs_synchronized_start_time()) | |
| 735 animations_[i]->set_start_time(monotonic_time); | |
| 736 if (events) { | |
| 737 AnimationEvent started_event( | |
| 738 AnimationEvent::STARTED, id_, animations_[i]->group(), | |
| 739 animations_[i]->target_property(), monotonic_time); | |
| 740 started_event.is_impl_only = animations_[i]->is_impl_only(); | |
| 741 if (started_event.is_impl_only) | |
| 742 NotifyAnimationStarted(started_event); | |
| 743 else | |
| 744 events->push_back(started_event); | |
| 745 } | |
| 746 } | |
| 747 } | |
| 748 } | |
| 749 | |
| 750 void LayerAnimationController::MarkFinishedAnimations( | |
| 751 base::TimeTicks monotonic_time) { | |
| 752 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 753 if (animations_[i]->IsFinishedAt(monotonic_time) && | |
| 754 animations_[i]->run_state() != Animation::ABORTED && | |
| 755 animations_[i]->run_state() != Animation::WAITING_FOR_DELETION) | |
| 756 animations_[i]->SetRunState(Animation::FINISHED, monotonic_time); | |
| 757 } | |
| 758 } | |
| 759 | |
| 760 void LayerAnimationController::MarkAnimationsForDeletion( | |
| 761 base::TimeTicks monotonic_time, | |
| 762 AnimationEventsVector* events) { | |
| 763 bool marked_animations_for_deletions = false; | |
| 764 std::vector<size_t> animations_with_same_group_id; | |
| 765 | |
| 766 animations_with_same_group_id.reserve(animations_.size()); | |
| 767 // Non-aborted animations are marked for deletion after a corresponding | |
| 768 // AnimationEvent::FINISHED event is sent or received. This means that if | |
| 769 // we don't have an events vector, we must ensure that non-aborted animations | |
| 770 // have received a finished event before marking them for deletion. | |
| 771 for (size_t i = 0; i < animations_.size(); i++) { | |
| 772 int group_id = animations_[i]->group(); | |
| 773 if (animations_[i]->run_state() == Animation::ABORTED) { | |
| 774 if (events && !animations_[i]->is_impl_only()) { | |
| 775 AnimationEvent aborted_event(AnimationEvent::ABORTED, id_, group_id, | |
| 776 animations_[i]->target_property(), | |
| 777 monotonic_time); | |
| 778 events->push_back(aborted_event); | |
| 779 } | |
| 780 animations_[i]->SetRunState(Animation::WAITING_FOR_DELETION, | |
| 781 monotonic_time); | |
| 782 marked_animations_for_deletions = true; | |
| 783 continue; | |
| 784 } | |
| 785 | |
| 786 bool all_anims_with_same_id_are_finished = false; | |
| 787 | |
| 788 // Since deleting an animation on the main thread leads to its deletion | |
| 789 // on the impl thread, we only mark a FINISHED main thread animation for | |
| 790 // deletion once it has received a FINISHED event from the impl thread. | |
| 791 bool animation_i_will_send_or_has_received_finish_event = | |
| 792 events || animations_[i]->received_finished_event(); | |
| 793 // If an animation is finished, and not already marked for deletion, | |
| 794 // find out if all other animations in the same group are also finished. | |
| 795 if (animations_[i]->run_state() == Animation::FINISHED && | |
| 796 animation_i_will_send_or_has_received_finish_event) { | |
| 797 // Clear the animations_with_same_group_id if it was added for | |
| 798 // the previous animation's iteration. | |
| 799 if (animations_with_same_group_id.size() > 0) | |
| 800 animations_with_same_group_id.clear(); | |
| 801 all_anims_with_same_id_are_finished = true; | |
| 802 for (size_t j = 0; j < animations_.size(); ++j) { | |
| 803 bool animation_j_will_send_or_has_received_finish_event = | |
| 804 events || animations_[j]->received_finished_event(); | |
| 805 if (group_id == animations_[j]->group()) { | |
| 806 if (!animations_[j]->is_finished() || | |
| 807 (animations_[j]->run_state() == Animation::FINISHED && | |
| 808 !animation_j_will_send_or_has_received_finish_event)) { | |
| 809 all_anims_with_same_id_are_finished = false; | |
| 810 break; | |
| 811 } else if (j >= i && | |
| 812 animations_[j]->run_state() != Animation::ABORTED) { | |
| 813 // Mark down the animations which belong to the same group | |
| 814 // and is not yet aborted. If this current iteration finds that all | |
| 815 // animations with same ID are finished, then the marked | |
| 816 // animations below will be set to WAITING_FOR_DELETION in next | |
| 817 // iteration. | |
| 818 animations_with_same_group_id.push_back(j); | |
| 819 } | |
| 820 } | |
| 821 } | |
| 822 } | |
| 823 if (all_anims_with_same_id_are_finished) { | |
| 824 // We now need to remove all animations with the same group id as | |
| 825 // group_id (and send along animation finished notifications, if | |
| 826 // necessary). | |
| 827 for (size_t j = 0; j < animations_with_same_group_id.size(); j++) { | |
| 828 size_t animation_index = animations_with_same_group_id[j]; | |
| 829 if (events) { | |
| 830 AnimationEvent finished_event( | |
| 831 AnimationEvent::FINISHED, id_, | |
| 832 animations_[animation_index]->group(), | |
| 833 animations_[animation_index]->target_property(), | |
| 834 monotonic_time); | |
| 835 finished_event.is_impl_only = | |
| 836 animations_[animation_index]->is_impl_only(); | |
| 837 if (finished_event.is_impl_only) | |
| 838 NotifyAnimationFinished(finished_event); | |
| 839 else | |
| 840 events->push_back(finished_event); | |
| 841 } | |
| 842 animations_[animation_index]->SetRunState( | |
| 843 Animation::WAITING_FOR_DELETION, monotonic_time); | |
| 844 } | |
| 845 marked_animations_for_deletions = true; | |
| 846 } | |
| 847 } | |
| 848 if (marked_animations_for_deletions) | |
| 849 NotifyObserversAnimationWaitingForDeletion(); | |
| 850 } | |
| 851 | |
| 852 static bool IsWaitingForDeletion(Animation* animation) { | |
| 853 return animation->run_state() == Animation::WAITING_FOR_DELETION; | |
| 854 } | |
| 855 | |
| 856 void LayerAnimationController::PurgeAnimationsMarkedForDeletion() { | |
| 857 animations_.erase(cc::remove_if(&animations_, | |
| 858 animations_.begin(), | |
| 859 animations_.end(), | |
| 860 IsWaitingForDeletion), | |
| 861 animations_.end()); | |
| 862 } | |
| 863 | |
| 864 void LayerAnimationController::TickAnimations(base::TimeTicks monotonic_time) { | |
| 865 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 866 if (animations_[i]->run_state() == Animation::STARTING || | |
| 867 animations_[i]->run_state() == Animation::RUNNING || | |
| 868 animations_[i]->run_state() == Animation::PAUSED) { | |
| 869 if (!animations_[i]->InEffect(monotonic_time)) | |
| 870 continue; | |
| 871 | |
| 872 base::TimeDelta trimmed = | |
| 873 animations_[i]->TrimTimeToCurrentIteration(monotonic_time); | |
| 874 | |
| 875 switch (animations_[i]->target_property()) { | |
| 876 case Animation::TRANSFORM: { | |
| 877 const TransformAnimationCurve* transform_animation_curve = | |
| 878 animations_[i]->curve()->ToTransformAnimationCurve(); | |
| 879 const gfx::Transform transform = | |
| 880 transform_animation_curve->GetValue(trimmed); | |
| 881 NotifyObserversTransformAnimated( | |
| 882 transform, | |
| 883 animations_[i]->affects_active_observers(), | |
| 884 animations_[i]->affects_pending_observers()); | |
| 885 break; | |
| 886 } | |
| 887 | |
| 888 case Animation::OPACITY: { | |
| 889 const FloatAnimationCurve* float_animation_curve = | |
| 890 animations_[i]->curve()->ToFloatAnimationCurve(); | |
| 891 const float opacity = std::max( | |
| 892 std::min(float_animation_curve->GetValue(trimmed), 1.0f), 0.f); | |
| 893 NotifyObserversOpacityAnimated( | |
| 894 opacity, | |
| 895 animations_[i]->affects_active_observers(), | |
| 896 animations_[i]->affects_pending_observers()); | |
| 897 break; | |
| 898 } | |
| 899 | |
| 900 case Animation::FILTER: { | |
| 901 const FilterAnimationCurve* filter_animation_curve = | |
| 902 animations_[i]->curve()->ToFilterAnimationCurve(); | |
| 903 const FilterOperations filter = | |
| 904 filter_animation_curve->GetValue(trimmed); | |
| 905 NotifyObserversFilterAnimated( | |
| 906 filter, | |
| 907 animations_[i]->affects_active_observers(), | |
| 908 animations_[i]->affects_pending_observers()); | |
| 909 break; | |
| 910 } | |
| 911 | |
| 912 case Animation::BACKGROUND_COLOR: { | |
| 913 // Not yet implemented. | |
| 914 break; | |
| 915 } | |
| 916 | |
| 917 case Animation::SCROLL_OFFSET: { | |
| 918 const ScrollOffsetAnimationCurve* scroll_offset_animation_curve = | |
| 919 animations_[i]->curve()->ToScrollOffsetAnimationCurve(); | |
| 920 const gfx::ScrollOffset scroll_offset = | |
| 921 scroll_offset_animation_curve->GetValue(trimmed); | |
| 922 NotifyObserversScrollOffsetAnimated( | |
| 923 scroll_offset, | |
| 924 animations_[i]->affects_active_observers(), | |
| 925 animations_[i]->affects_pending_observers()); | |
| 926 break; | |
| 927 } | |
| 928 } | |
| 929 } | |
| 930 } | |
| 931 } | |
| 932 | |
| 933 void LayerAnimationController::UpdateActivation(UpdateActivationType type) { | |
| 934 bool force = type == FORCE_ACTIVATION; | |
| 935 if (registrar_) { | |
| 936 bool was_active = is_active_; | |
| 937 is_active_ = false; | |
| 938 for (size_t i = 0; i < animations_.size(); ++i) { | |
| 939 if (animations_[i]->run_state() != Animation::WAITING_FOR_DELETION) { | |
| 940 is_active_ = true; | |
| 941 break; | |
| 942 } | |
| 943 } | |
| 944 | |
| 945 if (is_active_ && (!was_active || force)) | |
| 946 registrar_->DidActivateAnimationController(this); | |
| 947 else if (!is_active_ && (was_active || force)) | |
| 948 registrar_->DidDeactivateAnimationController(this); | |
| 949 } | |
| 950 } | |
| 951 | |
| 952 void LayerAnimationController::NotifyObserversOpacityAnimated( | |
| 953 float opacity, | |
| 954 bool notify_active_observers, | |
| 955 bool notify_pending_observers) { | |
| 956 if (value_observers_.might_have_observers()) { | |
| 957 ObserverListBase<LayerAnimationValueObserver>::Iterator it( | |
| 958 &value_observers_); | |
| 959 LayerAnimationValueObserver* obs; | |
| 960 while ((obs = it.GetNext()) != nullptr) { | |
| 961 if ((notify_active_observers && notify_pending_observers) || | |
| 962 (notify_active_observers && obs->IsActive()) || | |
| 963 (notify_pending_observers && !obs->IsActive())) | |
| 964 obs->OnOpacityAnimated(opacity); | |
| 965 } | |
| 966 } | |
| 967 } | |
| 968 | |
| 969 void LayerAnimationController::NotifyObserversTransformAnimated( | |
| 970 const gfx::Transform& transform, | |
| 971 bool notify_active_observers, | |
| 972 bool notify_pending_observers) { | |
| 973 if (value_observers_.might_have_observers()) { | |
| 974 ObserverListBase<LayerAnimationValueObserver>::Iterator it( | |
| 975 &value_observers_); | |
| 976 LayerAnimationValueObserver* obs; | |
| 977 while ((obs = it.GetNext()) != nullptr) { | |
| 978 if ((notify_active_observers && notify_pending_observers) || | |
| 979 (notify_active_observers && obs->IsActive()) || | |
| 980 (notify_pending_observers && !obs->IsActive())) | |
| 981 obs->OnTransformAnimated(transform); | |
| 982 } | |
| 983 } | |
| 984 } | |
| 985 | |
| 986 void LayerAnimationController::NotifyObserversFilterAnimated( | |
| 987 const FilterOperations& filters, | |
| 988 bool notify_active_observers, | |
| 989 bool notify_pending_observers) { | |
| 990 if (value_observers_.might_have_observers()) { | |
| 991 ObserverListBase<LayerAnimationValueObserver>::Iterator it( | |
| 992 &value_observers_); | |
| 993 LayerAnimationValueObserver* obs; | |
| 994 while ((obs = it.GetNext()) != nullptr) { | |
| 995 if ((notify_active_observers && notify_pending_observers) || | |
| 996 (notify_active_observers && obs->IsActive()) || | |
| 997 (notify_pending_observers && !obs->IsActive())) | |
| 998 obs->OnFilterAnimated(filters); | |
| 999 } | |
| 1000 } | |
| 1001 } | |
| 1002 | |
| 1003 void LayerAnimationController::NotifyObserversScrollOffsetAnimated( | |
| 1004 const gfx::ScrollOffset& scroll_offset, | |
| 1005 bool notify_active_observers, | |
| 1006 bool notify_pending_observers) { | |
| 1007 if (value_observers_.might_have_observers()) { | |
| 1008 ObserverListBase<LayerAnimationValueObserver>::Iterator it( | |
| 1009 &value_observers_); | |
| 1010 LayerAnimationValueObserver* obs; | |
| 1011 while ((obs = it.GetNext()) != nullptr) { | |
| 1012 if ((notify_active_observers && notify_pending_observers) || | |
| 1013 (notify_active_observers && obs->IsActive()) || | |
| 1014 (notify_pending_observers && !obs->IsActive())) | |
| 1015 obs->OnScrollOffsetAnimated(scroll_offset); | |
| 1016 } | |
| 1017 } | |
| 1018 } | |
| 1019 | |
| 1020 void LayerAnimationController::NotifyObserversAnimationWaitingForDeletion() { | |
| 1021 FOR_EACH_OBSERVER(LayerAnimationValueObserver, | |
| 1022 value_observers_, | |
| 1023 OnAnimationWaitingForDeletion()); | |
| 1024 } | |
| 1025 | |
| 1026 bool LayerAnimationController::HasValueObserver() { | |
| 1027 if (value_observers_.might_have_observers()) { | |
| 1028 ObserverListBase<LayerAnimationValueObserver>::Iterator it( | |
| 1029 &value_observers_); | |
| 1030 return it.GetNext() != nullptr; | |
| 1031 } | |
| 1032 return false; | |
| 1033 } | |
| 1034 | |
| 1035 bool LayerAnimationController::HasActiveValueObserver() { | |
| 1036 if (value_observers_.might_have_observers()) { | |
| 1037 ObserverListBase<LayerAnimationValueObserver>::Iterator it( | |
| 1038 &value_observers_); | |
| 1039 LayerAnimationValueObserver* obs; | |
| 1040 while ((obs = it.GetNext()) != nullptr) | |
| 1041 if (obs->IsActive()) | |
| 1042 return true; | |
| 1043 } | |
| 1044 return false; | |
| 1045 } | |
| 1046 | |
| 1047 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1057283003:
Remove parts of //cc we aren't using (Closed)
Base URL: git@github.com:domokit/mojo.git@master