text: // 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>
  
  #include "base/auto_reset.h"
  #include "base/command_line.h"
  #include "base/memory/ptr_util.h"
  #include "base/metrics/histogram_macros.h"
  #include "base/strings/string_number_conversions.h"
  #include "content/browser/renderer_host/input/gesture_event_queue.h"
  #include "content/browser/renderer_host/input/input_ack_handler.h"
  #include "content/browser/renderer_host/input/input_router_client.h"
  #include "content/browser/renderer_host/input/touch_event_queue.h"
  #include "content/browser/renderer_host/input/touchpad_tap_suppression_controller.h"
  #include "content/common/content_constants_internal.h"
  #include "content/common/edit_command.h"
  #include "content/common/input/input_event_ack_state.h"
  #include "content/common/input/touch_action.h"
  #include "content/common/input/web_touch_event_traits.h"
  #include "content/common/input_messages.h"
  #include "content/common/view_messages.h"
  #include "content/public/browser/notification_service.h"
  #include "content/public/browser/notification_types.h"
  #include "content/public/browser/user_metrics.h"
  #include "content/public/common/content_features.h"
  #include "content/public/common/content_switches.h"
  #include "ipc/ipc_sender.h"
  #include "ui/events/blink/blink_event_util.h"
  #include "ui/events/blink/web_input_event_traits.h"
  #include "ui/events/event.h"
  #include "ui/events/keycodes/keyboard_codes.h"
  
  using base::Time;
  using base::TimeDelta;
  using base::TimeTicks;
  using blink::WebGestureEvent;
  using blink::WebInputEvent;
  using blink::WebKeyboardEvent;
  using blink::WebMouseEvent;
  using blink::WebMouseWheelEvent;
  using blink::WebTouchEvent;
  using ui::WebInputEventTraits;
  
  namespace content {
  namespace {
  
  const char* GetEventAckName(InputEventAckState ack_result) {
    switch(ack_result) {
      case INPUT_EVENT_ACK_STATE_UNKNOWN: return "UNKNOWN";
      case INPUT_EVENT_ACK_STATE_CONSUMED: return "CONSUMED";
      case INPUT_EVENT_ACK_STATE_NOT_CONSUMED: return "NOT_CONSUMED";
      case INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS: return "NO_CONSUMER_EXISTS";
      case INPUT_EVENT_ACK_STATE_IGNORED: return "IGNORED";
      case INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING:
        return "SET_NON_BLOCKING";
      case INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING:
        return "SET_NON_BLOCKING_DUE_TO_FLING";
    }
    DLOG(WARNING) << "Unhandled InputEventAckState in GetEventAckName.";
    return "";
  }
  
  } // namespace
  
  InputRouterImpl::Config::Config() {
  }
  
  InputRouterImpl::InputRouterImpl(IPC::Sender* sender,
                                   InputRouterClient* client,
                                   InputAckHandler* ack_handler,
                                   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)),
        touch_event_queue_(this, config.touch_config),
        gesture_event_queue_(this, this, config.gesture_config),
        device_scale_factor_(1.f) {
    DCHECK(sender);
    DCHECK(client);
    DCHECK(ack_handler);
    UpdateTouchAckTimeoutEnabled();
  }
  
  InputRouterImpl::~InputRouterImpl() {
  }
  
  bool InputRouterImpl::SendInput(std::unique_ptr<IPC::Message> message) {
    DCHECK(IPC_MESSAGE_ID_CLASS(message->type()) == InputMsgStart);
    switch (message->type()) {
      // Check for types that require an ACK.
      case InputMsg_SelectRange::ID:
      case InputMsg_MoveRangeSelectionExtent::ID:
        return SendSelectMessage(std::move(message));
      case InputMsg_MoveCaret::ID:
        return SendMoveCaret(std::move(message));
      case InputMsg_HandleInputEvent::ID:
        NOTREACHED() << "WebInputEvents should never be sent via SendInput.";
        return false;
      default:
        return Send(message.release());
    }
  }
  
  void InputRouterImpl::SendMouseEvent(
      const MouseEventWithLatencyInfo& mouse_event) {
    if (mouse_event.event.type() == WebInputEvent::MouseDown &&
        gesture_event_queue_.GetTouchpadTapSuppressionController()
            ->ShouldDeferMouseDown(mouse_event))
      return;
    if (mouse_event.event.type() == WebInputEvent::MouseUp &&
        gesture_event_queue_.GetTouchpadTapSuppressionController()
            ->ShouldSuppressMouseUp())
      return;
  
    SendMouseEventImmediately(mouse_event);
  }
  
  void InputRouterImpl::SendWheelEvent(
      const MouseWheelEventWithLatencyInfo& wheel_event) {
    wheel_event_queue_.QueueEvent(wheel_event);
  }
  
  void InputRouterImpl::SendKeyboardEvent(
      const NativeWebKeyboardEventWithLatencyInfo& key_event) {
    // Put all WebKeyboardEvent objects in a queue since we can't trust the
    // renderer and we need to give something to the HandleKeyboardEvent
    // handler.
    key_queue_.push_back(key_event);
    LOCAL_HISTOGRAM_COUNTS_100("Renderer.KeyboardQueueSize", key_queue_.size());
  
    gesture_event_queue_.FlingHasBeenHalted();
  
    // Only forward the non-native portions of our event.
    FilterAndSendWebInputEvent(key_event.event, key_event.latency);
  }
  
  void InputRouterImpl::SendGestureEvent(
      const GestureEventWithLatencyInfo& original_gesture_event) {
    input_stream_validator_.Validate(original_gesture_event.event);
  
    GestureEventWithLatencyInfo gesture_event(original_gesture_event);
  
    if (touch_action_filter_.FilterGestureEvent(&gesture_event.event))
      return;
  
    wheel_event_queue_.OnGestureScrollEvent(gesture_event);
  
    if (gesture_event.event.sourceDevice == blink::WebGestureDeviceTouchscreen) {
      if (gesture_event.event.type() ==
          blink::WebInputEvent::GestureScrollBegin) {
        touch_scroll_started_sent_ = false;
      } else if (!touch_scroll_started_sent_ &&
                 gesture_event.event.type() ==
                     blink::WebInputEvent::GestureScrollUpdate) {
        // A touch scroll hasn't really started until the first
        // GestureScrollUpdate event.  Eg. if the page consumes all touchmoves
        // then no scrolling really ever occurs (even though we still send
        // GestureScrollBegin).
        touch_event_queue_.PrependTouchScrollNotification();
        touch_scroll_started_sent_ = true;
      }
      touch_event_queue_.OnGestureScrollEvent(gesture_event);
    }
  
    gesture_event_queue_.QueueEvent(gesture_event);
  }
  
  void InputRouterImpl::SendTouchEvent(
      const TouchEventWithLatencyInfo& touch_event) {
    input_stream_validator_.Validate(touch_event.event);
    touch_event_queue_.QueueEvent(touch_event);
  }
  
  // Forwards MouseEvent without passing it through
  // TouchpadTapSuppressionController.
  void InputRouterImpl::SendMouseEventImmediately(
      const MouseEventWithLatencyInfo& mouse_event) {
    if (mouse_event.event.type() == blink::WebInputEvent::MouseMove)
      mouse_move_queue_.push_back(mouse_event);
  
    FilterAndSendWebInputEvent(mouse_event.event, mouse_event.latency);
  }
  
  void InputRouterImpl::SendTouchEventImmediately(
      const TouchEventWithLatencyInfo& touch_event) {
    if (WebTouchEventTraits::IsTouchSequenceStart(touch_event.event)) {
      touch_action_filter_.ResetTouchAction();
      // Note that if the previous touch-action was TOUCH_ACTION_NONE, enabling
      // the timeout here will not take effect until the *following* touch
      // sequence.  This is a desirable side-effect, giving the renderer a chance
      // to send a touch-action response without racing against the ack timeout.
      UpdateTouchAckTimeoutEnabled();
    }
  
    FilterAndSendWebInputEvent(touch_event.event, touch_event.latency);
  }
  
  void InputRouterImpl::SendGestureEventImmediately(
      const GestureEventWithLatencyInfo& gesture_event) {
    FilterAndSendWebInputEvent(gesture_event.event, gesture_event.latency);
  }
  
  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;
  }
  
  bool InputRouterImpl::OnMessageReceived(const IPC::Message& message) {
    bool handled = true;
    IPC_BEGIN_MESSAGE_MAP(InputRouterImpl, message)
      IPC_MESSAGE_HANDLER(InputHostMsg_HandleInputEvent_ACK, OnInputEventAck)
      IPC_MESSAGE_HANDLER(InputHostMsg_DidOverscroll, OnDidOverscroll)
      IPC_MESSAGE_HANDLER(InputHostMsg_MoveCaret_ACK, OnMsgMoveCaretAck)
      IPC_MESSAGE_HANDLER(InputHostMsg_SelectRange_ACK, OnSelectMessageAck)
      IPC_MESSAGE_HANDLER(InputHostMsg_MoveRangeSelectionExtent_ACK,
                          OnSelectMessageAck)
      IPC_MESSAGE_HANDLER(ViewHostMsg_HasTouchEventHandlers,
                          OnHasTouchEventHandlers)
      IPC_MESSAGE_HANDLER(InputHostMsg_SetTouchAction,
                          OnSetTouchAction)
      IPC_MESSAGE_HANDLER(InputHostMsg_DidStopFlinging, OnDidStopFlinging)
      IPC_MESSAGE_UNHANDLED(handled = false)
    IPC_END_MESSAGE_MAP()
  
    return handled;
  }
  
  void InputRouterImpl::OnTouchEventAck(const TouchEventWithLatencyInfo& event,
                                        InputEventAckState ack_result) {
    // Touchstart events sent to the renderer indicate a new touch sequence, but
    // in some cases we may filter out sending the touchstart - catch those here.
    if (WebTouchEventTraits::IsTouchSequenceStart(event.event) &&
        ack_result == INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS) {
      touch_action_filter_.ResetTouchAction();
      UpdateTouchAckTimeoutEnabled();
    }
    ack_handler_->OnTouchEventAck(event, ack_result);
  }
  
  void InputRouterImpl::OnFilteringTouchEvent(
      const WebTouchEvent& touch_event) {
    // The event stream given to the renderer is not guaranteed to be
    // valid based on the current TouchEventStreamValidator rules. This event will
    // never be given to the renderer, but in order to ensure that the event
    // stream |output_stream_validator_| sees is valid, we give events which are
    // filtered out to the validator. crbug.com/589111 proposes adding an
    // additional validator for the events which are actually sent to the
    // renderer.
    output_stream_validator_.Validate(touch_event);
  }
  
  void InputRouterImpl::OnGestureEventAck(
      const GestureEventWithLatencyInfo& event,
      InputEventAckState ack_result) {
    touch_event_queue_.OnGestureEventAck(event, ack_result);
    ack_handler_->OnGestureEventAck(event, ack_result);
  }
  
  void InputRouterImpl::ForwardGestureEventWithLatencyInfo(
      const blink::WebGestureEvent& event,
      const ui::LatencyInfo& latency_info) {
    client_->ForwardGestureEventWithLatencyInfo(event, latency_info);
  }
  
  void InputRouterImpl::SendMouseWheelEventImmediately(
      const MouseWheelEventWithLatencyInfo& wheel_event) {
    FilterAndSendWebInputEvent(wheel_event.event, wheel_event.latency);
  }
  
  void InputRouterImpl::OnMouseWheelEventAck(
      const MouseWheelEventWithLatencyInfo& event,
      InputEventAckState ack_result) {
    ack_handler_->OnWheelEventAck(event, ack_result);
  }
  
  bool InputRouterImpl::SendSelectMessage(std::unique_ptr<IPC::Message> message) {
    DCHECK(message->type() == InputMsg_SelectRange::ID ||
           message->type() == InputMsg_MoveRangeSelectionExtent::ID);
  
    // TODO(jdduke): Factor out common logic between selection and caret-related
    //               IPC messages.
    if (select_message_pending_) {
      if (!pending_select_messages_.empty() &&
          pending_select_messages_.back()->type() == message->type()) {
        pending_select_messages_.pop_back();
      }
  
      pending_select_messages_.push_back(std::move(message));
      return true;
    }
  
    select_message_pending_ = true;
    return Send(message.release());
  }
  
  bool InputRouterImpl::SendMoveCaret(std::unique_ptr<IPC::Message> message) {
    DCHECK(message->type() == InputMsg_MoveCaret::ID);
    if (move_caret_pending_) {
      next_move_caret_ = std::move(message);
      return true;
    }
  
    move_caret_pending_ = true;
    return Send(message.release());
  }
  
  bool InputRouterImpl::Send(IPC::Message* message) {
    return sender_->Send(message);
  }
  
  void InputRouterImpl::FilterAndSendWebInputEvent(
      const WebInputEvent& input_event,
      const ui::LatencyInfo& latency_info) {
    TRACE_EVENT1("input", "InputRouterImpl::FilterAndSendWebInputEvent", "type",
                 WebInputEvent::GetName(input_event.type()));
    TRACE_EVENT_WITH_FLOW2("input,benchmark,devtools.timeline",
                           "LatencyInfo.Flow",
                           TRACE_ID_DONT_MANGLE(latency_info.trace_id()),
                           TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
                           "step", "SendInputEventUI",
                           "frameTreeNodeId", frame_tree_node_id_);
  
    OfferToHandlers(input_event, latency_info);
  }
  
  void InputRouterImpl::OfferToHandlers(const WebInputEvent& input_event,
                                        const ui::LatencyInfo& latency_info) {
    output_stream_validator_.Validate(input_event);
  
    if (OfferToClient(input_event, latency_info))
      return;
  
    bool should_block = WebInputEventTraits::ShouldBlockEventStream(input_event);
    OfferToRenderer(input_event, latency_info,
                    should_block
                        ? InputEventDispatchType::DISPATCH_TYPE_BLOCKING
                        : InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING);
  
    // Generate a synthetic ack if the event was sent so it doesn't block.
    if (!should_block) {
      ProcessInputEventAck(
          input_event.type(), INPUT_EVENT_ACK_STATE_IGNORED, latency_info,
          WebInputEventTraits::GetUniqueTouchEventId(input_event),
          IGNORING_DISPOSITION);
    }
  }
  
  bool InputRouterImpl::OfferToClient(const WebInputEvent& input_event,
                                      const ui::LatencyInfo& latency_info) {
    bool consumed = false;
  
    InputEventAckState filter_ack =
        client_->FilterInputEvent(input_event, latency_info);
    switch (filter_ack) {
      case INPUT_EVENT_ACK_STATE_CONSUMED:
      case INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS:
        // Send the ACK and early exit.
        ProcessInputEventAck(
            input_event.type(), filter_ack, latency_info,
            WebInputEventTraits::GetUniqueTouchEventId(input_event), CLIENT);
        // WARNING: |this| may be deleted at this point.
        consumed = true;
        break;
      case INPUT_EVENT_ACK_STATE_UNKNOWN:
        // Simply drop the event.
        consumed = true;
        break;
      default:
        break;
    }
  
    return consumed;
  }
  
  bool InputRouterImpl::OfferToRenderer(const WebInputEvent& input_event,
                                        const ui::LatencyInfo& latency_info,
                                        InputEventDispatchType dispatch_type) {
    DCHECK(input_event.type() != blink::WebInputEvent::GestureFlingStart ||
           static_cast<const blink::WebGestureEvent&>(input_event)
                   .data.flingStart.velocityX != 0.0 ||
           static_cast<const blink::WebGestureEvent&>(input_event)
                   .data.flingStart.velocityY != 0.0);
  
    // This conversion is temporary. WebInputEvent should be generated
    // directly from ui::Event with the viewport coordinates. See
    // crbug.com/563730.
    std::unique_ptr<blink::WebInputEvent> event_in_viewport =
        ui::ScaleWebInputEvent(input_event, device_scale_factor_);
    const WebInputEvent* event_to_send =
        event_in_viewport ? event_in_viewport.get() : &input_event;
  
    if (Send(new InputMsg_HandleInputEvent(routing_id(), event_to_send,
                                           latency_info, dispatch_type))) {
      // Ack messages for ignored ack event types should never be sent by the
      // renderer. Consequently, such event types should not affect event time
      // or in-flight event count metrics.
      if (dispatch_type == InputEventDispatchType::DISPATCH_TYPE_BLOCKING)
        client_->IncrementInFlightEventCount(input_event.type());
      return true;
    }
    return false;
  }
  
  void InputRouterImpl::OnInputEventAck(const InputEventAck& ack) {
    client_->DecrementInFlightEventCount(ack.source);
  
    if (ack.overscroll) {
      DCHECK(ack.type == WebInputEvent::MouseWheel ||
             ack.type == WebInputEvent::GestureScrollUpdate);
      OnDidOverscroll(*ack.overscroll);
    }
  
    ProcessInputEventAck(ack.type, ack.state, ack.latency,
                         ack.unique_touch_event_id, RENDERER);
  }
  
  void InputRouterImpl::OnDidOverscroll(const ui::DidOverscrollParams& params) {
    client_->DidOverscroll(params);
  }
  
  void InputRouterImpl::OnMsgMoveCaretAck() {
    move_caret_pending_ = false;
    if (next_move_caret_)
      SendMoveCaret(std::move(next_move_caret_));
  }
  
  void InputRouterImpl::OnSelectMessageAck() {
    select_message_pending_ = false;
    if (!pending_select_messages_.empty()) {
      std::unique_ptr<IPC::Message> next_message =
          std::move(pending_select_messages_.front());
      pending_select_messages_.pop_front();
  
      SendSelectMessage(std::move(next_message));
    }
  }
  
  void InputRouterImpl::OnHasTouchEventHandlers(bool has_handlers) {
    TRACE_EVENT1("input", "InputRouterImpl::OnHasTouchEventHandlers",
                 "has_handlers", has_handlers);
  
    // Lack of a touch handler indicates that the page either has no touch-action
    // modifiers or that all its touch-action modifiers are auto. Resetting the
    // touch-action here allows forwarding of subsequent gestures even if the
    // underlying touches never reach the router.
    if (!has_handlers)
      touch_action_filter_.ResetTouchAction();
  
    touch_event_queue_.OnHasTouchEventHandlers(has_handlers);
    client_->OnHasTouchEventHandlers(has_handlers);
  }
  
  void InputRouterImpl::OnSetTouchAction(TouchAction touch_action) {
    // Synthetic touchstart events should get filtered out in RenderWidget.
    DCHECK(touch_event_queue_.IsPendingAckTouchStart());
    TRACE_EVENT1("input", "InputRouterImpl::OnSetTouchAction",
                 "action", touch_action);
  
    touch_action_filter_.OnSetTouchAction(touch_action);
  
    // TOUCH_ACTION_NONE 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",
                 WebInputEvent::GetName(event_type), "ack",
                 GetEventAckName(ack_result));
  
    // Note: The keyboard ack must be treated carefully, as it may result in
    // synchronous destruction of |this|. Handling immediately guards against
    // future references to |this|, as with |auto_reset_current_ack_source| below.
    if (WebInputEvent::isKeyboardEventType(event_type)) {
      ProcessKeyboardAck(event_type, ack_result, latency_info);
      // WARNING: |this| may be deleted at this point.
      return;
    }
  
    base::AutoReset<AckSource> auto_reset_current_ack_source(
        &current_ack_source_, ack_source);
  
    if (WebInputEvent::isMouseEventType(event_type)) {
      ProcessMouseAck(event_type, ack_result, latency_info);
    } else if (event_type == WebInputEvent::MouseWheel) {
      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::Undefined) {
      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.type() != type) {
      // Something must be wrong. Clear the |key_queue_| and char event
      // suppression so that we can resume from the error.
      key_queue_.clear();
      ack_handler_->OnUnexpectedEventAck(InputAckHandler::UNEXPECTED_EVENT_TYPE);
    } else {
      NativeWebKeyboardEventWithLatencyInfo front_item = key_queue_.front();
      front_item.latency.AddNewLatencyFrom(latency);
      key_queue_.pop_front();
  
      ack_handler_->OnKeyboardEventAck(front_item, ack_result);
      // WARNING: This InputRouterImpl can be deallocated at this point
      // (i.e.  in the case of Ctrl+W, where the call to
      // HandleKeyboardEvent destroys this InputRouterImpl).
      // TODO(jdduke): crbug.com/274029 - Make ack-triggered shutdown async.
    }
  }
  
  void InputRouterImpl::ProcessMouseAck(blink::WebInputEvent::Type type,
                                        InputEventAckState ack_result,
                                        const ui::LatencyInfo& latency) {
    if (type != WebInputEvent::MouseMove)
      return;
  
    if (mouse_move_queue_.empty()) {
      ack_handler_->OnUnexpectedEventAck(InputAckHandler::UNEXPECTED_ACK);
    } else {
      MouseEventWithLatencyInfo front_item = mouse_move_queue_.front();
      front_item.latency.AddNewLatencyFrom(latency);
      mouse_move_queue_.pop_front();
      ack_handler_->OnMouseEventAck(front_item, ack_result);
    }
  }
  
  void InputRouterImpl::ProcessWheelAck(InputEventAckState ack_result,
                                        const ui::LatencyInfo& latency) {
    wheel_event_queue_.ProcessMouseWheelAck(ack_result, latency);
  }
  
  void InputRouterImpl::ProcessGestureAck(WebInputEvent::Type type,
                                          InputEventAckState ack_result,
                                          const ui::LatencyInfo& latency) {
    if (type == blink::WebInputEvent::GestureFlingStart &&
        ack_result == INPUT_EVENT_ACK_STATE_CONSUMED) {
      ++active_renderer_fling_count_;
    }
  
    // |gesture_event_queue_| will forward to OnGestureEventAck when appropriate.
    gesture_event_queue_.ProcessGestureAck(ack_result, type, latency);
  }
  
  void InputRouterImpl::ProcessTouchAck(InputEventAckState ack_result,
                                        const ui::LatencyInfo& latency,
                                        uint32_t unique_touch_event_id) {
    // |touch_event_queue_| will forward to OnTouchEventAck when appropriate.
    touch_event_queue_.ProcessTouchAck(ack_result, latency,
                                       unique_touch_event_id);
  }
  
  void InputRouterImpl::UpdateTouchAckTimeoutEnabled() {
    // TOUCH_ACTION_NONE 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() != TOUCH_ACTION_NONE;
    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;
  }
  
  }  // namespace content
  