[animations] Adds metrics for jank on selected layer animations

ui/views/animation/flood_fill_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/flood_fill_ink_drop_ripple.h"
 
 #include <algorithm>
 
+#include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/metrics/histogram_macros.h"
 #include "third_party/skia/include/core/SkColor.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/point_conversions.h"
 #include "ui/gfx/geometry/vector2d_f.h"
 
 namespace {
 
 // The minimum radius to use when scaling the painted layers. Smaller values
@@ skipping 86 matching lines @@
                               const gfx::Insets& clip_insets) {
   gfx::Rect clip_bounds(host_size);
   clip_bounds.Inset(clip_insets);
   return clip_bounds;
 }
 
 float CalculateCircleLayerRadius(const gfx::Rect& clip_bounds) {
   return std::max(clip_bounds.width(), clip_bounds.height()) / 2.f;
 }
 
+class FloodRippleMetricsReporter : public ui::AnimationMetricsReporter {
+  void Report(int value) override {
+    UMA_HISTOGRAM_PERCENTAGE("Views.AnimationSmoothness.FloodFillRipple",
+                             value);
+  }
+};
+
+base::LazyInstance<FloodRippleMetricsReporter>::Leaky g_reporter =
+    LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
 namespace views {
 
 FloodFillInkDropRipple::FloodFillInkDropRipple(const gfx::Size& host_size,
                                                const gfx::Insets& clip_insets,
                                                const gfx::Point& center_point,
                                                SkColor color,
                                                float visible_opacity)
     : clip_insets_(clip_insets),
@@ skipping 190 matching lines @@
 
   std::unique_ptr<ui::LayerAnimationElement> element =
       ui::LayerAnimationElement::CreateTransformElement(transform, 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 FloodFillInkDropRipple::PauseTransformAnimation(
     base::TimeDelta duration,
     ui::LayerAnimator::PreemptionStrategy preemption_strategy,
     ui::LayerAnimationObserver* observer) {
   ui::LayerAnimator* animator = painted_layer_.GetAnimator();
   ui::ScopedLayerAnimationSettings animation(animator);
   animation.SetPreemptionStrategy(preemption_strategy);
 
   std::unique_ptr<ui::LayerAnimationElement> element =
       ui::LayerAnimationElement::CreatePauseElement(
           ui::LayerAnimationElement::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 FloodFillInkDropRipple::SetOpacity(float opacity) {
   root_layer_.SetOpacity(opacity);
 }
 
 void FloodFillInkDropRipple::AnimateToOpacity(
     float opacity,
     base::TimeDelta duration,
     ui::LayerAnimator::PreemptionStrategy preemption_strategy,
     gfx::Tween::Type tween,
     ui::LayerAnimationObserver* animation_observer) {
   ui::LayerAnimator* animator = root_layer_.GetAnimator();
   ui::ScopedLayerAnimationSettings animation_settings(animator);
   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 FloodFillInkDropRipple::PauseOpacityAnimation(
     base::TimeDelta duration,
     ui::LayerAnimator::PreemptionStrategy preemption_strategy,
     ui::LayerAnimationObserver* observer) {
   ui::LayerAnimator* animator = root_layer_.GetAnimator();
   ui::ScopedLayerAnimationSettings animation(animator);
   animation.SetPreemptionStrategy(preemption_strategy);
 
   std::unique_ptr<ui::LayerAnimationElement> element =
       ui::LayerAnimationElement::CreatePauseElement(
           ui::LayerAnimationElement::OPACITY, duration);
 
   ui::LayerAnimationSequence* sequence =
       new ui::LayerAnimationSequence(std::move(element));
 
   if (observer)
     sequence->AddObserver(observer);
 
+  sequence->SetAnimationMetricsReporter(g_reporter.Pointer());
   animator->StartAnimation(sequence);
 }
 
 gfx::Transform FloodFillInkDropRipple::CalculateTransform(
     float target_radius) const {
   const float target_scale = target_radius / circle_layer_delegate_.radius();
 
   gfx::Transform transform = gfx::Transform();
   transform.Translate(center_point_.x() - root_layer_.bounds().x(),
                       center_point_.y() - root_layer_.bounds().y());
@@ skipping 20 matching lines @@
       (bounds.bottom_right() - point).Length();
 
   float largest_distance =
       std::max(distance_to_top_left, distance_to_top_right);
   largest_distance = std::max(largest_distance, distance_to_bottom_left);
   largest_distance = std::max(largest_distance, distance_to_bottom_right);
   return largest_distance;
 }
 
 }  // namespace views