Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(68)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: ui/compositor/layer_animation_element.cc

Issue 667923002: Standardize usage of virtual/override/final in ui/ (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « ui/compositor/layer.cc ('k') | ui/compositor/layer_animation_observer.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: ui/compositor/layer_animation_element.cc
diff --git a/ui/compositor/layer_animation_element.cc b/ui/compositor/layer_animation_element.cc
index b74aebcf603c2725eff61b7d3f97abb585463197..3e667dfdc032662f796fb738ce707867add99a51 100644
--- a/ui/compositor/layer_animation_element.cc
+++ b/ui/compositor/layer_animation_element.cc
@@ -32,16 +32,15 @@ class Pause : public LayerAnimationElement {
Pause(AnimatableProperties properties, base::TimeDelta duration)
: LayerAnimationElement(properties, duration) {
}
- virtual ~Pause() {}
+ ~Pause() override {}
private:
- virtual void OnStart(LayerAnimationDelegate* delegate) override {}
- virtual bool OnProgress(double t,
- LayerAnimationDelegate* delegate) override {
+ void OnStart(LayerAnimationDelegate* delegate) override {}
+ bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
return false;
}
- virtual void OnGetTarget(TargetValue* target) const override {}
- virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
+ void OnGetTarget(TargetValue* target) const override {}
+ void OnAbort(LayerAnimationDelegate* delegate) override {}
DISALLOW_COPY_AND_ASSIGN(Pause);
};
@@ -54,24 +53,24 @@ class TransformTransition : public LayerAnimationElement {
: LayerAnimationElement(TRANSFORM, duration),
target_(target) {
}
- virtual ~TransformTransition() {}
+ ~TransformTransition() override {}
protected:
- virtual void OnStart(LayerAnimationDelegate* delegate) override {
+ void OnStart(LayerAnimationDelegate* delegate) override {
start_ = delegate->GetTransformForAnimation();
}
- virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
+ bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
delegate->SetTransformFromAnimation(
gfx::Tween::TransformValueBetween(t, start_, target_));
return true;
}
- virtual void OnGetTarget(TargetValue* target) const override {
+ void OnGetTarget(TargetValue* target) const override {
target->transform = target_;
}
- virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
+ void OnAbort(LayerAnimationDelegate* delegate) override {}
private:
gfx::Transform start_;
@@ -89,23 +88,22 @@ class InterpolatedTransformTransition : public LayerAnimationElement {
: LayerAnimationElement(TRANSFORM, duration),
interpolated_transform_(interpolated_transform) {
}
- virtual ~InterpolatedTransformTransition() {}
+ ~InterpolatedTransformTransition() override {}
protected:
- virtual void OnStart(LayerAnimationDelegate* delegate) override {
- }
+ void OnStart(LayerAnimationDelegate* delegate) override {}
- virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
+ bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
delegate->SetTransformFromAnimation(
interpolated_transform_->Interpolate(static_cast<float>(t)));
return true;
}
- virtual void OnGetTarget(TargetValue* target) const override {
+ void OnGetTarget(TargetValue* target) const override {
target->transform = interpolated_transform_->Interpolate(1.0f);
}
- virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
+ void OnAbort(LayerAnimationDelegate* delegate) override {}
private:
scoped_ptr<InterpolatedTransform> interpolated_transform_;
@@ -121,24 +119,24 @@ class BoundsTransition : public LayerAnimationElement {
: LayerAnimationElement(BOUNDS, duration),
target_(target) {
}
- virtual ~BoundsTransition() {}
+ ~BoundsTransition() override {}
protected:
- virtual void OnStart(LayerAnimationDelegate* delegate) override {
+ void OnStart(LayerAnimationDelegate* delegate) override {
start_ = delegate->GetBoundsForAnimation();
}
- virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
+ bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
delegate->SetBoundsFromAnimation(
gfx::Tween::RectValueBetween(t, start_, target_));
return true;
}
- virtual void OnGetTarget(TargetValue* target) const override {
+ void OnGetTarget(TargetValue* target) const override {
target->bounds = target_;
}
- virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
+ void OnAbort(LayerAnimationDelegate* delegate) override {}
private:
gfx::Rect start_;
@@ -156,24 +154,24 @@ class OpacityTransition : public LayerAnimationElement {
start_(0.0f),
target_(target) {
}
- virtual ~OpacityTransition() {}
+ ~OpacityTransition() override {}
protected:
- virtual void OnStart(LayerAnimationDelegate* delegate) override {
+ void OnStart(LayerAnimationDelegate* delegate) override {
start_ = delegate->GetOpacityForAnimation();
}
- virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
+ bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
delegate->SetOpacityFromAnimation(
gfx::Tween::FloatValueBetween(t, start_, target_));
return true;
}
- virtual void OnGetTarget(TargetValue* target) const override {
+ void OnGetTarget(TargetValue* target) const override {
target->opacity = target_;
}
- virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
+ void OnAbort(LayerAnimationDelegate* delegate) override {}
private:
float start_;
@@ -191,23 +189,23 @@ class VisibilityTransition : public LayerAnimationElement {
start_(false),
target_(target) {
}
- virtual ~VisibilityTransition() {}
+ ~VisibilityTransition() override {}
protected:
- virtual void OnStart(LayerAnimationDelegate* delegate) override {
+ void OnStart(LayerAnimationDelegate* delegate) override {
start_ = delegate->GetVisibilityForAnimation();
}
- virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
+ bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
delegate->SetVisibilityFromAnimation(t == 1.0 ? target_ : start_);
return t == 1.0;
}
- virtual void OnGetTarget(TargetValue* target) const override {
+ void OnGetTarget(TargetValue* target) const override {
target->visibility = target_;
}
- virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
+ void OnAbort(LayerAnimationDelegate* delegate) override {}
private:
bool start_;
@@ -225,24 +223,24 @@ class BrightnessTransition : public LayerAnimationElement {
start_(0.0f),
target_(target) {
}
- virtual ~BrightnessTransition() {}
+ ~BrightnessTransition() override {}
protected:
- virtual void OnStart(LayerAnimationDelegate* delegate) override {
+ void OnStart(LayerAnimationDelegate* delegate) override {
start_ = delegate->GetBrightnessForAnimation();
}
- virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
+ bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
delegate->SetBrightnessFromAnimation(
gfx::Tween::FloatValueBetween(t, start_, target_));
return true;
}
- virtual void OnGetTarget(TargetValue* target) const override {
+ void OnGetTarget(TargetValue* target) const override {
target->brightness = target_;
}
- virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
+ void OnAbort(LayerAnimationDelegate* delegate) override {}
private:
float start_;
@@ -260,24 +258,24 @@ class GrayscaleTransition : public LayerAnimationElement {
start_(0.0f),
target_(target) {
}
- virtual ~GrayscaleTransition() {}
+ ~GrayscaleTransition() override {}
protected:
- virtual void OnStart(LayerAnimationDelegate* delegate) override {
+ void OnStart(LayerAnimationDelegate* delegate) override {
start_ = delegate->GetGrayscaleForAnimation();
}
- virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
+ bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
delegate->SetGrayscaleFromAnimation(
gfx::Tween::FloatValueBetween(t, start_, target_));
return true;
}
- virtual void OnGetTarget(TargetValue* target) const override {
+ void OnGetTarget(TargetValue* target) const override {
target->grayscale = target_;
}
- virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
+ void OnAbort(LayerAnimationDelegate* delegate) override {}
private:
float start_;
@@ -295,24 +293,24 @@ class ColorTransition : public LayerAnimationElement {
start_(SK_ColorBLACK),
target_(target) {
}
- virtual ~ColorTransition() {}
+ ~ColorTransition() override {}
protected:
- virtual void OnStart(LayerAnimationDelegate* delegate) override {
+ void OnStart(LayerAnimationDelegate* delegate) override {
start_ = delegate->GetColorForAnimation();
}
- virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
+ bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
delegate->SetColorFromAnimation(
gfx::Tween::ColorValueBetween(t, start_, target_));
return true;
}
- virtual void OnGetTarget(TargetValue* target) const override {
+ void OnGetTarget(TargetValue* target) const override {
target->color = target_;
}
- virtual void OnAbort(LayerAnimationDelegate* delegate) override {}
+ void OnAbort(LayerAnimationDelegate* delegate) override {}
private:
SkColor start_;
@@ -329,19 +327,16 @@ class ThreadedLayerAnimationElement : public LayerAnimationElement {
base::TimeDelta duration)
: LayerAnimationElement(properties, duration) {
}
- virtual ~ThreadedLayerAnimationElement() {}
+ ~ThreadedLayerAnimationElement() override {}
- virtual bool IsThreaded() const override {
- return (duration() != base::TimeDelta());
- }
+ bool IsThreaded() const override { return (duration() != base::TimeDelta()); }
protected:
explicit ThreadedLayerAnimationElement(const LayerAnimationElement& element)
: LayerAnimationElement(element) {
}
- virtual bool OnProgress(double t,
- LayerAnimationDelegate* delegate) override {
+ bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
if (t < 1.0)
return false;
@@ -353,14 +348,13 @@ class ThreadedLayerAnimationElement : public LayerAnimationElement {
return true;
}
- virtual void OnAbort(LayerAnimationDelegate* delegate) override {
+ void OnAbort(LayerAnimationDelegate* delegate) override {
if (delegate && Started()) {
delegate->RemoveThreadedAnimation(animation_id());
}
}
- virtual void RequestEffectiveStart(
- LayerAnimationDelegate* delegate) override {
+ void RequestEffectiveStart(LayerAnimationDelegate* delegate) override {
DCHECK(animation_group_id());
if (duration() == base::TimeDelta()) {
set_effective_start_time(requested_start_time());
@@ -389,14 +383,14 @@ class ThreadedOpacityTransition : public ThreadedLayerAnimationElement {
start_(0.0f),
target_(target) {
}
- virtual ~ThreadedOpacityTransition() {}
+ ~ThreadedOpacityTransition() override {}
protected:
- virtual void OnStart(LayerAnimationDelegate* delegate) override {
+ void OnStart(LayerAnimationDelegate* delegate) override {
start_ = delegate->GetOpacityForAnimation();
}
- virtual void OnAbort(LayerAnimationDelegate* delegate) override {
+ void OnAbort(LayerAnimationDelegate* delegate) override {
if (delegate && Started()) {
ThreadedLayerAnimationElement::OnAbort(delegate);
delegate->SetOpacityFromAnimation(gfx::Tween::FloatValueBetween(
@@ -406,11 +400,11 @@ class ThreadedOpacityTransition : public ThreadedLayerAnimationElement {
}
}
- virtual void OnEnd(LayerAnimationDelegate* delegate) override {
+ void OnEnd(LayerAnimationDelegate* delegate) override {
delegate->SetOpacityFromAnimation(target_);
}
- virtual scoped_ptr<cc::Animation> CreateCCAnimation() override {
+ scoped_ptr<cc::Animation> CreateCCAnimation() override {
scoped_ptr<cc::AnimationCurve> animation_curve(
new FloatAnimationCurveAdapter(tween_type(),
start_,
@@ -424,7 +418,7 @@ class ThreadedOpacityTransition : public ThreadedLayerAnimationElement {
return animation.Pass();
}
- virtual void OnGetTarget(TargetValue* target) const override {
+ void OnGetTarget(TargetValue* target) const override {
target->opacity = target_;
}
@@ -444,14 +438,14 @@ class ThreadedTransformTransition : public ThreadedLayerAnimationElement {
: ThreadedLayerAnimationElement(TRANSFORM, duration),
target_(target) {
}
- virtual ~ThreadedTransformTransition() {}
+ ~ThreadedTransformTransition() override {}
protected:
- virtual void OnStart(LayerAnimationDelegate* delegate) override {
+ void OnStart(LayerAnimationDelegate* delegate) override {
start_ = delegate->GetTransformForAnimation();
}
- virtual void OnAbort(LayerAnimationDelegate* delegate) override {
+ void OnAbort(LayerAnimationDelegate* delegate) override {
if (delegate && Started()) {
ThreadedLayerAnimationElement::OnAbort(delegate);
delegate->SetTransformFromAnimation(gfx::Tween::TransformValueBetween(
@@ -461,11 +455,11 @@ class ThreadedTransformTransition : public ThreadedLayerAnimationElement {
}
}
- virtual void OnEnd(LayerAnimationDelegate* delegate) override {
+ void OnEnd(LayerAnimationDelegate* delegate) override {
delegate->SetTransformFromAnimation(target_);
}
- virtual scoped_ptr<cc::Animation> CreateCCAnimation() override {
+ scoped_ptr<cc::Animation> CreateCCAnimation() override {
scoped_ptr<cc::AnimationCurve> animation_curve(
new TransformAnimationCurveAdapter(tween_type(),
start_,
@@ -479,7 +473,7 @@ class ThreadedTransformTransition : public ThreadedLayerAnimationElement {
return animation.Pass();
}
- virtual void OnGetTarget(TargetValue* target) const override {
+ void OnGetTarget(TargetValue* target) const override {
target->transform = target_;
}
@@ -502,7 +496,7 @@ class InverseTransformTransition : public ThreadedLayerAnimationElement {
CheckAndCast<const ThreadedTransformTransition*>(
uninverted_transition)) {
}
- virtual ~InverseTransformTransition() {}
+ ~InverseTransformTransition() override {}
static InverseTransformTransition* Clone(const LayerAnimationElement* other) {
const InverseTransformTransition* other_inverse =
@@ -512,7 +506,7 @@ class InverseTransformTransition : public ThreadedLayerAnimationElement {
}
protected:
- virtual void OnStart(LayerAnimationDelegate* delegate) override {
+ void OnStart(LayerAnimationDelegate* delegate) override {
gfx::Transform start(delegate->GetTransformForAnimation());
effective_start_ = base_transform_ * start;
@@ -533,18 +527,18 @@ class InverseTransformTransition : public ThreadedLayerAnimationElement {
base_target_);
}
- virtual void OnAbort(LayerAnimationDelegate* delegate) override {
+ void OnAbort(LayerAnimationDelegate* delegate) override {
if (delegate && Started()) {
ThreadedLayerAnimationElement::OnAbort(delegate);
delegate->SetTransformFromAnimation(ComputeCurrentTransform());
}
}
- virtual void OnEnd(LayerAnimationDelegate* delegate) override {
+ void OnEnd(LayerAnimationDelegate* delegate) override {
delegate->SetTransformFromAnimation(computed_target_transform_);
}
- virtual scoped_ptr<cc::Animation> CreateCCAnimation() override {
+ scoped_ptr<cc::Animation> CreateCCAnimation() override {
scoped_ptr<cc::Animation> animation(
cc::Animation::Create(animation_curve_->Clone(),
animation_id(),
@@ -553,7 +547,7 @@ class InverseTransformTransition : public ThreadedLayerAnimationElement {
return animation.Pass();
}
- virtual void OnGetTarget(TargetValue* target) const override {
+ void OnGetTarget(TargetValue* target) const override {
target->transform = computed_target_transform_;
}
« no previous file with comments | « ui/compositor/layer.cc ('k') | ui/compositor/layer_animation_observer.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698