Update To 11.40.268.0

[platform/framework/web/crosswalk.git] / src / ui / compositor / layer_animation_element.cc

diff --git a/src/ui/compositor/layer_animation_element.cc b/src/ui/compositor/layer_animation_element.cc
index ade7765..3e667df 100644 (file)
--- a/src/ui/compositor/layer_animation_element.cc
+++ b/src/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_;
   }