Add UMA metric for tracking listeners for blocking touch while fling is happening

content/renderer/input/input_event_filter.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_event_filter.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 32 matching lines @@
 namespace content {
 
 InputEventFilter::InputEventFilter(
     const base::Callback<void(const IPC::Message&)>& main_listener,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& target_task_runner)
     : main_task_runner_(main_task_runner),
       main_listener_(main_listener),
       sender_(NULL),
       target_task_runner_(target_task_runner),
-      current_overscroll_params_(NULL) {
+      current_overscroll_params_(NULL),
+      is_flinging_(false) {
   DCHECK(target_task_runner_.get());
 }
 
 void InputEventFilter::SetBoundHandler(const Handler& handler) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   handler_ = handler;
 }
 
 void InputEventFilter::DidAddInputHandler(int routing_id) {
   base::AutoLock locked(routes_lock_);
@@ skipping 113 matching lines @@
           &current_overscroll_params_, send_ack ? &overscroll_params : NULL);
 
   InputEventAckState ack_state = handler_.Run(routing_id, event, &latency_info);
 
   if (ack_state == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING ||
       ack_state == INPUT_EVENT_ACK_STATE_NOT_CONSUMED) {
     DCHECK(!overscroll_params);
     RouteQueueMap::iterator iter = route_queues_.find(routing_id);
     if (iter != route_queues_.end())
       send_ack &= iter->second->HandleEvent(event, latency_info, dispatch_type,
-                                            ack_state);
+                                            ack_state, is_flinging_);
   }
 
   if (!send_ack)
     return;
 
   InputEventAck ack(event->type, ack_state, latency_info,
                     std::move(overscroll_params),
                     WebInputEventTraits::GetUniqueTouchEventId(*event));
   SendMessage(std::unique_ptr<IPC::Message>(
       new InputHostMsg_HandleInputEvent_ACK(routing_id, ack)));
@@ skipping 23 matching lines @@
     const ui::LatencyInfo& latency_info,
     InputEventDispatchType dispatch_type) {
   TRACE_EVENT_INSTANT0(
       "input", "InputEventFilter::ForwardToHandler::SendEventToMainThread",
       TRACE_EVENT_SCOPE_THREAD);
   IPC::Message new_msg =
       InputMsg_HandleInputEvent(routing_id, event, latency_info, dispatch_type);
   main_task_runner_->PostTask(FROM_HERE, base::Bind(main_listener_, new_msg));
 }
 
+void InputEventFilter::SetIsFlinging(bool is_flinging) {
+  is_flinging_ = is_flinging;
+}
+
 }  // namespace content