Check target value

ui/compositor/layer_animation_element.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/compositor/layer_animation_element.h"
 
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
@@ skipping 26 matching lines @@
   }
   ~Pause() override {}
 
  private:
   void OnStart(LayerAnimationDelegate* delegate) override {}
   bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
     return false;
   }
   void OnGetTarget(TargetValue* target) const override {}
   void OnAbort(LayerAnimationDelegate* delegate) override {}
+  bool AreStartAndTargetSame() override {
+    return false;
+  }
 
   DISALLOW_COPY_AND_ASSIGN(Pause);
 };
 
 // InterpolatedTransformTransition ---------------------------------------------
 
 class InterpolatedTransformTransition : public LayerAnimationElement {
  public:
   InterpolatedTransformTransition(InterpolatedTransform* interpolated_transform,
                                   base::TimeDelta duration)
@@ skipping 10 matching lines @@
         interpolated_transform_->Interpolate(static_cast<float>(t)));
     return true;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->transform = interpolated_transform_->Interpolate(1.0f);
   }
 
   void OnAbort(LayerAnimationDelegate* delegate) override {}
 
+  bool AreStartAndTargetSame() override {
+    return false;
+  }
+
  private:
   std::unique_ptr<InterpolatedTransform> interpolated_transform_;
 
   DISALLOW_COPY_AND_ASSIGN(InterpolatedTransformTransition);
 };
 
 // BoundsTransition ------------------------------------------------------------
 
 class BoundsTransition : public LayerAnimationElement {
  public:
@@ skipping 13 matching lines @@
         gfx::Tween::RectValueBetween(t, start_, target_));
     return true;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->bounds = target_;
   }
 
   void OnAbort(LayerAnimationDelegate* delegate) override {}
 
+  bool AreStartAndTargetSame() override {
+    return start_ == target_;
+  }
+
  private:
   gfx::Rect start_;
   const gfx::Rect target_;
 
   DISALLOW_COPY_AND_ASSIGN(BoundsTransition);
 };
 
 // VisibilityTransition --------------------------------------------------------
 
 class VisibilityTransition : public LayerAnimationElement {
@@ skipping 14 matching lines @@
     delegate->SetVisibilityFromAnimation(t == 1.0 ? target_ : start_);
     return t == 1.0;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->visibility = target_;
   }
 
   void OnAbort(LayerAnimationDelegate* delegate) override {}
 
+  bool AreStartAndTargetSame() override {
+    return start_ == target_;
+  }
+
  private:
   bool start_;
   const bool target_;
 
   DISALLOW_COPY_AND_ASSIGN(VisibilityTransition);
 };
 
 // BrightnessTransition --------------------------------------------------------
 
 class BrightnessTransition : public LayerAnimationElement {
@@ skipping 15 matching lines @@
         gfx::Tween::FloatValueBetween(t, start_, target_));
     return true;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->brightness = target_;
   }
 
   void OnAbort(LayerAnimationDelegate* delegate) override {}
 
+  bool AreStartAndTargetSame() override {
+    return start_ == target_;
+  }
+
  private:
   float start_;
   const float target_;
 
   DISALLOW_COPY_AND_ASSIGN(BrightnessTransition);
 };
 
 // GrayscaleTransition ---------------------------------------------------------
 
 class GrayscaleTransition : public LayerAnimationElement {
@@ skipping 15 matching lines @@
         gfx::Tween::FloatValueBetween(t, start_, target_));
     return true;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->grayscale = target_;
   }
 
   void OnAbort(LayerAnimationDelegate* delegate) override {}
 
+  bool AreStartAndTargetSame() override {
+    return start_ == target_;
+  }
+
  private:
   float start_;
   const float target_;
 
   DISALLOW_COPY_AND_ASSIGN(GrayscaleTransition);
 };
 
 // ColorTransition -------------------------------------------------------------
 
 class ColorTransition : public LayerAnimationElement {
@@ skipping 15 matching lines @@
         gfx::Tween::ColorValueBetween(t, start_, target_));
     return true;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->color = target_;
   }
 
   void OnAbort(LayerAnimationDelegate* delegate) override {}
 
+  bool AreStartAndTargetSame() override {
+    return start_ == target_;
+  }
+
  private:
   SkColor start_;
   const SkColor target_;
 
   DISALLOW_COPY_AND_ASSIGN(ColorTransition);
 };
 
 // ThreadedLayerAnimationElement -----------------------------------------------
 
 class ThreadedLayerAnimationElement : public LayerAnimationElement {
  public:
   ThreadedLayerAnimationElement(AnimatableProperties properties,
                                 base::TimeDelta duration)
       : LayerAnimationElement(properties, duration) {
   }
   ~ThreadedLayerAnimationElement() override {}
 
   bool IsThreaded() const override { return !duration().is_zero(); }
 
  protected:
   explicit ThreadedLayerAnimationElement(const LayerAnimationElement& element)
     : LayerAnimationElement(element) {
   }
 
   bool OnProgress(double t, LayerAnimationDelegate* delegate) override {
     if (t < 1.0)
       return false;
 
     if (Started() && IsThreaded()) {
+      LOG(ERROR) << "RemoveThreadedAnimation";
       LayerThreadedAnimationDelegate* threaded =
           delegate->GetThreadedAnimationDelegate();
       DCHECK(threaded);
       threaded->RemoveThreadedAnimation(animation_id());
     }
 
     OnEnd(delegate);
     return true;
   }
 
   void OnAbort(LayerAnimationDelegate* delegate) override {
     if (delegate && Started() && IsThreaded()) {
       LayerThreadedAnimationDelegate* threaded =
           delegate->GetThreadedAnimationDelegate();
       DCHECK(threaded);
       threaded->RemoveThreadedAnimation(animation_id());
     }
   }
 
   void RequestEffectiveStart(LayerAnimationDelegate* delegate) override {
     DCHECK(animation_group_id());
     if (!IsThreaded()) {
       set_effective_start_time(requested_start_time());
       return;
     }
     set_effective_start_time(base::TimeTicks());
     std::unique_ptr<cc::Animation> animation = CreateCCAnimation();
     animation->set_needs_synchronized_start_time(true);
+    LOG(ERROR) << "AddThreadedAnimation";
 
     LayerThreadedAnimationDelegate* threaded =
         delegate->GetThreadedAnimationDelegate();
     DCHECK(threaded);
     threaded->AddThreadedAnimation(std::move(animation));
   }
 
   virtual void OnEnd(LayerAnimationDelegate* delegate) = 0;
 
   virtual std::unique_ptr<cc::Animation> CreateCCAnimation() = 0;
@@ skipping 26 matching lines @@
               start_,
               target_));
     }
   }
 
   void OnEnd(LayerAnimationDelegate* delegate) override {
     delegate->SetOpacityFromAnimation(target_);
   }
 
   std::unique_ptr<cc::Animation> CreateCCAnimation() override {
+    LOG(ERROR) << "Create Opacity CC Animation";
     std::unique_ptr<cc::AnimationCurve> animation_curve(
         new FloatAnimationCurveAdapter(tween_type(), start_, target_,
                                        duration()));
     std::unique_ptr<cc::Animation> animation(cc::Animation::Create(
         std::move(animation_curve), animation_id(), animation_group_id(),
         cc::TargetProperty::OPACITY));
     return animation;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->opacity = target_;
   }
 
+  bool AreStartAndTargetSame() override {
+    return start_ == target_;
+  }
+
  private:
   float start_;
   const float target_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadedOpacityTransition);
 };
 
 // ThreadedTransformTransition -------------------------------------------------
 
 class ThreadedTransformTransition : public ThreadedLayerAnimationElement {
@@ skipping 31 matching lines @@
     std::unique_ptr<cc::Animation> animation(cc::Animation::Create(
         std::move(animation_curve), animation_id(), animation_group_id(),
         cc::TargetProperty::TRANSFORM));
     return animation;
   }
 
   void OnGetTarget(TargetValue* target) const override {
     target->transform = target_;
   }
 
+  bool AreStartAndTargetSame() override {
+    return start_ == target_;
+  }
+
  private:
   gfx::Transform start_;
   const gfx::Transform target_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadedTransformTransition);
 };
 
 }  // namespace
 
 // LayerAnimationElement::TargetValue ------------------------------------------
@@ skipping 46 matching lines @@
 
 LayerAnimationElement::~LayerAnimationElement() {
 }
 
 void LayerAnimationElement::Start(LayerAnimationDelegate* delegate,
                                   int animation_group_id) {
   DCHECK(requested_start_time_ != base::TimeTicks());
   DCHECK(first_frame_);
   animation_group_id_ = animation_group_id;
   last_progressed_fraction_ = 0.0;
+
   OnStart(delegate);
+  if (AreStartAndTargetSame()) {
+    ProgressToEnd(delegate);
+    return;
+  }
+
   RequestEffectiveStart(delegate);
   first_frame_ = false;
 }
 
 bool LayerAnimationElement::Progress(base::TimeTicks now,
                                      LayerAnimationDelegate* delegate) {
   DCHECK(requested_start_time_ != base::TimeTicks());
   DCHECK(!first_frame_);
 
   bool need_draw;
@@ skipping 162 matching lines @@
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateColorElement(
     SkColor color,
     base::TimeDelta duration) {
   return new ColorTransition(color, duration);
 }
 
 }  // namespace ui