Add support for passing an arbitrary parameter to an IPC message handler. The motivation is for Web…

content/renderer/input/input_event_filter_unittest.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 <new>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 160 matching lines @@
   AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
   ASSERT_EQ(arraysize(kEvents), ipc_sink_.message_count());
   ASSERT_EQ(arraysize(kEvents), event_recorder_.record_count());
   EXPECT_EQ(0U, message_recorder_.message_count());
 
   for (size_t i = 0; i < arraysize(kEvents); ++i) {
     const IPC::Message* message = ipc_sink_.GetMessageAt(i);
     EXPECT_EQ(kTestRoutingID, message->routing_id());
     EXPECT_EQ(InputHostMsg_HandleInputEvent_ACK::ID, message->type());
 
-    WebInputEvent::Type event_type = WebInputEvent::Undefined;
-    InputEventAckState ack_result = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
-    ui::LatencyInfo latency_info;
-    EXPECT_TRUE(InputHostMsg_HandleInputEvent_ACK::Read(message,
-                                                        &event_type,
-                                                        &ack_result,
-                                                        &latency_info));
+    InputHostMsg_HandleInputEvent_ACK::Param params;
+    EXPECT_TRUE(InputHostMsg_HandleInputEvent_ACK::Read(message, &params));
+    WebInputEvent::Type event_type = params.a;
+    InputEventAckState ack_result = params.b;
+
     EXPECT_EQ(kEvents[i].type, event_type);
     EXPECT_EQ(ack_result, INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
 
     const WebInputEvent* event = event_recorder_.record_at(i);
     ASSERT_TRUE(event);
 
     EXPECT_EQ(kEvents[i].size, event->size);
     EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0);
   }
 
   event_recorder_.set_send_to_widget(true);
 
   AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
   EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count());
   EXPECT_EQ(2 * arraysize(kEvents), event_recorder_.record_count());
   EXPECT_EQ(arraysize(kEvents), message_recorder_.message_count());
 
   for (size_t i = 0; i < arraysize(kEvents); ++i) {
     const IPC::Message& message = message_recorder_.message_at(i);
 
     ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type());
-    const WebInputEvent* event = NULL;
-    ui::LatencyInfo latency_info;
-    bool is_kbd_shortcut;
-    EXPECT_TRUE(InputMsg_HandleInputEvent::Read(
-        &message, &event, &latency_info, &is_kbd_shortcut));
+    InputMsg_HandleInputEvent::Param params;
+    EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, &params));
+    const WebInputEvent* event = params.a;
 
     EXPECT_EQ(kEvents[i].size, event->size);
     EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0);
   }
 
   // Now reset everything, and test that DidHandleInputEvent is called.
 
   ipc_sink_.ClearMessages();
   event_recorder_.Clear();
   message_recorder_.Clear();
 
   event_recorder_.set_handle_events(true);
 
   AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
   EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count());
   EXPECT_EQ(arraysize(kEvents), event_recorder_.record_count());
   EXPECT_EQ(0U, message_recorder_.message_count());
 
   for (size_t i = 0; i < arraysize(kEvents); ++i) {
     const IPC::Message* message = ipc_sink_.GetMessageAt(i);
     EXPECT_EQ(kTestRoutingID, message->routing_id());
     EXPECT_EQ(InputHostMsg_HandleInputEvent_ACK::ID, message->type());
 
-    WebInputEvent::Type event_type = WebInputEvent::Undefined;
-    InputEventAckState ack_result = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
-    ui::LatencyInfo latency_info;
-    EXPECT_TRUE(InputHostMsg_HandleInputEvent_ACK::Read(message,
-                                                        &event_type,
-                                                        &ack_result,
-                                                        &latency_info));
+    InputHostMsg_HandleInputEvent_ACK::Param params;
+    EXPECT_TRUE(InputHostMsg_HandleInputEvent_ACK::Read(message, &params));
+    WebInputEvent::Type event_type = params.a;
+    InputEventAckState ack_result = params.b;
     EXPECT_EQ(kEvents[i].type, event_type);
     EXPECT_EQ(ack_result, INPUT_EVENT_ACK_STATE_CONSUMED);
   }
 
   filter_->OnFilterRemoved();
 }
 
 TEST_F(InputEventFilterTest, PreserveRelativeOrder) {
   filter_->DidAddInputHandler(kTestRoutingID, NULL);
   event_recorder_.set_send_to_widget(true);
@@ skipping 42 matching lines @@
 
   // We should have sent all messages back to the main thread and preserved
   // their relative order.
   ASSERT_EQ(message_recorder_.message_count(), messages.size());
   for (size_t i = 0; i < messages.size(); ++i) {
     EXPECT_EQ(message_recorder_.message_at(i).type(), messages[i].type()) << i;
   }
 }
 
 }  // namespace content