Check target value

ui/compositor/layer_animator.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_animator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
 #include "cc/animation/animation_timeline.h"
 #include "cc/animation/element_animations.h"
 #include "cc/output/begin_frame_args.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator_collection.h"
 
+#include "base/debug/stack_trace.h"
 #define SAFE_INVOKE_VOID(function, running_anim, ...) \
     if (running_anim.is_sequence_alive()) \
       function(running_anim.sequence(), ##__VA_ARGS__)
 #define SAFE_INVOKE_BOOL(function, running_anim) \
     ((running_anim.is_sequence_alive()) \
         ? function(running_anim.sequence()) \
         : false)
 #define SAFE_INVOKE_PTR(function, running_anim) \
     ((running_anim.is_sequence_alive()) \
         ? function(running_anim.sequence()) \
@@ skipping 36 matching lines @@
 LayerAnimator* LayerAnimator::CreateDefaultAnimator() {
   return new LayerAnimator(base::TimeDelta::FromMilliseconds(0));
 }
 
 // static
 LayerAnimator* LayerAnimator::CreateImplicitAnimator() {
   return new LayerAnimator(
       base::TimeDelta::FromMilliseconds(kDefaultTransitionDurationMs));
 }
 
+void Print(const std::string& name, const gfx::Rect& r) {
+  LOG(ERROR) << name << ":" << r.ToString();
+}
+
+void Print(const std::string& name, const gfx::Transform& t) {
+  LOG(ERROR) << name << ":" << t.ToString();
+}
+
+void Print(const std::string& name, float f) {
+  LOG(ERROR) << name << ":" << f;
+}
+
+void Print(const std::string& name, int i) {
+  LOG(ERROR) << name << ":" << i;
+}
+
+void Print(const std::string& name, SkColor c) {
+  LOG(ERROR) << name << ":" << c;
+}
+
 // This macro provides the implementation for the setter and getter (well,
 // the getter of the target value) for an animated property. For example,
 // it is used for the implementations of SetTransform and GetTargetTransform.
 // It is worth noting that SetFoo avoids invoking the usual animation machinery
 // if the transition duration is zero -- in this case we just set the property
 // on the layer animation delegate immediately.
 #define ANIMATED_PROPERTY(type, property, name, member_type, member)    \
   void LayerAnimator::Set##name(type value) {                           \
     base::TimeDelta duration = GetTransitionDuration();                 \
     if (duration.is_zero() && delegate() &&                             \
         (preemption_strategy_ != ENQUEUE_NEW_ANIMATION)) {              \
       StopAnimatingProperty(LayerAnimationElement::property);           \
-      delegate()->Set##name##FromAnimation(value);                      \
+      delegate()->Set##name##FromAnimation(value);                    \
       return;                                                           \
     }                                                                   \
     std::unique_ptr<LayerAnimationElement> element(                     \
         LayerAnimationElement::Create##name##Element(value, duration)); \
     element->set_tween_type(tween_type_);                               \
     StartAnimation(new LayerAnimationSequence(element.release()));      \
   }                                                                     \
                                                                         \
   member_type LayerAnimator::GetTarget##name() const {                  \
     LayerAnimationElement::TargetValue target(delegate());              \
@@ skipping 862 matching lines @@
     const base::WeakPtr<LayerAnimationSequence>& sequence)
     : sequence_(sequence) {
 }
 
 LayerAnimator::RunningAnimation::RunningAnimation(
     const RunningAnimation& other) = default;
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui