OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "ui/compositor/layer_animation_element.h" | 5 #include "ui/compositor/layer_animation_element.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/compiler_specific.h" | 9 #include "base/compiler_specific.h" |
10 #include "base/macros.h" | 10 #include "base/macros.h" |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
45 void OnGetTarget(TargetValue* target) const override {} | 45 void OnGetTarget(TargetValue* target) const override {} |
46 void OnAbort(LayerAnimationDelegate* delegate) override {} | 46 void OnAbort(LayerAnimationDelegate* delegate) override {} |
47 | 47 |
48 DISALLOW_COPY_AND_ASSIGN(Pause); | 48 DISALLOW_COPY_AND_ASSIGN(Pause); |
49 }; | 49 }; |
50 | 50 |
51 // InterpolatedTransformTransition --------------------------------------------- | 51 // InterpolatedTransformTransition --------------------------------------------- |
52 | 52 |
53 class InterpolatedTransformTransition : public LayerAnimationElement { | 53 class InterpolatedTransformTransition : public LayerAnimationElement { |
54 public: | 54 public: |
55 InterpolatedTransformTransition(InterpolatedTransform* interpolated_transform, | 55 InterpolatedTransformTransition( |
56 base::TimeDelta duration) | 56 std::unique_ptr<InterpolatedTransform> interpolated_transform, |
57 base::TimeDelta duration) | |
57 : LayerAnimationElement(TRANSFORM, duration), | 58 : LayerAnimationElement(TRANSFORM, duration), |
58 interpolated_transform_(interpolated_transform) { | 59 interpolated_transform_(std::move(interpolated_transform)) {} |
59 } | |
60 ~InterpolatedTransformTransition() override {} | 60 ~InterpolatedTransformTransition() override {} |
61 | 61 |
62 protected: | 62 protected: |
63 void OnStart(LayerAnimationDelegate* delegate) override {} | 63 void OnStart(LayerAnimationDelegate* delegate) override {} |
64 | 64 |
65 bool OnProgress(double t, LayerAnimationDelegate* delegate) override { | 65 bool OnProgress(double t, LayerAnimationDelegate* delegate) override { |
66 delegate->SetTransformFromAnimation( | 66 delegate->SetTransformFromAnimation( |
67 interpolated_transform_->Interpolate(static_cast<float>(t))); | 67 interpolated_transform_->Interpolate(static_cast<float>(t))); |
68 return true; | 68 return true; |
69 } | 69 } |
(...skipping 521 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
591 return duration / kNonZeroDurationScaleDivisor; | 591 return duration / kNonZeroDurationScaleDivisor; |
592 case ScopedAnimationDurationScaleMode::ZERO_DURATION: | 592 case ScopedAnimationDurationScaleMode::ZERO_DURATION: |
593 return base::TimeDelta(); | 593 return base::TimeDelta(); |
594 default: | 594 default: |
595 NOTREACHED(); | 595 NOTREACHED(); |
596 return base::TimeDelta(); | 596 return base::TimeDelta(); |
597 } | 597 } |
598 } | 598 } |
599 | 599 |
600 // static | 600 // static |
601 LayerAnimationElement* LayerAnimationElement::CreateTransformElement( | 601 std::unique_ptr<LayerAnimationElement> |
602 const gfx::Transform& transform, | 602 LayerAnimationElement::CreateTransformElement(const gfx::Transform& transform, |
603 base::TimeDelta duration) { | 603 base::TimeDelta duration) { |
604 return new ThreadedTransformTransition(transform, duration); | 604 return base::MakeUnique<ThreadedTransformTransition>(transform, duration); |
loyso (OOO)
2016/12/13 02:24:49
Looks like this file doesn't
#include "base/memor
| |
605 } | 605 } |
606 | 606 |
607 // static | 607 // static |
608 LayerAnimationElement* | 608 std::unique_ptr<LayerAnimationElement> |
609 LayerAnimationElement::CreateInterpolatedTransformElement( | 609 LayerAnimationElement::CreateInterpolatedTransformElement( |
610 InterpolatedTransform* interpolated_transform, | 610 std::unique_ptr<InterpolatedTransform> interpolated_transform, |
611 base::TimeDelta duration) { | 611 base::TimeDelta duration) { |
612 return new InterpolatedTransformTransition(interpolated_transform, duration); | 612 return base::MakeUnique<InterpolatedTransformTransition>( |
613 std::move(interpolated_transform), duration); | |
613 } | 614 } |
614 | 615 |
615 // static | 616 // static |
616 LayerAnimationElement* LayerAnimationElement::CreateBoundsElement( | 617 std::unique_ptr<LayerAnimationElement> |
617 const gfx::Rect& bounds, | 618 LayerAnimationElement::CreateBoundsElement(const gfx::Rect& bounds, |
618 base::TimeDelta duration) { | 619 base::TimeDelta duration) { |
619 return new BoundsTransition(bounds, duration); | 620 return base::MakeUnique<BoundsTransition>(bounds, duration); |
620 } | 621 } |
621 | 622 |
622 // static | 623 // static |
623 LayerAnimationElement* LayerAnimationElement::CreateOpacityElement( | 624 std::unique_ptr<LayerAnimationElement> |
624 float opacity, | 625 LayerAnimationElement::CreateOpacityElement(float opacity, |
625 base::TimeDelta duration) { | 626 base::TimeDelta duration) { |
626 return new ThreadedOpacityTransition(opacity, duration); | 627 return base::MakeUnique<ThreadedOpacityTransition>(opacity, duration); |
627 } | 628 } |
628 | 629 |
629 // static | 630 // static |
630 LayerAnimationElement* LayerAnimationElement::CreateVisibilityElement( | 631 std::unique_ptr<LayerAnimationElement> |
631 bool visibility, | 632 LayerAnimationElement::CreateVisibilityElement(bool visibility, |
632 base::TimeDelta duration) { | 633 base::TimeDelta duration) { |
633 return new VisibilityTransition(visibility, duration); | 634 return base::MakeUnique<VisibilityTransition>(visibility, duration); |
634 } | 635 } |
635 | 636 |
636 // static | 637 // static |
637 LayerAnimationElement* LayerAnimationElement::CreateBrightnessElement( | 638 std::unique_ptr<LayerAnimationElement> |
638 float brightness, | 639 LayerAnimationElement::CreateBrightnessElement(float brightness, |
639 base::TimeDelta duration) { | 640 base::TimeDelta duration) { |
640 return new BrightnessTransition(brightness, duration); | 641 return base::MakeUnique<BrightnessTransition>(brightness, duration); |
641 } | 642 } |
642 | 643 |
643 // static | 644 // static |
644 LayerAnimationElement* LayerAnimationElement::CreateGrayscaleElement( | 645 std::unique_ptr<LayerAnimationElement> |
645 float grayscale, | 646 LayerAnimationElement::CreateGrayscaleElement(float grayscale, |
646 base::TimeDelta duration) { | 647 base::TimeDelta duration) { |
647 return new GrayscaleTransition(grayscale, duration); | 648 return base::MakeUnique<GrayscaleTransition>(grayscale, duration); |
648 } | 649 } |
649 | 650 |
650 // static | 651 // static |
651 LayerAnimationElement* LayerAnimationElement::CreatePauseElement( | 652 std::unique_ptr<LayerAnimationElement> |
652 AnimatableProperties properties, | 653 LayerAnimationElement::CreatePauseElement(AnimatableProperties properties, |
653 base::TimeDelta duration) { | 654 base::TimeDelta duration) { |
654 return new Pause(properties, duration); | 655 return base::MakeUnique<Pause>(properties, duration); |
655 } | 656 } |
656 | 657 |
657 // static | 658 // static |
658 LayerAnimationElement* LayerAnimationElement::CreateColorElement( | 659 std::unique_ptr<LayerAnimationElement> |
659 SkColor color, | 660 LayerAnimationElement::CreateColorElement(SkColor color, |
660 base::TimeDelta duration) { | 661 base::TimeDelta duration) { |
661 return new ColorTransition(color, duration); | 662 return base::MakeUnique<ColorTransition>(color, duration); |
662 } | 663 } |
663 | 664 |
664 } // namespace ui | 665 } // namespace ui |
OLD | NEW |