ui/compositor/layer_animation_element.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_element.h"
   6
   7 #include "base/compiler_specific.h"
   8 #include "cc/animation/animation.h"
   9 #include "cc/animation/animation_id_provider.h"
  10 #include "ui/base/animation/tween.h"
  11 #include "ui/compositor/float_animation_curve_adapter.h"
  12 #include "ui/compositor/layer.h"
  13 #include "ui/compositor/layer_animation_delegate.h"
  14 #include "ui/compositor/layer_animator.h"
  15 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
  16 #include "ui/compositor/transform_animation_curve_adapter.h"
  17 #include "ui/gfx/interpolated_transform.h"
  18
  19 namespace ui {
  20
  21 namespace {
  22
  23 // The factor by which duration is scaled up or down when
  24 // ScopedAnimationDurationScaleMode::duration_scale_mode() is SLOW_DURATION or
  25 // FAST_DURATION.
  26 const int kSlowDurationScaleFactor = 4;
  27 const int kFastDurationScaleFactor = 4;
  28
  29 // Pause -----------------------------------------------------------------------
  30 class Pause : public LayerAnimationElement {
  31  public:
  32   Pause(const AnimatableProperties& properties, base::TimeDelta duration)
  33       : LayerAnimationElement(properties, duration) {
  34   }
  35   virtual ~Pause() {}
  36
  37  private:
  38   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {}
  39   virtual bool OnProgress(double t,
  40                           LayerAnimationDelegate* delegate) OVERRIDE {
  41     return false;
  42   }
  43   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {}
  44   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
  45
  46   DISALLOW_COPY_AND_ASSIGN(Pause);
  47 };
  48
  49 // TransformTransition ---------------------------------------------------------
  50
  51 class TransformTransition : public LayerAnimationElement {
  52  public:
  53     TransformTransition(const gfx::Transform& target, base::TimeDelta duration)
  54       : LayerAnimationElement(GetProperties(), duration),
  55         target_(target) {
  56   }
  57   virtual ~TransformTransition() {}
  58
  59  protected:
  60   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
  61     start_ = delegate->GetTransformForAnimation();
  62   }
  63
  64   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
  65     delegate->SetTransformFromAnimation(
  66         Tween::ValueBetween(t, start_, target_));
  67     return true;
  68   }
  69
  70   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
  71     target->transform = target_;
  72   }
  73
  74   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
  75
  76  private:
  77   static AnimatableProperties GetProperties() {
  78     AnimatableProperties properties;
  79     properties.insert(LayerAnimationElement::TRANSFORM);
  80     return properties;
  81   }
  82
  83   gfx::Transform start_;
  84   const gfx::Transform target_;
  85
  86   DISALLOW_COPY_AND_ASSIGN(TransformTransition);
  87 };
  88
  89 // InterpolatedTransformTransition ---------------------------------------------
  90
  91 class InterpolatedTransformTransition : public LayerAnimationElement {
  92  public:
  93   InterpolatedTransformTransition(InterpolatedTransform* interpolated_transform,
  94                                   base::TimeDelta duration)
  95       : LayerAnimationElement(GetProperties(), duration),
  96         interpolated_transform_(interpolated_transform) {
  97   }
  98   virtual ~InterpolatedTransformTransition() {}
  99
 100  protected:
 101   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
 102   }
 103
 104   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
 105     delegate->SetTransformFromAnimation(
 106         interpolated_transform_->Interpolate(static_cast<float>(t)));
 107     return true;
 108   }
 109
 110   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
 111     target->transform = interpolated_transform_->Interpolate(1.0f);
 112   }
 113
 114   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 115
 116  private:
 117   static AnimatableProperties GetProperties() {
 118     AnimatableProperties properties;
 119     properties.insert(LayerAnimationElement::TRANSFORM);
 120     return properties;
 121   }
 122
 123   scoped_ptr<InterpolatedTransform> interpolated_transform_;
 124
 125   DISALLOW_COPY_AND_ASSIGN(InterpolatedTransformTransition);
 126 };
 127
 128 // BoundsTransition ------------------------------------------------------------
 129
 130 class BoundsTransition : public LayerAnimationElement {
 131  public:
 132   BoundsTransition(const gfx::Rect& target, base::TimeDelta duration)
 133       : LayerAnimationElement(GetProperties(), duration),
 134         target_(target) {
 135   }
 136   virtual ~BoundsTransition() {}
 137
 138  protected:
 139   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
 140     start_ = delegate->GetBoundsForAnimation();
 141   }
 142
 143   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
 144     delegate->SetBoundsFromAnimation(Tween::ValueBetween(t, start_, target_));
 145     return true;
 146   }
 147
 148   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
 149     target->bounds = target_;
 150   }
 151
 152   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 153
 154  private:
 155   static AnimatableProperties GetProperties() {
 156     AnimatableProperties properties;
 157     properties.insert(LayerAnimationElement::BOUNDS);
 158     return properties;
 159   }
 160
 161   gfx::Rect start_;
 162   const gfx::Rect target_;
 163
 164   DISALLOW_COPY_AND_ASSIGN(BoundsTransition);
 165 };
 166
 167 // OpacityTransition -----------------------------------------------------------
 168
 169 class OpacityTransition : public LayerAnimationElement {
 170  public:
 171   OpacityTransition(float target, base::TimeDelta duration)
 172       : LayerAnimationElement(GetProperties(), duration),
 173         start_(0.0f),
 174         target_(target) {
 175   }
 176   virtual ~OpacityTransition() {}
 177
 178  protected:
 179   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
 180     start_ = delegate->GetOpacityForAnimation();
 181   }
 182
 183   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
 184     delegate->SetOpacityFromAnimation(Tween::ValueBetween(t, start_, target_));
 185     return true;
 186   }
 187
 188   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
 189     target->opacity = target_;
 190   }
 191
 192   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 193
 194  private:
 195   static AnimatableProperties GetProperties() {
 196     AnimatableProperties properties;
 197     properties.insert(LayerAnimationElement::OPACITY);
 198     return properties;
 199   }
 200
 201   float start_;
 202   const float target_;
 203
 204   DISALLOW_COPY_AND_ASSIGN(OpacityTransition);
 205 };
 206
 207 // VisibilityTransition --------------------------------------------------------
 208
 209 class VisibilityTransition : public LayerAnimationElement {
 210  public:
 211   VisibilityTransition(bool target, base::TimeDelta duration)
 212       : LayerAnimationElement(GetProperties(), duration),
 213         start_(false),
 214         target_(target) {
 215   }
 216   virtual ~VisibilityTransition() {}
 217
 218  protected:
 219   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
 220     start_ = delegate->GetVisibilityForAnimation();
 221   }
 222
 223   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
 224     delegate->SetVisibilityFromAnimation(t == 1.0 ? target_ : start_);
 225     return t == 1.0;
 226   }
 227
 228   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
 229     target->visibility = target_;
 230   }
 231
 232   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 233
 234  private:
 235   static AnimatableProperties GetProperties() {
 236     AnimatableProperties properties;
 237     properties.insert(LayerAnimationElement::VISIBILITY);
 238     return properties;
 239   }
 240
 241   bool start_;
 242   const bool target_;
 243
 244   DISALLOW_COPY_AND_ASSIGN(VisibilityTransition);
 245 };
 246
 247 // BrightnessTransition --------------------------------------------------------
 248
 249 class BrightnessTransition : public LayerAnimationElement {
 250  public:
 251   BrightnessTransition(float target, base::TimeDelta duration)
 252       : LayerAnimationElement(GetProperties(), duration),
 253         start_(0.0f),
 254         target_(target) {
 255   }
 256   virtual ~BrightnessTransition() {}
 257
 258  protected:
 259   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
 260     start_ = delegate->GetBrightnessForAnimation();
 261   }
 262
 263   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
 264     delegate->SetBrightnessFromAnimation(
 265         Tween::ValueBetween(t, start_, target_));
 266     return true;
 267   }
 268
 269   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
 270     target->brightness = target_;
 271   }
 272
 273   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 274
 275  private:
 276   static AnimatableProperties GetProperties() {
 277     AnimatableProperties properties;
 278     properties.insert(LayerAnimationElement::BRIGHTNESS);
 279     return properties;
 280   }
 281
 282   float start_;
 283   const float target_;
 284
 285   DISALLOW_COPY_AND_ASSIGN(BrightnessTransition);
 286 };
 287
 288 // GrayscaleTransition ---------------------------------------------------------
 289
 290 class GrayscaleTransition : public LayerAnimationElement {
 291  public:
 292   GrayscaleTransition(float target, base::TimeDelta duration)
 293       : LayerAnimationElement(GetProperties(), duration),
 294         start_(0.0f),
 295         target_(target) {
 296   }
 297   virtual ~GrayscaleTransition() {}
 298
 299  protected:
 300   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
 301     start_ = delegate->GetGrayscaleForAnimation();
 302   }
 303
 304   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
 305     delegate->SetGrayscaleFromAnimation(
 306         Tween::ValueBetween(t, start_, target_));
 307     return true;
 308   }
 309
 310   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
 311     target->grayscale = target_;
 312   }
 313
 314   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 315
 316  private:
 317   static AnimatableProperties GetProperties() {
 318     AnimatableProperties properties;
 319     properties.insert(LayerAnimationElement::GRAYSCALE);
 320     return properties;
 321   }
 322
 323   float start_;
 324   const float target_;
 325
 326   DISALLOW_COPY_AND_ASSIGN(GrayscaleTransition);
 327 };
 328
 329 // ColorTransition -------------------------------------------------------------
 330
 331 class ColorTransition : public LayerAnimationElement {
 332  public:
 333   ColorTransition(SkColor target, base::TimeDelta duration)
 334       : LayerAnimationElement(GetProperties(), duration),
 335         start_(SK_ColorBLACK),
 336         target_(target) {
 337   }
 338   virtual ~ColorTransition() {}
 339
 340  protected:
 341   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
 342     start_ = delegate->GetColorForAnimation();
 343   }
 344
 345   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
 346     delegate->SetColorFromAnimation(
 347         SkColorSetARGB(
 348             Tween::ValueBetween(t,
 349                                 static_cast<int>(SkColorGetA(start_)),
 350                                 static_cast<int>(SkColorGetA(target_))),
 351             Tween::ValueBetween(t,
 352                                 static_cast<int>(SkColorGetR(start_)),
 353                                 static_cast<int>(SkColorGetR(target_))),
 354             Tween::ValueBetween(t,
 355                                 static_cast<int>(SkColorGetG(start_)),
 356                                 static_cast<int>(SkColorGetG(target_))),
 357             Tween::ValueBetween(t,
 358                                 static_cast<int>(SkColorGetB(start_)),
 359                                 static_cast<int>(SkColorGetB(target_)))));
 360     return true;
 361   }
 362
 363   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
 364     target->color = target_;
 365   }
 366
 367   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 368
 369  private:
 370   static AnimatableProperties GetProperties() {
 371     AnimatableProperties properties;
 372     properties.insert(LayerAnimationElement::COLOR);
 373     return properties;
 374   }
 375
 376   SkColor start_;
 377   const SkColor target_;
 378
 379   DISALLOW_COPY_AND_ASSIGN(ColorTransition);
 380 };
 381
 382 // ThreadedLayerAnimationElement -----------------------------------------------
 383
 384 class ThreadedLayerAnimationElement : public LayerAnimationElement {
 385  public:
 386   ThreadedLayerAnimationElement(const AnimatableProperties& properties,
 387                                 base::TimeDelta duration)
 388       : LayerAnimationElement(properties, duration) {
 389   }
 390   virtual ~ThreadedLayerAnimationElement() {}
 391
 392   virtual bool IsThreaded() const OVERRIDE {
 393     return (duration() != base::TimeDelta());
 394   }
 395
 396  protected:
 397   virtual bool OnProgress(double t,
 398                           LayerAnimationDelegate* delegate) OVERRIDE {
 399     if (t < 1.0)
 400       return false;
 401
 402     if (Started()) {
 403       delegate->RemoveThreadedAnimation(animation_id());
 404     }
 405
 406     OnEnd(delegate);
 407     return true;
 408   }
 409
 410   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {
 411     if (delegate && Started()) {
 412       delegate->RemoveThreadedAnimation(animation_id());
 413     }
 414   }
 415
 416   virtual void RequestEffectiveStart(
 417       LayerAnimationDelegate* delegate) OVERRIDE {
 418     DCHECK(animation_group_id());
 419     if (duration() == base::TimeDelta()) {
 420       set_effective_start_time(requested_start_time());
 421       return;
 422     }
 423     set_effective_start_time(base::TimeTicks());
 424     scoped_ptr<cc::Animation> animation = CreateCCAnimation();
 425     animation->set_needs_synchronized_start_time(true);
 426     delegate->AddThreadedAnimation(animation.Pass());
 427   }
 428
 429   virtual void OnEnd(LayerAnimationDelegate* delegate) = 0;
 430
 431   virtual scoped_ptr<cc::Animation> CreateCCAnimation() = 0;
 432
 433  private:
 434   DISALLOW_COPY_AND_ASSIGN(ThreadedLayerAnimationElement);
 435 };
 436
 437 // ThreadedOpacityTransition ---------------------------------------------------
 438
 439 class ThreadedOpacityTransition : public ThreadedLayerAnimationElement {
 440  public:
 441   ThreadedOpacityTransition(float target, base::TimeDelta duration)
 442       : ThreadedLayerAnimationElement(GetProperties(), duration),
 443         start_(0.0f),
 444         target_(target) {
 445   }
 446   virtual ~ThreadedOpacityTransition() {}
 447
 448  protected:
 449   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
 450     start_ = delegate->GetOpacityForAnimation();
 451   }
 452
 453   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {
 454     if (delegate && Started()) {
 455       ThreadedLayerAnimationElement::OnAbort(delegate);
 456       delegate->SetOpacityFromAnimation(Tween::ValueBetween(
 457             Tween::CalculateValue(tween_type(), last_progressed_fraction()),
 458             start_,
 459             target_));
 460     }
 461   }
 462
 463   virtual void OnEnd(LayerAnimationDelegate* delegate) OVERRIDE {
 464     delegate->SetOpacityFromAnimation(target_);
 465   }
 466
 467   virtual scoped_ptr<cc::Animation> CreateCCAnimation() OVERRIDE {
 468     scoped_ptr<cc::AnimationCurve> animation_curve(
 469         new FloatAnimationCurveAdapter(tween_type(),
 470                                        start_,
 471                                        target_,
 472                                        duration()));
 473     scoped_ptr<cc::Animation> animation(
 474         cc::Animation::Create(animation_curve.Pass(),
 475                               animation_id(),
 476                               animation_group_id(),
 477                               cc::Animation::Opacity));
 478     return animation.Pass();
 479   }
 480
 481   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
 482     target->opacity = target_;
 483   }
 484
 485  private:
 486   static AnimatableProperties GetProperties() {
 487     AnimatableProperties properties;
 488     properties.insert(LayerAnimationElement::OPACITY);
 489     return properties;
 490   }
 491
 492   float start_;
 493   const float target_;
 494
 495   DISALLOW_COPY_AND_ASSIGN(ThreadedOpacityTransition);
 496 };
 497
 498 // ThreadedTransformTransition -------------------------------------------------
 499
 500 class ThreadedTransformTransition : public ThreadedLayerAnimationElement {
 501  public:
 502   ThreadedTransformTransition(const gfx::Transform& target,
 503                               base::TimeDelta duration)
 504       : ThreadedLayerAnimationElement(GetProperties(), duration),
 505         target_(target) {
 506   }
 507   virtual ~ThreadedTransformTransition() {}
 508
 509  protected:
 510   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
 511     start_ = delegate->GetTransformForAnimation();
 512     float device_scale_factor = delegate->GetDeviceScaleFactor();
 513     cc_start_ = Layer::ConvertTransformToCCTransform(start_,
 514                                                      device_scale_factor);
 515     cc_target_ = Layer::ConvertTransformToCCTransform(target_,
 516                                                       device_scale_factor);
 517   }
 518
 519   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {
 520     if (delegate && Started()) {
 521       ThreadedLayerAnimationElement::OnAbort(delegate);
 522       delegate->SetTransformFromAnimation(Tween::ValueBetween(
 523           Tween::CalculateValue(tween_type(), last_progressed_fraction()),
 524           start_,
 525           target_));
 526     }
 527   }
 528
 529   virtual void OnEnd(LayerAnimationDelegate* delegate) OVERRIDE {
 530     delegate->SetTransformFromAnimation(target_);
 531   }
 532
 533   virtual scoped_ptr<cc::Animation> CreateCCAnimation() OVERRIDE {
 534     scoped_ptr<cc::AnimationCurve> animation_curve(
 535         new TransformAnimationCurveAdapter(tween_type(),
 536                                            cc_start_,
 537                                            cc_target_,
 538                                            duration()));
 539     scoped_ptr<cc::Animation> animation(
 540         cc::Animation::Create(animation_curve.Pass(),
 541                               animation_id(),
 542                               animation_group_id(),
 543                               cc::Animation::Transform));
 544     return animation.Pass();
 545   }
 546
 547   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
 548     target->transform = target_;
 549   }
 550
 551  private:
 552   static AnimatableProperties GetProperties() {
 553     AnimatableProperties properties;
 554     properties.insert(LayerAnimationElement::TRANSFORM);
 555     return properties;
 556   }
 557
 558   gfx::Transform start_;
 559   gfx::Transform cc_start_;
 560   const gfx::Transform target_;
 561   gfx::Transform cc_target_;
 562
 563   DISALLOW_COPY_AND_ASSIGN(ThreadedTransformTransition);
 564 };
 565
 566 }  // namespace
 567
 568 // LayerAnimationElement::TargetValue ------------------------------------------
 569
 570 LayerAnimationElement::TargetValue::TargetValue()
 571     : opacity(0.0f),
 572       visibility(false),
 573       brightness(0.0f),
 574       grayscale(0.0f),
 575       color(SK_ColorBLACK) {
 576 }
 577
 578 LayerAnimationElement::TargetValue::TargetValue(
 579     const LayerAnimationDelegate* delegate)
 580     : bounds(delegate ? delegate->GetBoundsForAnimation() : gfx::Rect()),
 581       transform(delegate ?
 582                 delegate->GetTransformForAnimation() : gfx::Transform()),
 583       opacity(delegate ? delegate->GetOpacityForAnimation() : 0.0f),
 584       visibility(delegate ? delegate->GetVisibilityForAnimation() : false),
 585       brightness(delegate ? delegate->GetBrightnessForAnimation() : 0.0f),
 586       grayscale(delegate ? delegate->GetGrayscaleForAnimation() : 0.0f),
 587       color(delegate ? delegate->GetColorForAnimation() : 0.0f) {
 588 }
 589
 590 // LayerAnimationElement -------------------------------------------------------
 591
 592 LayerAnimationElement::LayerAnimationElement(
 593     const AnimatableProperties& properties,
 594     base::TimeDelta duration)
 595     : first_frame_(true),
 596       properties_(properties),
 597       duration_(GetEffectiveDuration(duration)),
 598       tween_type_(Tween::LINEAR),
 599       animation_id_(cc::AnimationIdProvider::NextAnimationId()),
 600       animation_group_id_(0),
 601       last_progressed_fraction_(0.0) {
 602 }
 603
 604 LayerAnimationElement::~LayerAnimationElement() {
 605 }
 606
 607 void LayerAnimationElement::Start(LayerAnimationDelegate* delegate,
 608                                   int animation_group_id) {
 609   DCHECK(requested_start_time_ != base::TimeTicks());
 610   DCHECK(first_frame_);
 611   animation_group_id_ = animation_group_id;
 612   last_progressed_fraction_ = 0.0;
 613   OnStart(delegate);
 614   RequestEffectiveStart(delegate);
 615   first_frame_ = false;
 616 }
 617
 618 bool LayerAnimationElement::Progress(base::TimeTicks now,
 619                                      LayerAnimationDelegate* delegate) {
 620   DCHECK(requested_start_time_ != base::TimeTicks());
 621   DCHECK(!first_frame_);
 622
 623   bool need_draw;
 624   double t = 1.0;
 625
 626   if ((effective_start_time_ == base::TimeTicks()) ||
 627       (now < effective_start_time_))  {
 628     // This hasn't actually started yet.
 629     need_draw = false;
 630     last_progressed_fraction_ = 0.0;
 631     return need_draw;
 632   }
 633
 634   base::TimeDelta elapsed = now - effective_start_time_;
 635   if ((duration_ > base::TimeDelta()) && (elapsed < duration_))
 636     t = elapsed.InMillisecondsF() / duration_.InMillisecondsF();
 637   need_draw = OnProgress(Tween::CalculateValue(tween_type_, t), delegate);
 638   first_frame_ = t == 1.0;
 639   last_progressed_fraction_ = t;
 640   return need_draw;
 641 }
 642
 643 bool LayerAnimationElement::IsFinished(base::TimeTicks time,
 644                                        base::TimeDelta* total_duration) {
 645   // If an effective start has been requested but the effective start time
 646   // hasn't yet been set, the animation is not finished, regardless of the
 647   // value of |time|.
 648   if (!first_frame_ && (effective_start_time_ == base::TimeTicks()))
 649     return false;
 650
 651   base::TimeDelta queueing_delay;
 652   if (!first_frame_)
 653     queueing_delay = effective_start_time_ - requested_start_time_;
 654
 655   base::TimeDelta elapsed = time - requested_start_time_;
 656   if (elapsed >= duration_ + queueing_delay) {
 657     *total_duration = duration_ + queueing_delay;
 658     return true;
 659   }
 660   return false;
 661 }
 662
 663 bool LayerAnimationElement::ProgressToEnd(LayerAnimationDelegate* delegate) {
 664   if (first_frame_)
 665     OnStart(delegate);
 666   bool need_draw = OnProgress(1.0, delegate);
 667   last_progressed_fraction_ = 1.0;
 668   first_frame_ = true;
 669   return need_draw;
 670 }
 671
 672 void LayerAnimationElement::GetTargetValue(TargetValue* target) const {
 673   OnGetTarget(target);
 674 }
 675
 676 bool LayerAnimationElement::IsThreaded() const {
 677   return false;
 678 }
 679
 680 void LayerAnimationElement::Abort(LayerAnimationDelegate* delegate) {
 681   OnAbort(delegate);
 682   first_frame_ = true;
 683 }
 684
 685 void LayerAnimationElement::RequestEffectiveStart(
 686     LayerAnimationDelegate* delegate) {
 687   DCHECK(requested_start_time_ != base::TimeTicks());
 688   effective_start_time_ = requested_start_time_;
 689 }
 690
 691 // static
 692 LayerAnimationElement::AnimatableProperty
 693 LayerAnimationElement::ToAnimatableProperty(
 694     cc::Animation::TargetProperty property) {
 695   switch (property) {
 696     case cc::Animation::Transform:
 697       return TRANSFORM;
 698     case cc::Animation::Opacity:
 699       return OPACITY;
 700     default:
 701       NOTREACHED();
 702       return AnimatableProperty();
 703   }
 704 }
 705
 706 // static
 707 base::TimeDelta LayerAnimationElement::GetEffectiveDuration(
 708     const base::TimeDelta& duration) {
 709   switch (ScopedAnimationDurationScaleMode::duration_scale_mode()) {
 710     case ScopedAnimationDurationScaleMode::NORMAL_DURATION:
 711       return duration;
 712     case ScopedAnimationDurationScaleMode::FAST_DURATION:
 713       return duration / kFastDurationScaleFactor;
 714     case ScopedAnimationDurationScaleMode::SLOW_DURATION:
 715       return duration * kSlowDurationScaleFactor;
 716     case ScopedAnimationDurationScaleMode::ZERO_DURATION:
 717       return base::TimeDelta();
 718     default:
 719       NOTREACHED();
 720       return base::TimeDelta();
 721   }
 722 }
 723
 724 // static
 725 LayerAnimationElement* LayerAnimationElement::CreateTransformElement(
 726     const gfx::Transform& transform,
 727     base::TimeDelta duration) {
 728   return new ThreadedTransformTransition(transform, duration);
 729 }
 730
 731 // static
 732 LayerAnimationElement*
 733 LayerAnimationElement::CreateInterpolatedTransformElement(
 734     InterpolatedTransform* interpolated_transform,
 735     base::TimeDelta duration) {
 736   return new InterpolatedTransformTransition(interpolated_transform, duration);
 737 }
 738
 739 // static
 740 LayerAnimationElement* LayerAnimationElement::CreateBoundsElement(
 741     const gfx::Rect& bounds,
 742     base::TimeDelta duration) {
 743   return new BoundsTransition(bounds, duration);
 744 }
 745
 746 // static
 747 LayerAnimationElement* LayerAnimationElement::CreateOpacityElement(
 748     float opacity,
 749     base::TimeDelta duration) {
 750   return new ThreadedOpacityTransition(opacity, duration);
 751 }
 752
 753 // static
 754 LayerAnimationElement* LayerAnimationElement::CreateVisibilityElement(
 755     bool visibility,
 756     base::TimeDelta duration) {
 757   return new VisibilityTransition(visibility, duration);
 758 }
 759
 760 // static
 761 LayerAnimationElement* LayerAnimationElement::CreateBrightnessElement(
 762     float brightness,
 763     base::TimeDelta duration) {
 764   return new BrightnessTransition(brightness, duration);
 765 }
 766
 767 // static
 768 LayerAnimationElement* LayerAnimationElement::CreateGrayscaleElement(
 769     float grayscale,
 770     base::TimeDelta duration) {
 771   return new GrayscaleTransition(grayscale, duration);
 772 }
 773
 774 // static
 775 LayerAnimationElement* LayerAnimationElement::CreatePauseElement(
 776     const AnimatableProperties& properties,
 777     base::TimeDelta duration) {
 778   return new Pause(properties, duration);
 779 }
 780
 781 // static
 782 LayerAnimationElement* LayerAnimationElement::CreateColorElement(
 783     SkColor color,
 784     base::TimeDelta duration) {
 785   return new ColorTransition(color, duration);
 786 }
 787
 788 }  // namespace ui