Expand UMA coverage for compositor-handled events and fling FPS

content/renderer/input/input_handler_proxy.cc

 // Copyright 2013 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/renderer/input/input_handler_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 100 matching lines @@
   WebGestureEvent scroll_begin_event = event;
   scroll_begin_event.type = WebInputEvent::GestureScrollBegin;
   scroll_begin_event.data.scrollBegin.deltaXHint = 0;
   scroll_begin_event.data.scrollBegin.deltaYHint = 0;
   return scroll_begin_event;
 }
 
 void SendScrollLatencyUma(const WebInputEvent& event,
                           const ui::LatencyInfo& latency_info) {
   if (!(event.type == WebInputEvent::GestureScrollBegin ||
-        event.type == WebInputEvent::GestureScrollUpdate))
+        event.type == WebInputEvent::GestureScrollUpdate ||
+        event.type == WebInputEvent::GesturePinchBegin ||
+        event.type == WebInputEvent::GesturePinchUpdate ||
+        event.type == WebInputEvent::GestureFlingStart)) {
     return;
+  }
 
   ui::LatencyInfo::LatencyMap::const_iterator it =
       latency_info.latency_components.find(std::make_pair(
           ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0));
 
   if (it == latency_info.latency_components.end())
     return;
 
   base::TimeDelta delta = base::TimeTicks::HighResNow() - it->second.event_time;
   for (size_t i = 0; i < it->second.event_count; ++i) {
-    UMA_HISTOGRAM_CUSTOM_COUNTS(
-        "Event.Latency.RendererImpl.GestureScroll2",
-        delta.InMicroseconds(),
-        1,
-        1000000,
-        100);
+    switch (event.type) {
+      case blink::WebInputEvent::GestureScrollBegin:
+        UMA_HISTOGRAM_CUSTOM_COUNTS(
+            "Event.Latency.RendererImpl.GestureScrollBegin",
+            delta.InMicroseconds(), 1, 1000000, 100);
+        break;
+      case blink::WebInputEvent::GestureScrollUpdate:
+        UMA_HISTOGRAM_CUSTOM_COUNTS(
+            // So named for historical reasons.
+            "Event.Latency.RendererImpl.GestureScroll2",
+            delta.InMicroseconds(), 1, 1000000, 100);
+        break;
+      case blink::WebInputEvent::GesturePinchBegin:
+        UMA_HISTOGRAM_CUSTOM_COUNTS(
+            "Event.Latency.RendererImpl.GesturePinchBegin",
+            delta.InMicroseconds(), 1, 1000000, 100);
+        break;
+      case blink::WebInputEvent::GesturePinchUpdate:
+        UMA_HISTOGRAM_CUSTOM_COUNTS(
+            "Event.Latency.RendererImpl.GesturePinchUpdate",
+            delta.InMicroseconds(), 1, 1000000, 100);
+        break;
+      case blink::WebInputEvent::GestureFlingStart:
+        UMA_HISTOGRAM_CUSTOM_COUNTS(
+            "Event.Latency.RendererImpl.GestureFlingStart",
+            delta.InMicroseconds(), 1, 1000000, 100);
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
   }
+}
+
 }  // namespace
 
-}
-
 namespace content {
 
 InputHandlerProxy::InputHandlerProxy(cc::InputHandler* input_handler,
                                      InputHandlerProxyClient* client)
     : client_(client),
       input_handler_(input_handler),
       deferred_fling_cancel_time_seconds_(0),
 #ifndef NDEBUG
       expect_scroll_update_end_(false),
 #endif
@@ skipping 732 matching lines @@
   // trigger a scroll, e.g., with a trivial time delta between fling updates.
   // Return true in this case to prevent early fling termination.
   if (std::abs(clipped_increment.width) < kScrollEpsilon &&
       std::abs(clipped_increment.height) < kScrollEpsilon)
     return true;
 
   return did_scroll;
 }
 
 }  // namespace content