[WIP] BufferedInputRouter

content/renderer/gpu/input_event_filter.cc

Index: content/renderer/gpu/input_event_filter.cc
diff --git a/content/renderer/gpu/input_event_filter.cc b/content/renderer/gpu/input_event_filter.cc
index 208c47180f9c9dc26f86ce9f7bfe1a341aedda13..9f4d74151a6355e9e319f03f47187a3105973da9 100644
--- a/content/renderer/gpu/input_event_filter.cc
+++ b/content/renderer/gpu/input_event_filter.cc
@@ -12,6 +12,7 @@
 #include "content/common/view_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/renderer/gpu/input_event_filter.h"
+#include "ipc/ipc_message_utils.h"
 #include "ui/gfx/vector2d_f.h"
 
 using WebKit::WebInputEvent;
@@ -55,12 +56,9 @@ void InputEventFilter::DidOverscroll(int routing_id,
   if (!overscroll_notifications_enabled_)
     return;
 
-  io_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&InputEventFilter::SendMessageOnIOThread, this,
-                 ViewHostMsg_DidOverscroll(routing_id,
-                                           params.accumulated_overscroll,
-                                           params.current_fling_velocity)));
+  Send(new ViewHostMsg_DidOverscroll(routing_id,
+                                     params.accumulated_overscroll,
+                                     params.current_fling_velocity));
 }
 
 void InputEventFilter::OnFilterAdded(IPC::Channel* channel) {
@@ -106,21 +104,34 @@ bool InputEventFilter::OnMessageReceived(const IPC::Message& message) {
 InputEventFilter::~InputEventFilter() {
 }
 
+void InputEventFilter::ForwardToHandler(const IPC::Message& message) {
+  DCHECK(target_loop_->BelongsToCurrentThread());
+  IPC_BEGIN_MESSAGE_MAP(InputEventFilter, message)
+    IPC_MESSAGE_HANDLER_GENERIC(InputMsg_HandleInputEvent,
+                                OnHandleInputEvent(message))
+    IPC_MESSAGE_HANDLER_GENERIC(InputMsg_HandleEventPacket,
+                                OnHandleEventPacket(message))
+    IPC_MESSAGE_UNHANDLED(ForwardToMainListener(message))
+  IPC_END_MESSAGE_MAP()
+}
+
 void InputEventFilter::ForwardToMainListener(const IPC::Message& message) {
+  DCHECK(target_loop_->BelongsToCurrentThread());
+  main_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&InputEventFilter::ForwardToMainListenerOnMainThread,
+                 this, message));
+}
+
+void InputEventFilter::ForwardToMainListenerOnMainThread(
+    const IPC::Message& message) {
+  DCHECK(main_loop_->BelongsToCurrentThread());
   main_listener_->OnMessageReceived(message);
 }
 
-void InputEventFilter::ForwardToHandler(const IPC::Message& message) {
+void InputEventFilter::OnHandleInputEvent(const IPC::Message& message) {
   DCHECK(!handler_.is_null());
-  DCHECK(target_loop_->BelongsToCurrentThread());
-
-  if (message.type() != InputMsg_HandleInputEvent::ID) {
-    main_loop_->PostTask(
-        FROM_HERE,
-        base::Bind(&InputEventFilter::ForwardToMainListener,
-                   this, message));
-    return;
-  }
+  TRACE_EVENT0("input", "InputEventFilter::OnHandleInputEvent");
 
   int routing_id = message.routing_id();
   ui::LatencyInfo latency_info;
@@ -131,43 +142,71 @@ void InputEventFilter::ForwardToHandler(const IPC::Message& message) {
     return;
   DCHECK(event);
 
-  InputEventAckState ack =
-      handler_.Run(routing_id, event, latency_info);
+  InputEventAckState ack = handler_.Run(routing_id, event, latency_info);
 
   if (ack == INPUT_EVENT_ACK_STATE_NOT_CONSUMED) {
-    TRACE_EVENT0("input", "InputEventFilter::ForwardToHandler");
-    IPC::Message new_msg = InputMsg_HandleInputEvent(
-        routing_id, event, latency_info, is_keyboard_shortcut);
-    main_loop_->PostTask(
-        FROM_HERE,
-        base::Bind(&InputEventFilter::ForwardToMainListener,
-                   this, new_msg));
+    TRACE_EVENT0("input", "InputEventFilter::ForwardToMainHandler");
+    ForwardToMainListener(message);
     return;
   }
 
-  SendACK(event->type, ack, latency_info, routing_id);
+  Send(new InputHostMsg_HandleInputEvent_ACK(
+      message.routing_id(), event->type, ack, latency_info));
 }
 
-void InputEventFilter::SendACK(WebKit::WebInputEvent::Type type,
-                               InputEventAckState ack_result,
-                               const ui::LatencyInfo& latency_info,
-                               int routing_id) {
+void InputEventFilter::OnHandleEventPacket(const IPC::Message& message) {
+  DCHECK(!handler_.is_null());
+  InputMsg_HandleEventPacket::Param param;
+  if (!InputMsg_HandleEventPacket::Read(&message, &param))
+    return;
+
+  TRACE_EVENT1("input", "InputEventFilter::OnHandleEventPacket",
+               "id", param.a.id());
+  RendererEventPacket packet(&param.a, param.b);
+
+  scoped_ptr<IPC::Message> dispatch_result =
+      packet.DispatchWith(this,
+                          RendererEventPacket::THREAD_IMPL,
+                          message.routing_id());
+
+  if (dispatch_result->type() == InputHostMsg_HandleEventPacket_ACK::ID)
+    Send(dispatch_result.release());
+  else
+    ForwardToMainListener(*dispatch_result);
+}
+
+void InputEventFilter::Send(IPC::Message* message) {
   DCHECK(target_loop_->BelongsToCurrentThread());
 
   io_loop_->PostTask(
       FROM_HERE,
-      base::Bind(&InputEventFilter::SendMessageOnIOThread, this,
-                 InputHostMsg_HandleInputEvent_ACK(
-                     routing_id, type, ack_result, latency_info)));
+      base::Bind(&InputEventFilter::SendOnIOThread, this,
+                 base::Passed(scoped_ptr<IPC::Message>(message))));
 }
 
-void InputEventFilter::SendMessageOnIOThread(const IPC::Message& message) {
+void InputEventFilter::SendOnIOThread(scoped_ptr<IPC::Message> message) {
   DCHECK(io_loop_->BelongsToCurrentThread());
 
   if (!sender_)
     return;  // Filter was removed.
 
-  sender_->Send(new IPC::Message(message));
+  sender_->Send(message.release());
+}
+
+InputEventDisposition InputEventFilter::Dispatch(const IPC::Message& message) {
+  TRACE_EVENT0("input", "InputEventFilter::ForwardToMainHandler");
+  ForwardToMainListener(message);
+  return INPUT_EVENT_MAIN_THREAD_CONSUMED;
+}
+
+InputEventDisposition InputEventFilter::Dispatch(
+    int routing_id,
+    const WebKit::WebInputEvent* web_event,
+    const ui::LatencyInfo& latency_info,
+    bool is_keyboard_shortcut) {
+  InputEventAckState ack_state =
+      handler_.Run(routing_id, web_event, latency_info);
+  return ToDisposition(ack_state, false, false);
 }
 
 }  // namespace content