ipc: Use existing [de]serializer for WebInputEvent.

There is an existing serializer/deserializer for WebInputEvent (used
for plugins). Use that everywhere else, instead of reading/writing
directly into the IPC message.

BUG=164682

Review URL: https://codereview.chromium.org/11471022

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@173012 0039d316-1c4b-4281-b951-d872f2087c98

17 files changed, 136 insertions, 143 deletions

diff --git a/content/browser/browser_plugin/browser_plugin_embedder_helper.cc b/content/browser/browser_plugin/browser_plugin_embedder_helper.cc
index cfd0eb9..60d9117 100644
--- a/content/browser/browser_plugin/browser_plugin_embedder_helper.cc
+++ b/content/browser/browser_plugin/browser_plugin_embedder_helper.cc
@@ -34,16 +34,16 @@ bool BrowserPluginEmbedderHelper::OnMessageReceived(
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BrowserPluginEmbedderHelper, message)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_CreateGuest,
-                        OnCreateGuest);
+                        OnCreateGuest)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_NavigateGuest,
-                        OnNavigateGuest);
+                        OnNavigateGuest)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_ResizeGuest, OnResizeGuest)
-    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_UpdateRect_ACK, OnUpdateRectACK);
-    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetFocus, OnSetFocus);
-    IPC_MESSAGE_HANDLER_GENERIC(BrowserPluginHostMsg_HandleInputEvent,
-        OnHandleInputEvent(message))
+    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_UpdateRect_ACK, OnUpdateRectACK)
+    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetFocus, OnSetFocus)
+    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_HandleInputEvent,
+                        OnHandleInputEvent)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_PluginDestroyed,
-                        OnPluginDestroyed);
+                        OnPluginDestroyed)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_Go, OnGo)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_Stop, OnStop)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_Reload, OnReload)
@@ -69,29 +69,14 @@ void BrowserPluginEmbedderHelper::OnResizeGuest(
 }
 
 void BrowserPluginEmbedderHelper::OnHandleInputEvent(
-    const IPC::Message& message) {
-  PickleIterator iter(message);
-
-  int instance_id = -1;
-  const char* guest_rect_data = NULL;
-  int guest_rect_data_length = -1;
-  const char* input_event_data = NULL;
-  int input_event_data_length = -1;
-  if (!message.ReadInt(&iter, &instance_id) ||
-      !message.ReadData(&iter, &guest_rect_data, &guest_rect_data_length) ||
-      !message.ReadData(&iter, &input_event_data, &input_event_data_length)) {
-    return;
-  }
-  const gfx::Rect* guest_window_rect =
-      reinterpret_cast<const gfx::Rect*>(guest_rect_data);
-  const WebKit::WebInputEvent* input_event =
-      reinterpret_cast<const WebKit::WebInputEvent*>(input_event_data);
+    int instance_id,
+    const gfx::Rect& guest_window_rect,
+    const WebKit::WebInputEvent* input_event) {
   RenderViewHostImpl* rvh = static_cast<RenderViewHostImpl*>(
       render_view_host());
-
   embedder_->HandleInputEvent(instance_id,
                               rvh,
-                              *guest_window_rect,
+                              guest_window_rect,
                               *input_event);
 }
 
diff --git a/content/browser/browser_plugin/browser_plugin_embedder_helper.h b/content/browser/browser_plugin/browser_plugin_embedder_helper.h
index 4f262d7..d4bbab7 100644
--- a/content/browser/browser_plugin/browser_plugin_embedder_helper.h
+++ b/content/browser/browser_plugin/browser_plugin_embedder_helper.h
@@ -14,14 +14,18 @@
 
 namespace IPC {
 class Message;
-class SyncMessage;
 }
 
 namespace gfx {
 class Point;
+class Rect;
 class Size;
 }
 
+namespace WebKit {
+class WebInputEvent;
+}
+
 struct BrowserPluginHostMsg_AutoSize_Params;
 struct BrowserPluginHostMsg_CreateGuest_Params;
 struct BrowserPluginHostMsg_ResizeGuest_Params;
@@ -68,7 +72,9 @@ class BrowserPluginEmbedderHelper : public RenderViewHostObserver {
       const BrowserPluginHostMsg_AutoSize_Params& auto_size_params,
       const BrowserPluginHostMsg_ResizeGuest_Params& resize_guest_params);
   void OnSwapBuffersACK(int route_id, int gpu_host_id, uint32 sync_point);
-  void OnHandleInputEvent(const IPC::Message& message);
+  void OnHandleInputEvent(int instance_id,
+                          const gfx::Rect& guest_window_rect,
+                          const WebKit::WebInputEvent* input_event);
   void OnSetFocus(int instance_id, bool focused);
   void OnPluginDestroyed(int instance_id);
   void OnGo(int instance_id, int relative_index);
diff --git a/content/browser/browser_plugin/browser_plugin_guest.cc b/content/browser/browser_plugin/browser_plugin_guest.cc
index 9ec5559..c8f5116 100644
--- a/content/browser/browser_plugin/browser_plugin_guest.cc
+++ b/content/browser/browser_plugin/browser_plugin_guest.cc
@@ -464,21 +464,20 @@ void BrowserPluginGuest::HandleInputEvent(RenderViewHost* render_view_host,
   guest_screen_rect_ = guest_screen_rect;
   RenderViewHostImpl* guest_rvh = static_cast<RenderViewHostImpl*>(
       web_contents()->GetRenderViewHost());
-  IPC::Message* message = new ViewMsg_HandleInputEvent(routing_id());
-
-  // Copy the WebInputEvent and modify the event type. The guest expects
-  // WebInputEvent::RawKeyDowns and not KeyDowns.
-  scoped_array<char> input_buffer(new char[event.size]);
-  memcpy(input_buffer.get(), &event, event.size);
-  WebKit::WebInputEvent* input_event =
-      reinterpret_cast<WebKit::WebInputEvent*>(input_buffer.get());
-  if (event.type == WebKit::WebInputEvent::KeyDown)
-    input_event->type = WebKit::WebInputEvent::RawKeyDown;
-
-  message->WriteData(input_buffer.get(), event.size);
-  // TODO(fsamuel): What do we need to do here? This is for keyboard shortcuts.
-  if (input_event->type == WebKit::WebInputEvent::RawKeyDown)
-    message->WriteBool(false);
+
+  IPC::Message* message = NULL;
+
+  // TODO(fsamuel): What should we do for keyboard_shortcut field?
+  if (event.type == WebKit::WebInputEvent::KeyDown) {
+    CHECK_EQ(sizeof(WebKit::WebKeyboardEvent), event.size);
+    WebKit::WebKeyboardEvent key_event;
+    memcpy(&key_event, &event, event.size);
+    key_event.type = WebKit::WebInputEvent::RawKeyDown;
+    message = new ViewMsg_HandleInputEvent(routing_id(), &key_event, false);
+  } else {
+    message = new ViewMsg_HandleInputEvent(routing_id(), &event, false);
+  }
+
   guest_rvh->Send(message);
   guest_rvh->StartHangMonitorTimeout(guest_hang_timeout_);
 }
diff --git a/content/browser/renderer_host/render_widget_host_impl.cc b/content/browser/renderer_host/render_widget_host_impl.cc
index c6cfcfa..86cdf09 100644
--- a/content/browser/renderer_host/render_widget_host_impl.cc
+++ b/content/browser/renderer_host/render_widget_host_impl.cc
@@ -1092,14 +1092,9 @@ void RenderWidgetHostImpl::ForwardKeyboardEvent(
 void RenderWidgetHostImpl::SendInputEvent(const WebInputEvent& input_event,
                                           int event_size,
                                           bool is_keyboard_shortcut) {
-  IPC::Message* message = new ViewMsg_HandleInputEvent(routing_id_);
-  message->WriteData(
-      reinterpret_cast<const char*>(&input_event), event_size);
-  // |is_keyboard_shortcut| only makes sense for RawKeyDown events.
-  if (input_event.type == WebInputEvent::RawKeyDown)
-    message->WriteBool(is_keyboard_shortcut);
   input_event_start_time_ = TimeTicks::Now();
-  Send(message);
+  Send(new ViewMsg_HandleInputEvent(
+      routing_id_, &input_event, is_keyboard_shortcut));
   increment_in_flight_event_count();
 }
 
diff --git a/content/browser/renderer_host/render_widget_host_unittest.cc b/content/browser/renderer_host/render_widget_host_unittest.cc
index 1ceefb10..dc74728 100644
--- a/content/browser/renderer_host/render_widget_host_unittest.cc
+++ b/content/browser/renderer_host/render_widget_host_unittest.cc
@@ -526,7 +526,7 @@ class RenderWidgetHostTest : public testing::Test {
   }
 
   void SimulateMouseEvent(WebInputEvent::Type type) {
-    WebMouseWheelEvent mouse_event;
+    WebKit::WebMouseEvent mouse_event;
     mouse_event.type = type;
     host_->ForwardMouseEvent(mouse_event);
   }
diff --git a/content/common/browser_plugin_messages.h b/content/common/browser_plugin_messages.h
index 8c43f70..c98c52b 100644
--- a/content/common/browser_plugin_messages.h
+++ b/content/common/browser_plugin_messages.h
@@ -173,11 +173,11 @@ IPC_MESSAGE_ROUTED1(BrowserPluginHostMsg_Stop,
 IPC_MESSAGE_ROUTED1(BrowserPluginHostMsg_Reload,
                     int /* instance_id */)
 
-// Message payload includes:
-// 1. A blob that should be cast to WebInputEvent
-// 2. An optional boolean value indicating if a RawKeyDown event is associated
-//    to a keyboard shortcut of the browser.
-IPC_MESSAGE_ROUTED0(BrowserPluginHostMsg_HandleInputEvent)
+// Sends an input event to the guest.
+IPC_MESSAGE_ROUTED3(BrowserPluginHostMsg_HandleInputEvent,
+                    int /* instance_id */,
+                    gfx::Rect /* guest_window_rect */,
+                    IPC::WebInputEventPointer /* event */)
 
 // An ACK to the guest process letting it know that the embedder has handled
 // the previous frame and is ready for the next frame. If the guest sent the
diff --git a/content/common/content_param_traits.cc b/content/common/content_param_traits.cc
index df91adb..bc78659 100644
--- a/content/common/content_param_traits.cc
+++ b/content/common/content_param_traits.cc
@@ -11,6 +11,25 @@
 #include "webkit/plugins/npapi/plugin_host.h"
 #include "ui/base/range/range.h"
 
+namespace {
+
+int WebInputEventSizeForType(WebKit::WebInputEvent::Type type) {
+    if (WebKit::WebInputEvent::isMouseEventType(type))
+        return sizeof(WebKit::WebMouseEvent);
+    if (type == WebKit::WebInputEvent::MouseWheel)
+        return sizeof(WebKit::WebMouseWheelEvent);
+    if (WebKit::WebInputEvent::isKeyboardEventType(type))
+        return sizeof(WebKit::WebKeyboardEvent);
+    if (WebKit::WebInputEvent::isTouchEventType(type))
+        return sizeof(WebKit::WebTouchEvent);
+    if (WebKit::WebInputEvent::isGestureEventType(type))
+        return sizeof(WebKit::WebGestureEvent);
+    NOTREACHED() << "Unknown webkit event type " << type;
+    return 0;
+}
+
+}  // namespace
+
 namespace content {
 
 NPIdentifier_Param::NPIdentifier_Param()
@@ -169,6 +188,48 @@ void ParamTraits<ui::Range>::Log(const ui::Range& r, std::string* l) {
   l->append(base::StringPrintf("(%"PRIuS", %"PRIuS")", r.start(), r.end()));
 }
 
+void ParamTraits<WebInputEventPointer>::Write(Message* m, const param_type& p) {
+  m->WriteData(reinterpret_cast<const char*>(p), p->size);
+}
+
+bool ParamTraits<WebInputEventPointer>::Read(const Message* m,
+                                             PickleIterator* iter,
+                                             param_type* r) {
+  const char* data;
+  int data_length;
+  if (!m->ReadData(iter, &data, &data_length)) {
+    NOTREACHED();
+    return false;
+  }
+  if (data_length < static_cast<int>(sizeof(WebKit::WebInputEvent))) {
+    NOTREACHED();
+    return false;
+  }
+  param_type event = reinterpret_cast<param_type>(data);
+  // Check that the data size matches that of the event.
+  if (data_length != static_cast<int>(event->size)) {
+    NOTREACHED();
+    return false;
+  }
+  if (data_length != WebInputEventSizeForType(event->type)) {
+    NOTREACHED();
+    return false;
+  }
+  *r = event;
+  return true;
+}
+
+void ParamTraits<WebInputEventPointer>::Log(const param_type& p,
+                                            std::string* l) {
+  l->append("(");
+  LogParam(p->size, l);
+  l->append(", ");
+  LogParam(p->type, l);
+  l->append(", ");
+  LogParam(p->timeStampSeconds, l);
+  l->append(")");
+}
+
 }  // namespace IPC
 
 // Generate param traits write methods.
diff --git a/content/common/content_param_traits.h b/content/common/content_param_traits.h
index a6fe0bad..098f2fd 100644
--- a/content/common/content_param_traits.h
+++ b/content/common/content_param_traits.h
@@ -120,40 +120,10 @@ typedef const WebKit::WebInputEvent* WebInputEventPointer;
 template <>
 struct ParamTraits<WebInputEventPointer> {
   typedef WebInputEventPointer param_type;
-  static void Write(Message* m, const param_type& p) {
-    m->WriteData(reinterpret_cast<const char*>(p), p->size);
-  }
+  static void Write(Message* m, const param_type& p);
   // Note: upon read, the event has the lifetime of the message.
-  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
-    const char* data;
-    int data_length;
-    if (!m->ReadData(iter, &data, &data_length)) {
-      NOTREACHED();
-      return false;
-    }
-    if (data_length < static_cast<int>(sizeof(WebKit::WebInputEvent))) {
-      NOTREACHED();
-      return false;
-    }
-    param_type event = reinterpret_cast<param_type>(data);
-    // Check that the data size matches that of the event (we check the latter
-    // in the delegate).
-    if (data_length != static_cast<int>(event->size)) {
-      NOTREACHED();
-      return false;
-    }
-    *r = event;
-    return true;
-  }
-  static void Log(const param_type& p, std::string* l) {
-    l->append("(");
-    LogParam(p->size, l);
-    l->append(", ");
-    LogParam(p->type, l);
-    l->append(", ");
-    LogParam(p->timeStampSeconds, l);
-    l->append(")");
-  }
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r);
+  static void Log(const param_type& p, std::string* l);
 };
 
 }  // namespace IPC
diff --git a/content/common/view_messages.h b/content/common/view_messages.h
index e65e5ce..d1e322e 100644
--- a/content/common/view_messages.h
+++ b/content/common/view_messages.h
@@ -924,11 +924,10 @@ IPC_MESSAGE_ROUTED0(ViewMsg_UpdateRect_ACK)
 // compositor path.
 IPC_MESSAGE_ROUTED0(ViewMsg_SwapBuffers_ACK)
 
-// Message payload includes:
-// 1. A blob that should be cast to WebInputEvent
-// 2. An optional boolean value indicating if a RawKeyDown event is associated
-//    to a keyboard shortcut of the browser.
-IPC_MESSAGE_ROUTED0(ViewMsg_HandleInputEvent)
+// Sends an input event to the render widget.
+IPC_MESSAGE_ROUTED2(ViewMsg_HandleInputEvent,
+                    IPC::WebInputEventPointer /* event */,
+                    bool /* is_keyboard_shortcut */)
 
 // Tells the render widget that a smooth scroll completed.
 IPC_MESSAGE_ROUTED1(ViewMsg_SmoothScrollCompleted,
diff --git a/content/public/test/render_view_test.cc b/content/public/test/render_view_test.cc
index 62d4833..2ccd54f 100644
--- a/content/public/test/render_view_test.cc
+++ b/content/public/test/render_view_test.cc
@@ -209,20 +209,14 @@ void RenderViewTest::SendNativeKeyEvent(
 
 void RenderViewTest::SendWebKeyboardEvent(
     const WebKit::WebKeyboardEvent& key_event) {
-  scoped_ptr<IPC::Message> input_message(new ViewMsg_HandleInputEvent(0));
-  input_message->WriteData(reinterpret_cast<const char*>(&key_event),
-                           sizeof(WebKit::WebKeyboardEvent));
   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
-  impl->OnMessageReceived(*input_message);
+  impl->OnMessageReceived(ViewMsg_HandleInputEvent(0, &key_event, false));
 }
 
 void RenderViewTest::SendWebMouseEvent(
     const WebKit::WebMouseEvent& mouse_event) {
-  scoped_ptr<IPC::Message> input_message(new ViewMsg_HandleInputEvent(0));
-  input_message->WriteData(reinterpret_cast<const char*>(&mouse_event),
-                           sizeof(WebKit::WebMouseEvent));
   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
-  impl->OnMessageReceived(*input_message);
+  impl->OnMessageReceived(ViewMsg_HandleInputEvent(0, &mouse_event, false));
 }
 
 const char* const kGetCoordinatesScript =
@@ -280,10 +274,8 @@ bool RenderViewTest::SimulateElementClick(const std::string& element_id) {
   mouse_event.x = bounds.CenterPoint().x();
   mouse_event.y = bounds.CenterPoint().y();
   mouse_event.clickCount = 1;
-  ViewMsg_HandleInputEvent input_event(0);
-  scoped_ptr<IPC::Message> input_message(new ViewMsg_HandleInputEvent(0));
-  input_message->WriteData(reinterpret_cast<const char*>(&mouse_event),
-                           sizeof(WebMouseEvent));
+  scoped_ptr<IPC::Message> input_message(
+      new ViewMsg_HandleInputEvent(0, &mouse_event, false));
   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
   impl->OnMessageReceived(*input_message);
   return true;
diff --git a/content/renderer/browser_plugin/browser_plugin.cc b/content/renderer/browser_plugin/browser_plugin.cc
index 77c3746..917c064 100644
--- a/content/renderer/browser_plugin/browser_plugin.cc
+++ b/content/renderer/browser_plugin/browser_plugin.cc
@@ -969,14 +969,11 @@ bool BrowserPlugin::handleInputEvent(const WebKit::WebInputEvent& event,
   if (guest_crashed_ || !navigate_src_sent_ ||
       event.type == WebKit::WebInputEvent::ContextMenu)
     return false;
-  IPC::Message* message =
-      new BrowserPluginHostMsg_HandleInputEvent(
-          render_view_routing_id_);
-  message->WriteInt(instance_id_);
-  message->WriteData(reinterpret_cast<const char*>(&plugin_rect_),
-                     sizeof(gfx::Rect));
-  message->WriteData(reinterpret_cast<const char*>(&event), event.size);
-  browser_plugin_manager()->Send(message);
+  browser_plugin_manager()->Send(
+      new BrowserPluginHostMsg_HandleInputEvent(render_view_routing_id_,
+                                                instance_id_,
+                                                plugin_rect_,
+                                                &event));
   cursor_.GetCursorInfo(&cursor_info);
   return true;
 }
diff --git a/content/renderer/gpu/input_event_filter.cc b/content/renderer/gpu/input_event_filter.cc
index 89cccdd..43776fd 100644
--- a/content/renderer/gpu/input_event_filter.cc
+++ b/content/renderer/gpu/input_event_filter.cc
@@ -100,10 +100,6 @@ bool InputEventFilter::OnMessageReceived(const IPC::Message& message) {
       return false;
   }
 
-  const WebInputEvent* event = CrackMessage(message);
-  if (event->type == WebInputEvent::Undefined)
-    return false;
-
   target_loop_->PostTask(
       FROM_HERE,
       base::Bind(&InputEventFilter::ForwardToHandler, this, message));
@@ -116,12 +112,9 @@ const WebInputEvent* InputEventFilter::CrackMessage(
   DCHECK(message.type() == ViewMsg_HandleInputEvent::ID);
 
   PickleIterator iter(message);
-  const char* data;
-  int data_length;
-  if (!message.ReadData(&iter, &data, &data_length))
-    return NULL;
-
-  return reinterpret_cast<const WebInputEvent*>(data);
+  const WebInputEvent* event = NULL;
+  IPC::ParamTraits<IPC::WebInputEventPointer>::Read(&message, &iter, &event);
+  return event;
 }
 
 InputEventFilter::~InputEventFilter() {
diff --git a/content/renderer/gpu/input_event_filter_unittest.cc b/content/renderer/gpu/input_event_filter_unittest.cc
index 781560c..9651d46 100644
--- a/content/renderer/gpu/input_event_filter_unittest.cc
+++ b/content/renderer/gpu/input_event_filter_unittest.cc
@@ -107,9 +107,7 @@ void AddEventsToFilter(IPC::ChannelProxy::MessageFilter* message_filter,
                        const WebMouseEvent events[],
                        size_t count) {
   for (size_t i = 0; i < count; ++i) {
-    ViewMsg_HandleInputEvent message(kTestRoutingID);
-    message.WriteData(reinterpret_cast<const char*>(&events[i]),
-                      events[i].size);
+    ViewMsg_HandleInputEvent message(kTestRoutingID, &events[i], false);
     message_filter->OnMessageReceived(message);
   }
 
diff --git a/content/renderer/idle_user_detector.cc b/content/renderer/idle_user_detector.cc
index 2b635b5..1831fa9 100644
--- a/content/renderer/idle_user_detector.cc
+++ b/content/renderer/idle_user_detector.cc
@@ -25,7 +25,8 @@ bool IdleUserDetector::OnMessageReceived(const IPC::Message& message) {
   return false;
 }
 
-void IdleUserDetector::OnHandleInputEvent(const IPC::Message& message) {
+void IdleUserDetector::OnHandleInputEvent(const WebKit::WebInputEvent* event,
+                                          bool is_keyboard_shortcut) {
   if (GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) {
     RenderThreadImpl* render_thread = RenderThreadImpl::current();
     if (render_thread != NULL) {
diff --git a/content/renderer/idle_user_detector.h b/content/renderer/idle_user_detector.h
index 7eead12..ab45ed0c 100644
--- a/content/renderer/idle_user_detector.h
+++ b/content/renderer/idle_user_detector.h
@@ -8,6 +8,10 @@
 #include "base/basictypes.h"
 #include "content/public/renderer/render_view_observer.h"
 
+namespace WebKit {
+class WebInputEvent;
+}
+
 namespace content {
 
 // Class which observes user input events and postpones
@@ -21,7 +25,8 @@ class IdleUserDetector : public RenderViewObserver {
   // RenderViewObserver implementation:
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
-  void OnHandleInputEvent(const IPC::Message& message);
+  void OnHandleInputEvent(const WebKit::WebInputEvent* event,
+                          bool is_keyboard_shortcut);
 
   DISALLOW_COPY_AND_ASSIGN(IdleUserDetector);
 };
diff --git a/content/renderer/render_widget.cc b/content/renderer/render_widget.cc
index fdf034b..a9551a2 100644
--- a/content/renderer/render_widget.cc
+++ b/content/renderer/render_widget.cc
@@ -546,26 +546,16 @@ void RenderWidget::OnSwapBuffersComplete() {
   DoDeferredUpdateAndSendInputAck();
 }
 
-void RenderWidget::OnHandleInputEvent(const IPC::Message& message) {
+void RenderWidget::OnHandleInputEvent(const WebKit::WebInputEvent* input_event,
+                                      bool is_keyboard_shortcut) {
   TRACE_EVENT0("renderer", "RenderWidget::OnHandleInputEvent");
-  PickleIterator iter(message);
 
-  const char* data;
-  int data_length;
   handling_input_event_ = true;
-  if (!message.ReadData(&iter, &data, &data_length)) {
+  if (!input_event) {
     handling_input_event_ = false;
     return;
   }
 
-  const WebInputEvent* input_event =
-      reinterpret_cast<const WebInputEvent*>(data);
-
-  bool is_keyboard_shortcut = false;
-  // is_keyboard_shortcut flag is only available for RawKeyDown events.
-  if (input_event->type == WebInputEvent::RawKeyDown)
-    message.ReadBool(&iter, &is_keyboard_shortcut);
-
   bool prevent_default = false;
   if (WebInputEvent::isMouseEventType(input_event->type)) {
     const WebMouseEvent& mouse_event =
diff --git a/content/renderer/render_widget.h b/content/renderer/render_widget.h
index e274806..631455f 100644
--- a/content/renderer/render_widget.h
+++ b/content/renderer/render_widget.h
@@ -43,6 +43,7 @@ class SyncMessage;
 
 namespace WebKit {
 class WebGestureEvent;
+class WebInputEvent;
 class WebMouseEvent;
 struct WebRenderingStatsImpl;
 struct WebPoint;
@@ -264,7 +265,8 @@ class CONTENT_EXPORT RenderWidget
   void OnCreateVideoAck(int32 video_id);
   void OnUpdateVideoAck(int32 video_id);
   void OnRequestMoveAck();
-  void OnHandleInputEvent(const IPC::Message& message);
+  void OnHandleInputEvent(const WebKit::WebInputEvent* event,
+                          bool keyboard_shortcut);
   void OnMouseCaptureLost();
   virtual void OnSetFocus(bool enable);
   void OnSetInputMethodActive(bool is_active);