Expand UMA coverage for compositor-handled events and fling FPS

content/child/web_gesture_curve_impl.cc

 // Copyright 2014 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 "content/child/web_gesture_curve_impl.h"
 
 #include "base/logging.h"
 #include "third_party/WebKit/public/platform/WebFloatSize.h"
 #include "third_party/WebKit/public/platform/WebGestureCurveTarget.h"
 #include "ui/events/gestures/fling_curve.h"
-#include "ui/gfx/vector2d.h"
+#include "ui/gfx/geometry/safe_integer_conversions.h"
+#include "ui/gfx/geometry/vector2d.h"
 
 #if defined(OS_ANDROID)
 #include "ui/events/android/scroller.h"
 #endif
 
 using blink::WebGestureCurve;
 
 namespace content {
 namespace {
 
@@ skipping 16 matching lines @@
   return make_scoped_ptr(
       new ui::FlingCurve(initial_velocity, base::TimeTicks()));
 #endif
 }
 
 }  // namespace
 
 // static
 scoped_ptr<WebGestureCurve> WebGestureCurveImpl::CreateFromDefaultPlatformCurve(
     const gfx::Vector2dF& initial_velocity,
-    const gfx::Vector2dF& initial_offset) {
-  return CreateFrom(CreateDefaultPlatformCurve(initial_velocity),
-                    initial_offset);
+    const gfx::Vector2dF& initial_offset,
+    bool on_main_thread) {
+  return scoped_ptr<WebGestureCurve>(new WebGestureCurveImpl(
+      CreateDefaultPlatformCurve(initial_velocity), initial_offset,
+      on_main_thread ? ThreadType::MAIN : ThreadType::IMPL));
 }
 
 // static
-scoped_ptr<WebGestureCurve> WebGestureCurveImpl::CreateFrom(
+scoped_ptr<WebGestureCurve> WebGestureCurveImpl::CreateFromUICurveForTesting(
     scoped_ptr<ui::GestureCurve> curve,
     const gfx::Vector2dF& initial_offset) {
   return scoped_ptr<WebGestureCurve>(
-      new WebGestureCurveImpl(curve.Pass(), initial_offset));
+      new WebGestureCurveImpl(curve.Pass(), initial_offset, ThreadType::TEST));
 }
 
 WebGestureCurveImpl::WebGestureCurveImpl(scoped_ptr<ui::GestureCurve> curve,
-                                         const gfx::Vector2dF& initial_offset)
-    : curve_(curve.Pass()), last_offset_(initial_offset) {
+                                         const gfx::Vector2dF& initial_offset,
+                                         ThreadType animating_thread_type)
+    : curve_(curve.Pass()),
+      last_offset_(initial_offset),
+      animating_thread_type_(animating_thread_type),
+      ticks_since_first_animate_(0),
+      first_animate_time_(0),
+      last_animate_time_(0) {
 }
 
 WebGestureCurveImpl::~WebGestureCurveImpl() {
+  if (ticks_since_first_animate_ <= 1)
+    return;
+
+  if (first_animate_time_ >= last_animate_time_)
+    return;
+
+  switch (animating_thread_type_) {
+    case ThreadType::MAIN:
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Event.FPS.Renderer.Fling",
+          gfx::ToRoundedInt(ticks_since_first_animate_ /
+                            (last_animate_time_ - first_animate_time_)),
+          1, 200, 100);

[jdduke (slow), 2014/12/01 18:20:59]

Any thoughts on bucket extents/count?

[Yufeng Shen (Slow to review), 2014/12/01 18:57:07]

You can try a few test flings on your device and check its values at
about://histograms to see what the value range looks like.

[jdduke (slow), 2014/12/01 20:20:28]

Well, it *should* be capped by the refresh rate, so on most Android devices a
max of 60. We definitely want to include 120hz displays, hence the 200 cap, but
I wonder if we should consider 240hz displays?

[Yufeng Shen (Slow to review), 2014/12/01 20:40:14]

Do we push out frames as whatever the display refresh rate is ? or do we have an
internal cap ? 

+      break;
+    case ThreadType::IMPL:
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Event.FPS.RendererImpl.Fling",

[jdduke (slow), 2014/12/01 18:20:59]

Also not sure about the preferred naming scheme...

[Rick Byers, 2014/12/01 19:47:10]

We have Event.Latency.* for all latency measures.  Maybe we should have
Event.Frequency.* for anything where we want to monitor how frequently events
are being serviced / produced.  "FPS" is almost that except "frames" isn't
necessarily the right concept.  Eg. imagine we want to monitor stylus
performance to see how often we're hitting 120 or 200hz event handling rate.

[jdduke (slow), 2014/12/01 20:20:29]

Yeah, frequency is a nice name for this family.

+          gfx::ToRoundedInt(ticks_since_first_animate_ /
+                            (last_animate_time_ - first_animate_time_)),
+          1, 200, 100);
+      break;
+    case ThreadType::TEST:
+      break;
+  }
 }
 
 bool WebGestureCurveImpl::apply(double time,
                                 blink::WebGestureCurveTarget* target) {
   // If the fling has yet to start, simply return and report true to prevent
   // fling termination.
   if (time <= 0)
     return true;
 
+  if (!first_animate_time_) {
+    first_animate_time_ = time;
+  } else if (time != last_animate_time_) {
+    // Animation can occur multiple times a frame, but with the same timestamp.
+    // Suppress recording of such redundant animate calls, avoiding artificially

[Yufeng Shen (Slow to review), 2014/12/01 18:57:07]

If this is true, do you want to also guard against the case there comes repeated
apply() at the same first_animate_time ? e.g. the apply happens at 10, 10, 26 ?

[jdduke (slow), 2014/12/01 20:20:28]

Good catch, done.

+    // inflated FPS computation.
+    last_animate_time_ = time;
+    ++ticks_since_first_animate_;
+  }
+
   const base::TimeTicks time_ticks =
       base::TimeTicks() + base::TimeDelta::FromSecondsD(time);
   gfx::Vector2dF offset, velocity;
   bool still_active =
       curve_->ComputeScrollOffset(time_ticks, &offset, &velocity);
 
   gfx::Vector2dF delta = offset - last_offset_;
   last_offset_ = offset;
 
   // As successive timestamps can be arbitrarily close (but monotonic!), don't
   // assume that a zero delta means the curve has terminated.
   if (delta.IsZero())
     return still_active;
 
   // scrollBy() could delete this curve if the animation is over, so don't touch
   // any member variables after making that call.
   bool did_scroll = target->scrollBy(blink::WebFloatSize(delta),
                                      blink::WebFloatSize(velocity));
   return did_scroll && still_active;
 }
 
 }  // namespace content