[animations] Adds metrics for jank on selected layer animations

ui/views/animation/square_ink_drop_ripple.cc

 // Copyright 2016 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/views/animation/square_ink_drop_ripple.h"
 
 #include <algorithm>
 
+#include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/metrics/histogram_macros.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/geometry/vector3d_f.h"
 #include "ui/gfx/transform_util.h"
 #include "ui/views/animation/ink_drop_painted_layer_delegates.h"
 #include "ui/views/view.h"
@@ skipping 132 matching lines @@
 // factors.
 gfx::Transform CalculateRectTransform(const gfx::Vector2dF& center_offset,
                                       float x_scale,
                                       float y_scale) {
   gfx::Transform transform;
   transform.Scale(x_scale, y_scale);
   transform.Translate(-center_offset.x(), -center_offset.y());
   return transform;
 }
 
+class SquareRippleMetricsReporter : public ui::AnimationMetricsReporter {
+  void Report(int value) override {
+    UMA_HISTOGRAM_PERCENTAGE("Views.AnimationSmoothness.SquareRipple", value);
+  }
+};
+
+base::LazyInstance<SquareRippleMetricsReporter>::Leaky g_reporter =
+    LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
 namespace views {
 
 SquareInkDropRipple::SquareInkDropRipple(const gfx::Size& large_size,
                                          int large_corner_radius,
                                          const gfx::Size& small_size,
                                          int small_corner_radius,
                                          const gfx::Point& center_point,
                                          SkColor color,
@@ skipping 280 matching lines @@
   gfx::Transform transform;
   transform.Translate(target_center_point_.x(), target_center_point_.y());
   std::unique_ptr<ui::LayerAnimationElement> element =
       ui::LayerAnimationElement::CreateTransformElement(transform, duration);
   ui::LayerAnimationSequence* sequence =
       new ui::LayerAnimationSequence(std::move(element));
 
   if (observer)
     sequence->AddObserver(observer);
 
+  sequence->SetAnimationMetricsReporter(g_reporter.Pointer());
   animator->StartAnimation(sequence);
 }
 
 void SquareInkDropRipple::AnimateToTransforms(
     const InkDropTransforms transforms,
     base::TimeDelta duration,
     ui::LayerAnimator::PreemptionStrategy preemption_strategy,
     gfx::Tween::Type tween,
     ui::LayerAnimationObserver* animation_observer) {
   for (int i = 0; i < PAINTED_SHAPE_COUNT; ++i) {
     ui::LayerAnimator* animator = painted_layers_[i]->GetAnimator();
     ui::ScopedLayerAnimationSettings animation(animator);
     animation.SetPreemptionStrategy(preemption_strategy);
     animation.SetTweenType(tween);
     std::unique_ptr<ui::LayerAnimationElement> element =
         ui::LayerAnimationElement::CreateTransformElement(transforms[i],
                                                           duration);
     ui::LayerAnimationSequence* sequence =
         new ui::LayerAnimationSequence(std::move(element));
 
     if (animation_observer)
       sequence->AddObserver(animation_observer);
 
+    sequence->SetAnimationMetricsReporter(g_reporter.Pointer());
     animator->StartAnimation(sequence);
   }
 }
 
 void SquareInkDropRipple::SetTransforms(const InkDropTransforms transforms) {
   for (int i = 0; i < PAINTED_SHAPE_COUNT; ++i)
     painted_layers_[i]->SetTransform(transforms[i]);
 }
 
 void SquareInkDropRipple::SetOpacity(float opacity) {
@@ skipping 11 matching lines @@
   animation_settings.SetPreemptionStrategy(preemption_strategy);
   animation_settings.SetTweenType(tween);
   std::unique_ptr<ui::LayerAnimationElement> animation_element =
       ui::LayerAnimationElement::CreateOpacityElement(opacity, duration);
   ui::LayerAnimationSequence* animation_sequence =
       new ui::LayerAnimationSequence(std::move(animation_element));
 
   if (animation_observer)
     animation_sequence->AddObserver(animation_observer);
 
+  animation_sequence->SetAnimationMetricsReporter(g_reporter.Pointer());
   animator->StartAnimation(animation_sequence);
 }
 
 void SquareInkDropRipple::CalculateCircleTransforms(
     const gfx::Size& size,
     InkDropTransforms* transforms_out) const {
   CalculateRectTransforms(size, std::min(size.width(), size.height()) / 2.0f,
                           transforms_out);
 }
 
@@ skipping 113 matching lines @@
   layer->set_delegate(delegate);
   layer->SetVisible(true);
   layer->SetOpacity(1.0);
   layer->SetMasksToBounds(false);
   layer->set_name("PAINTED_SHAPE_COUNT:" + ToLayerName(painted_shape));
 
   painted_layers_[painted_shape].reset(layer);
 }
 
 }  // namespace views