[animations] Adds metrics for jank on selected layer animations

ui/compositor/layer_unittest.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.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 2210 matching lines @@
 
   root->SetOpacity(0.5f);
   WaitForSwap();
   EXPECT_EQ(1u, animation_observer.animation_step_count());
 
   EXPECT_FALSE(animation_observer.shutdown());
   ResetCompositor();
   EXPECT_TRUE(animation_observer.shutdown());
 }
 
+// A simple AnimationMetricsReporter class that remembers smoothness metric
+// when animation completes.
+class TestMetricsReporter : public ui::AnimationMetricsReporter {
+ public:
+  TestMetricsReporter() {}
+  ~TestMetricsReporter() override {}
+
+  bool report_called() { return report_called_; }
+  int value() const { return value_; }
+
+ protected:
+  void Report(int value) override {
+    value_ = value;
+    report_called_ = true;
+  }
+
+ private:
+  bool report_called_ = false;
+  int value_ = -1;
+
+  DISALLOW_COPY_AND_ASSIGN(TestMetricsReporter);
+};
+
+// Starts an animation and tests that incrementing compositor frame count can
+// be used to report animation smoothness metrics.
+TEST_F(LayerWithRealCompositorTest, ReportMetrics) {
+  std::unique_ptr<Layer> root(
+      CreateColorLayer(SK_ColorGREEN, gfx::Rect(20, 20, 50, 50)));
+  GetCompositor()->SetRootLayer(root.get());
+  LayerAnimator* animator = root->GetAnimator();
+  std::unique_ptr<ui::LayerAnimationElement> animation_element =
+      ui::LayerAnimationElement::CreateColorElement(
+          SK_ColorRED, base::TimeDelta::FromMilliseconds(100));
+  ui::LayerAnimationSequence* animation_sequence =
+      new ui::LayerAnimationSequence(std::move(animation_element));
+  TestMetricsReporter reporter;
+  animation_sequence->SetAnimationMetricsReporter(&reporter);
+  animator->StartAnimation(animation_sequence);
+  while (!reporter.report_called())
+    WaitForSwap();
+  ResetCompositor();
+  EXPECT_GT(reporter.value(), 90);

[ajuma, 2017/01/20 21:24:07]

Just to make sure I understand, since the animation duration is 100ms and since
we only report non-100 smoothness when there's at least a one frame difference
in duration vs actual_duration, this is equivalent to saying that smoothness is
100?

I guess the use of TimeTicks::Now() in the computation makes it hard to unit
test other scenarios.

[varkha, 2017/01/20 22:05:24]

Yes, you got me here. I saw a value of 100% and thought at first it was not
guaranteed. I think your logic is correct and I tried to put it in a comment.

+}
+
 TEST(LayerDebugInfoTest, LayerNameDoesNotClobber) {
   Layer layer(LAYER_NOT_DRAWN);
   layer.set_name("foo");
   std::unique_ptr<base::trace_event::ConvertableToTraceFormat> debug_info =
       layer.TakeDebugInfo(nullptr);
   std::string trace_format("bar,");
   debug_info->AppendAsTraceFormat(&trace_format);
   std::string expected("bar,{\"layer_name\":\"foo\"}");
   EXPECT_EQ(expected, trace_format);
 }
 
 }  // namespace ui