input: Remove now dead code.

content/browser/renderer_host/input/input_router_impl.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/browser/renderer_host/input/input_router_impl.h"
 
 #include <math.h>
 
 #include <utility>
 
@@ skipping 66 matching lines @@
                                  int routing_id,
                                  const Config& config)
     : sender_(sender),
       client_(client),
       ack_handler_(ack_handler),
       routing_id_(routing_id),
       frame_tree_node_id_(-1),
       select_message_pending_(false),
       move_caret_pending_(false),
       current_ack_source_(ACK_SOURCE_NONE),
-      flush_requested_(false),
       active_renderer_fling_count_(0),
       touch_scroll_started_sent_(false),
       wheel_event_queue_(this,
                          base::FeatureList::IsEnabled(
                              features::kTouchpadAndWheelScrollLatching)),
       gesture_event_queue_(this, this, config.gesture_config),
       device_scale_factor_(1.f),
       raf_aligned_touch_enabled_(
           base::FeatureList::IsEnabled(features::kRafAlignedTouchInputEvents)) {
   if (raf_aligned_touch_enabled_) {
@@ skipping 126 matching lines @@
 const NativeWebKeyboardEvent* InputRouterImpl::GetLastKeyboardEvent() const {
   if (key_queue_.empty())
     return NULL;
   return &key_queue_.front().event;
 }
 
 void InputRouterImpl::NotifySiteIsMobileOptimized(bool is_mobile_optimized) {
   touch_event_queue_->SetIsMobileOptimizedSite(is_mobile_optimized);
 }
 
-void InputRouterImpl::RequestNotificationWhenFlushed() {
-  flush_requested_ = true;
-  SignalFlushedIfNecessary();
-}
-
 bool InputRouterImpl::HasPendingEvents() const {
   return !touch_event_queue_->Empty() || !gesture_event_queue_.empty() ||
          !key_queue_.empty() || !mouse_move_queue_.empty() ||
          wheel_event_queue_.has_pending() || select_message_pending_ ||
          move_caret_pending_ || active_renderer_fling_count_ > 0;
 }
 
 void InputRouterImpl::SetDeviceScaleFactor(float device_scale_factor) {
   device_scale_factor_ = device_scale_factor;
 }
@@ skipping 262 matching lines @@
   // kTouchActionNone should disable the touch ack timeout.
   UpdateTouchAckTimeoutEnabled();
 }
 
 void InputRouterImpl::OnDidStopFlinging() {
   DCHECK_GT(active_renderer_fling_count_, 0);
   // Note that we're only guaranteed to get a fling end notification from the
   // renderer, not from any other consumers. Consequently, the GestureEventQueue
   // cannot use this bookkeeping for logic like tap suppression.
   --active_renderer_fling_count_;
-  SignalFlushedIfNecessary();
 
   client_->DidStopFlinging();
 }
 
 void InputRouterImpl::ProcessInputEventAck(WebInputEvent::Type event_type,
                                            InputEventAckState ack_result,
                                            const ui::LatencyInfo& latency_info,
                                            uint32_t unique_touch_event_id,
                                            AckSource ack_source) {
   TRACE_EVENT2("input", "InputRouterImpl::ProcessInputEventAck", "type",
@@ skipping 16 matching lines @@
     ProcessMouseAck(event_type, ack_result, latency_info);
   } else if (event_type == WebInputEvent::kMouseWheel) {
     ProcessWheelAck(ack_result, latency_info);
   } else if (WebInputEvent::IsTouchEventType(event_type)) {
     ProcessTouchAck(ack_result, latency_info, unique_touch_event_id);
   } else if (WebInputEvent::IsGestureEventType(event_type)) {
     ProcessGestureAck(event_type, ack_result, latency_info);
   } else if (event_type != WebInputEvent::kUndefined) {
     ack_handler_->OnUnexpectedEventAck(InputAckHandler::BAD_ACK_MESSAGE);
   }
-
-  SignalFlushedIfNecessary();
 }
 
 void InputRouterImpl::ProcessKeyboardAck(blink::WebInputEvent::Type type,
                                          InputEventAckState ack_result,
                                          const ui::LatencyInfo& latency) {
   if (key_queue_.empty()) {
     ack_handler_->OnUnexpectedEventAck(InputAckHandler::UNEXPECTED_ACK);
   } else if (key_queue_.front().event.GetType() != type) {
     // Something must be wrong. Clear the |key_queue_| and char event
     // suppression so that we can resume from the error.
@@ skipping 55 matching lines @@
 
 void InputRouterImpl::UpdateTouchAckTimeoutEnabled() {
   // kTouchActionNone will prevent scrolling, in which case the timeout serves
   // little purpose. It's also a strong signal that touch handling is critical
   // to page functionality, so the timeout could do more harm than good.
   const bool touch_ack_timeout_enabled =
       touch_action_filter_.allowed_touch_action() != cc::kTouchActionNone;
   touch_event_queue_->SetAckTimeoutEnabled(touch_ack_timeout_enabled);
 }
 
-void InputRouterImpl::SignalFlushedIfNecessary() {
-  if (!flush_requested_)
-    return;
-
-  if (HasPendingEvents())
-    return;
-
-  flush_requested_ = false;
-  client_->DidFlush();
-}
-
 void InputRouterImpl::SetFrameTreeNodeId(int frameTreeNodeId) {
   frame_tree_node_id_ = frameTreeNodeId;
 }
 
 void InputRouterImpl::SetMovementXYForTouchPoints(blink::WebTouchEvent* event) {
   for (size_t i = 0; i < event->touches_length; ++i) {
     blink::WebTouchPoint* touch_point = &event->touches[i];
     if (touch_point->state == blink::WebTouchPoint::kStateMoved) {
       const gfx::Point& last_position = global_touch_position_[touch_point->id];
       touch_point->movement_x =
@@ skipping 12 matching lines @@
         DCHECK(global_touch_position_.find(touch_point->id) ==
                global_touch_position_.end());
         global_touch_position_[touch_point->id] = gfx::Point(
             touch_point->screen_position.x, touch_point->screen_position.y);
       }
     }
   }
 }
 
 }  // namespace content