Provided batched input delivery with a BufferedInputRouter

content/browser/renderer_host/input/immediate_input_router.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/immediate_input_router.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "content/browser/renderer_host/input/gesture_event_filter.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/browser/renderer_host/render_process_host_impl.h"
 #include "content/common/content_constants_internal.h"
 #include "content/common/edit_command.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/port/common/input_event_ack_state.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 44 matching lines @@
     case INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS: return "NO_CONSUMER_EXISTS";
   default:
     DLOG(WARNING) << "Unhandled InputEventAckState in GetEventAckName.\n";
     break;
   }
   return "";
 }
 
 } // namespace
 
-ImmediateInputRouter::ImmediateInputRouter(
-    RenderProcessHost* process,
-    InputRouterClient* client,
-    int routing_id)
+ImmediateInputRouter::ImmediateInputRouter(RenderProcessHost* process,
+                                           InputRouterClient* client,
+                                           InputAckHandler* ack_handler,
+                                           int routing_id)
     : process_(process),
       client_(client),
+      ack_handler_(ack_handler),
       routing_id_(routing_id),
       select_range_pending_(false),
       move_caret_pending_(false),
       mouse_move_pending_(false),
       mouse_wheel_pending_(false),
       has_touch_handler_(false),
       touch_event_queue_(new TouchEventQueue(this)),
       gesture_event_filter_(new GestureEventFilter(this)) {
   enable_no_touch_to_renderer_while_scrolling_ =
-      CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-          switches::kNoTouchToRendererWhileScrolling) == "1";
+      CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kNoTouchToRendererWhileScrolling);
   DCHECK(process);
   DCHECK(client);
 }
 
 ImmediateInputRouter::~ImmediateInputRouter() {
 }
 
-bool ImmediateInputRouter::SendInput(IPC::Message* message) {
+void ImmediateInputRouter::Flush() {
+  NOTREACHED() << "ImmediateInputRouter will never request a flush.";
+}
+
+bool ImmediateInputRouter::SendInput(scoped_ptr<IPC::Message> message) {
   DCHECK(IPC_MESSAGE_ID_CLASS(message->type()) == InputMsgStart);
-  scoped_ptr<IPC::Message> scoped_message(message);
-  switch (scoped_message->type()) {
+  switch (message->type()) {
     // Check for types that require an ACK.
     case InputMsg_SelectRange::ID:
-      return SendSelectRange(scoped_message.release());
+      return SendSelectRange(message.Pass());
     case InputMsg_MoveCaret::ID:
-      return SendMoveCaret(scoped_message.release());
+      return SendMoveCaret(message.Pass());
     case InputMsg_HandleInputEvent::ID:
       NOTREACHED() << "WebInputEvents should never be sent via SendInput.";
       return false;
     default:
-      return Send(scoped_message.release());
+      return Send(message.release());
   }
 }
 
 void ImmediateInputRouter::SendMouseEvent(
     const MouseEventWithLatencyInfo& mouse_event) {
   if (!client_->OnSendMouseEvent(mouse_event))
     return;
 
   if (mouse_event.event.type == WebInputEvent::MouseDown &&
       gesture_event_filter_->GetTouchpadTapSuppressionController()->
@@ skipping 170 matching lines @@
   IPC_BEGIN_MESSAGE_MAP_EX(ImmediateInputRouter, message, message_is_ok)
     IPC_MESSAGE_HANDLER(InputHostMsg_HandleInputEvent_ACK, OnInputEventAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_MoveCaret_ACK, OnMsgMoveCaretAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SelectRange_ACK, OnSelectRangeAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_HasTouchEventHandlers,
                         OnHasTouchEventHandlers)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   if (!message_is_ok)
-    client_->OnUnexpectedEventAck(true);
+    ack_handler_->OnUnexpectedEventAck(InputAckHandler::BAD_ACK_MESSAGE);
 
   return handled;
 }
 
 void ImmediateInputRouter::OnTouchEventAck(
     const TouchEventWithLatencyInfo& event,
     InputEventAckState ack_result) {
-  client_->OnTouchEventAck(event, ack_result);
+  ack_handler_->OnTouchEventAck(event, ack_result);
 }
 
-bool ImmediateInputRouter::SendSelectRange(IPC::Message* message) {
+bool ImmediateInputRouter::SendSelectRange(scoped_ptr<IPC::Message> message) {
   DCHECK(message->type() == InputMsg_SelectRange::ID);
   if (select_range_pending_) {
-    next_selection_range_.reset(message);
+    next_selection_range_ = message.Pass();
     return true;
   }
 
   select_range_pending_ = true;
-  return Send(message);
+  return Send(message.release());
 }
 
-bool ImmediateInputRouter::SendMoveCaret(IPC::Message* message) {
+bool ImmediateInputRouter::SendMoveCaret(scoped_ptr<IPC::Message> message) {
   DCHECK(message->type() == InputMsg_MoveCaret::ID);
   if (move_caret_pending_) {
-    next_move_caret_.reset(message);
+    next_move_caret_ = message.Pass();
     return true;
   }
 
   move_caret_pending_ = true;
-  return Send(message);
+  return Send(message.release());
 }
 
 bool ImmediateInputRouter::Send(IPC::Message* message) {
   return process_->Send(message);
 }
 
 void ImmediateInputRouter::SendWebInputEvent(
     const WebInputEvent& input_event,
     const ui::LatencyInfo& latency_info,
     bool is_keyboard_shortcut) {
@@ skipping 53 matching lines @@
         // the overscroll is updated properly.
         touch_event_queue_->ProcessTouchAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED,
                                             latency_info);
       }
       return;
     }
 
     // Proceed as normal.
     case INPUT_EVENT_ACK_STATE_NOT_CONSUMED:
       break;
-  };
+  }
 
   // Transmit any pending wheel events on a non-wheel event. This ensures that
   // the renderer receives the final PhaseEnded wheel event, which is necessary
   // to terminate rubber-banding, for example.
   if (input_event.type != WebInputEvent::MouseWheel) {
     for (size_t i = 0; i < coalesced_mouse_wheel_events_.size(); ++i) {
       SendWebInputEvent(coalesced_mouse_wheel_events_[i].event,
                        coalesced_mouse_wheel_events_[i].latency,
                       false);
     }
@@ skipping 15 matching lines @@
   UMA_HISTOGRAM_TIMES("MPArch.IIR_InputEventDelta", delta);
 
   client_->DecrementInFlightEventCount();
 
   ProcessInputEventAck(event_type, ack_result, latency_info);
 }
 
 void ImmediateInputRouter::OnMsgMoveCaretAck() {
   move_caret_pending_ = false;
   if (next_move_caret_)
-    SendMoveCaret(next_move_caret_.release());
+    SendMoveCaret(next_move_caret_.Pass());
 }
 
 void ImmediateInputRouter::OnSelectRangeAck() {
   select_range_pending_ = false;
   if (next_selection_range_)
-    SendSelectRange(next_selection_range_.release());
+    SendSelectRange(next_selection_range_.Pass());
 }
 
 void ImmediateInputRouter::OnHasTouchEventHandlers(bool has_handlers) {
  if (has_touch_handler_ == has_handlers)
     return;
   has_touch_handler_ = has_handlers;
   if (!has_handlers)
     touch_event_queue_->FlushQueue();
   client_->OnHasTouchEventHandlers(has_handlers);
 }
 
 void ImmediateInputRouter::ProcessInputEventAck(
     WebInputEvent::Type event_type,
     InputEventAckState ack_result,
     const ui::LatencyInfo& latency_info) {
   TRACE_EVENT1("input", "ImmediateInputRouter::ProcessInputEventAck",
                "ack", GetEventAckName(ack_result));
 
   int type = static_cast<int>(event_type);
   if (type < WebInputEvent::Undefined) {
-    client_->OnUnexpectedEventAck(true);
+    ack_handler_->OnUnexpectedEventAck(InputAckHandler::BAD_ACK_MESSAGE);
   } else if (type == WebInputEvent::MouseMove) {
     mouse_move_pending_ = false;
 
     // now, we can send the next mouse move event
     if (next_mouse_move_) {
       DCHECK(next_mouse_move_->event.type == WebInputEvent::MouseMove);
       scoped_ptr<MouseEventWithLatencyInfo> next_mouse_move
           = next_mouse_move_.Pass();
       SendMouseEvent(*next_mouse_move);
     }
@@ skipping 19 matching lines @@
   NotificationService::current()->Notify(
       NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_INPUT_EVENT_ACK,
       Source<void>(this),
       Details<int>(&type));
 }
 
 void ImmediateInputRouter::ProcessKeyboardAck(
     int type,
     InputEventAckState ack_result) {
   if (key_queue_.empty()) {
-    LOG(ERROR) << "Got a KeyEvent back from the renderer but we "
-               << "don't seem to have sent it to the renderer!";
+    ack_handler_->OnUnexpectedEventAck(InputAckHandler::UNEXPECTED_ACK);
   } else if (key_queue_.front().type != type) {
-    LOG(ERROR) << "We seem to have a different key type sent from "
-               << "the renderer. (" << key_queue_.front().type << " vs. "
-               << type << "). Ignoring event.";
-
     // Something must be wrong. Clear the |key_queue_| and char event
     // suppression so that we can resume from the error.
     key_queue_.clear();
-    client_->OnUnexpectedEventAck(false);
+    ack_handler_->OnUnexpectedEventAck(InputAckHandler::UNEXPECTED_EVENT_TYPE);
   } else {
     NativeWebKeyboardEvent front_item = key_queue_.front();
     key_queue_.pop_front();
 
-    client_->OnKeyboardEventAck(front_item, ack_result);
-
+    ack_handler_->OnKeyboardEventAck(front_item, ack_result);
     // WARNING: This ImmediateInputRouter can be deallocated at this point
     // (i.e.  in the case of Ctrl+W, where the call to
     // HandleKeyboardEvent destroys this ImmediateInputRouter).
   }
 }
 
 void ImmediateInputRouter::ProcessWheelAck(InputEventAckState ack_result) {
   mouse_wheel_pending_ = false;
 
   // Process the unhandled wheel event here before calling
   // ForwardWheelEventWithLatencyInfo() since it will mutate
   // current_wheel_event_.
-  client_->OnWheelEventAck(current_wheel_event_.event, ack_result);
+  ack_handler_->OnWheelEventAck(current_wheel_event_.event, ack_result);
 
   // Now send the next (coalesced) mouse wheel event.
   if (!coalesced_mouse_wheel_events_.empty()) {
     MouseWheelEventWithLatencyInfo next_wheel_event =
         coalesced_mouse_wheel_events_.front();
     coalesced_mouse_wheel_events_.pop_front();
     SendWheelEvent(next_wheel_event);
   }
 }
 
 void ImmediateInputRouter::ProcessGestureAck(int type,
                                              InputEventAckState ack_result) {
   const bool processed = (INPUT_EVENT_ACK_STATE_CONSUMED == ack_result);
-  client_->OnGestureEventAck(
+  ack_handler_->OnGestureEventAck(
       gesture_event_filter_->GetGestureEventAwaitingAck(), ack_result);
   gesture_event_filter_->ProcessGestureAck(processed, type);
 }
 
 void ImmediateInputRouter::ProcessTouchAck(
     InputEventAckState ack_result,
     const ui::LatencyInfo& latency_info) {
   // |touch_event_queue_| will forward to OnTouchEventAck when appropriate.
   touch_event_queue_->ProcessTouchAck(ack_result, latency_info);
 }
 
 void ImmediateInputRouter::HandleGestureScroll(
     const GestureEventWithLatencyInfo& gesture_event) {
   if (!enable_no_touch_to_renderer_while_scrolling_)
     return;
 
   // Once scrolling is started stop forwarding touch move events to renderer.
   if (gesture_event.event.type == WebInputEvent::GestureScrollBegin)
     touch_event_queue_->set_no_touch_move_to_renderer(true);
 
   if (gesture_event.event.type == WebInputEvent::GestureScrollEnd ||
       gesture_event.event.type == WebInputEvent::GestureFlingStart) {
     touch_event_queue_->set_no_touch_move_to_renderer(false);
   }
 }
 
 }  // namespace content