Remove is_fling flag for fling intervention

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 <tuple>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 53 matching lines @@
   renderer_scheduler_ =
       render_thread_impl ? render_thread_impl->GetRendererScheduler() : nullptr;
 }
 
 void InputEventFilter::SetInputHandlerManager(
     InputHandlerManager* input_handler_manager) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   input_handler_manager_ = input_handler_manager;
 }
 
-void InputEventFilter::SetIsFlingingInMainThreadEventQueue(int routing_id,
-                                                           bool is_flinging) {
-  RouteQueueMap::iterator iter = route_queues_.find(routing_id);
-  if (iter == route_queues_.end() || !iter->second)
-    return;
-
-  iter->second->set_is_flinging(is_flinging);
-}
-
 void InputEventFilter::RegisterRoutingID(int routing_id) {
   base::AutoLock locked(routes_lock_);
   routes_.insert(routing_id);
   route_queues_[routing_id] = new MainThreadEventQueue(
       routing_id, this, main_task_runner_, renderer_scheduler_);
 }
 
 void InputEventFilter::UnregisterRoutingID(int routing_id) {
   base::AutoLock locked(routes_lock_);
   routes_.erase(routing_id);
   route_queues_.erase(routing_id);
 }
 
 void InputEventFilter::DidOverscroll(int routing_id,
                                      const DidOverscrollParams& params) {
   SendMessage(std::unique_ptr<IPC::Message>(
       new InputHostMsg_DidOverscroll(routing_id, params)));
 }
 
-void InputEventFilter::DidStartFlinging(int routing_id) {
-  SetIsFlingingInMainThreadEventQueue(routing_id, true);
-}
-
 void InputEventFilter::DidStopFlinging(int routing_id) {
-  SetIsFlingingInMainThreadEventQueue(routing_id, false);
   SendMessage(base::MakeUnique<InputHostMsg_DidStopFlinging>(routing_id));
 }
 
 void InputEventFilter::DispatchNonBlockingEventToMainThread(
     int routing_id,
     ui::ScopedWebInputEvent event,
     const ui::LatencyInfo& latency_info) {
   DCHECK(target_task_runner_->BelongsToCurrentThread());
   RouteQueueMap::iterator iter = route_queues_.find(routing_id);
   if (iter != route_queues_.end()) {
@@ skipping 126 matching lines @@
     InputEventAckState ack_state,
     ui::ScopedWebInputEvent event,
     const ui::LatencyInfo& latency_info,
     std::unique_ptr<DidOverscrollParams> overscroll_params) {
   bool send_ack = dispatch_type == DISPATCH_TYPE_BLOCKING;
   uint32_t unique_touch_event_id =
       ui::WebInputEventTraits::GetUniqueTouchEventId(*event);
   WebInputEvent::Type type = event->type;
 
   if (ack_state == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING ||
-      ack_state == INPUT_EVENT_ACK_STATE_NOT_CONSUMED) {
+      ack_state == INPUT_EVENT_ACK_STATE_NOT_CONSUMED ||
+      ack_state == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING) {

[tdresser, 2016/11/07 21:58:49]

Nit: might be nice to reorder these such that the set_non_blocking's are
contiguous.

[lanwei, 2016/11/07 23:25:18]

Done.

     DCHECK(!overscroll_params);
     RouteQueueMap::iterator iter = route_queues_.find(routing_id);
     if (iter != route_queues_.end()) {
       send_ack &= iter->second->HandleEvent(std::move(event), latency_info,
                                             dispatch_type, ack_state);
     }
   }
   event.reset();
 
   if (!send_ack)
@@ skipping 47 matching lines @@
     input_handler_manager_->NeedsMainFrame(routing_id);
     return;
   }
 
   target_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&InputEventFilter::NeedsMainFrame, this, routing_id));
 }
 
 }  // namespace content