[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",

[bruthig, 2017/01/24 15:56:30]

I'm not sure how helpful it will be to get an aggregate of all flood fill
animations across all surfaces.  It would be much much better if they could be
named with the surface that they are on, e.g. AppListFloodFill.  IIUC it should
be possible, you just have to expand the histogram macros manually.

[varkha, 2017/01/24 20:23:25]

I thought of those more as examples to use the new metrics. I agree that
aggregating across all ripples is not the use case I had in mind; it would be
better to have more specific (and more problematic) surfaces: notification tray
ripple, app-list ripple and maybe one example in top chrome (chrome kebob menu
button or bookmarks). I will leave the ripple metrics instantiations out of this
CL.

+                             value);
+  }
+};
+base::LazyInstance<FloodRippleMetricsReporter>::Leaky g_reporter =

[bruthig, 2017/01/24 15:56:30]

Do these really need to be global state?  Would any of the following work?

. Make FloodFillInkDropRipple inherit ui::AnimationMetricsReporter
. Use scoped_refptr's instead
. Use normal instances and pass them by copy

FloodRippleMetricsReporter may be a small class but if this is the de facto
standard than I imagine others will be adding a lot of global state to track
animations.  I don't think eating up that RAM is worthy for something that is
only useful for a small portion of the time.

[varkha, 2017/01/24 20:23:25]

Chatted offline about it. I think so far with a very few actual histograms added
simplicity would win (and avoid some non-trivial instantiation and
reconstitution costs for the histogram objects). I will leave the ripple metrics
out of this CL for now.

+    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 194 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