Add a new pair of IPC categories for messages that need handling as input events

content/browser/renderer_host/render_widget_host_unittest.cc

 // Copyright (c) 2012 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 "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "base/timer.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/backing_store.h"
-#include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/gesture_event_filter.h"
 #include "content/browser/renderer_host/overscroll_controller.h"
 #include "content/browser/renderer_host/overscroll_controller_delegate.h"
+#include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/tap_suppression_controller.h"
 #include "content/browser/renderer_host/tap_suppression_controller_client.h"
 #include "content/browser/renderer_host/test_render_view_host.h"
 #include "content/browser/renderer_host/touch_event_queue.h"
+#include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/port/browser/render_widget_host_view_port.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 627 matching lines @@
     screen_.reset();
 #endif
 
     // Process all pending tasks to avoid leaks.
     MessageLoop::current()->RunUntilIdle();
   }
 
   void SendInputEventACK(WebInputEvent::Type type,
                          InputEventAckState ack_result) {
     scoped_ptr<IPC::Message> response(
-        new ViewHostMsg_HandleInputEvent_ACK(0, type, ack_result));
+        new InputHostMsg_HandleInputEvent_ACK(0, type, ack_result));
     host_->OnMessageReceived(*response);
   }
 
   void SimulateKeyboardEvent(WebInputEvent::Type type) {
     NativeWebKeyboardEvent key_event;
     key_event.type = type;
     key_event.windowsKeyCode = ui::VKEY_L;  // non-null made up value.
     host_->ForwardKeyboardEvent(key_event);
   }
 
@@ skipping 476 matching lines @@
 #define MAYBE_HandleKeyEventsWeSent DISABLED_HandleKeyEventsWeSent
 #else
 #define MAYBE_HandleKeyEventsWeSent HandleKeyEventsWeSent
 #endif
 TEST_F(RenderWidgetHostTest, MAYBE_HandleKeyEventsWeSent) {
   // Simulate a keyboard event.
   SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
 
   // Make sure we sent the input event to the renderer.
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
-                  ViewMsg_HandleInputEvent::ID));
+                  InputMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // Send the simulated response from the renderer back.
   SendInputEventACK(WebInputEvent::RawKeyDown,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   EXPECT_TRUE(delegate_->unhandled_keyboard_event_called());
   EXPECT_EQ(WebInputEvent::RawKeyDown,
             delegate_->unhandled_keyboard_event_type());
 }
 
 TEST_F(RenderWidgetHostTest, IgnoreKeyEventsWeDidntSend) {
   // Send a simulated, unrequested key response. We should ignore this.
   SendInputEventACK(WebInputEvent::RawKeyDown,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   EXPECT_FALSE(delegate_->unhandled_keyboard_event_called());
 }
 
 TEST_F(RenderWidgetHostTest, IgnoreKeyEventsHandledByRenderer) {
   // Simulate a keyboard event.
   SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
 
   // Make sure we sent the input event to the renderer.
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
-                  ViewMsg_HandleInputEvent::ID));
+                  InputMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // Send the simulated response from the renderer back.
   SendInputEventACK(WebInputEvent::RawKeyDown,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_FALSE(delegate_->unhandled_keyboard_event_called());
 }
 
 TEST_F(RenderWidgetHostTest, PreHandleRawKeyDownEvent) {
   // Simluate the situation that the browser handled the key down event during
@@ skipping 18 matching lines @@
   SimulateKeyboardEvent(WebInputEvent::Char);
 
   // Make sure the Char event is suppressed.
   EXPECT_EQ(0U, process_->sink().message_count());
 
   // Forward the KeyUp event.
   SimulateKeyboardEvent(WebInputEvent::KeyUp);
 
   // Make sure only KeyUp was sent to the renderer.
   EXPECT_EQ(1U, process_->sink().message_count());
-  EXPECT_EQ(ViewMsg_HandleInputEvent::ID,
+  EXPECT_EQ(InputMsg_HandleInputEvent::ID,
             process_->sink().GetMessageAt(0)->type());
   process_->sink().ClearMessages();
 
   // Send the simulated response from the renderer back.
   SendInputEventACK(WebInputEvent::KeyUp,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   EXPECT_TRUE(delegate_->unhandled_keyboard_event_called());
   EXPECT_EQ(WebInputEvent::KeyUp, delegate_->unhandled_keyboard_event_type());
 }
 
 TEST_F(RenderWidgetHostTest, CoalescesWheelEvents) {
   process_->sink().ClearMessages();
 
   // Simulate wheel events.
   SimulateWheelEvent(0, -5, 0, false);  // sent directly
   SimulateWheelEvent(0, -10, 0, false);  // enqueued
   SimulateWheelEvent(8, -6, 0, false);  // coalesced into previous event
   SimulateWheelEvent(9, -7, 1, false);  // enqueued, different modifiers
 
   // Check that only the first event was sent.
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
-                  ViewMsg_HandleInputEvent::ID));
+                  InputMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // Check that the ACK sends the second message.
   SendInputEventACK(WebInputEvent::MouseWheel,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   // The coalesced events can queue up a delayed ack
   // so that additional input events can be processed before
   // we turn off coalescing.
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
-                  ViewMsg_HandleInputEvent::ID));
+                  InputMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // One more time.
   SendInputEventACK(WebInputEvent::MouseWheel,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
-                  ViewMsg_HandleInputEvent::ID));
+                  InputMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // After the final ack, the queue should be empty.
   SendInputEventACK(WebInputEvent::MouseWheel,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(0U, process_->sink().message_count());
 
   SimulateGestureFlingStartEvent(0.f, 0.f, WebGestureEvent::Touchpad);
   EXPECT_EQ(0U, process_->sink().message_count());
@@ skipping 74 matching lines @@
   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
   EXPECT_EQ(1, merged_event.modifiers);
 
   // Different.
   SimulateGestureEvent(WebInputEvent::GestureScrollEnd,
                        WebGestureEvent::Touchscreen);
 
   // Check that only the first event was sent.
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
-              ViewMsg_HandleInputEvent::ID));
+              InputMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // Check that the ACK sends the second message.
   SendInputEventACK(WebInputEvent::GestureScrollBegin,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
-              ViewMsg_HandleInputEvent::ID));
+              InputMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // Ack for queued coalesced event.
   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
-              ViewMsg_HandleInputEvent::ID));
+              InputMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // Ack for queued uncoalesced event.
   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
-              ViewMsg_HandleInputEvent::ID));
+              InputMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // After the final ack, the queue should be empty.
   SendInputEventACK(WebInputEvent::GestureScrollEnd,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(0U, process_->sink().message_count());
 }
 
 TEST_F(RenderWidgetHostTest, CoalescesScrollAndPinchEvents) {
@@ skipping 74 matching lines @@
   EXPECT_EQ(1, merged_event.modifiers);
   merged_event = host_->GestureEventSecondFromLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
   EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
   EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
   EXPECT_EQ(1, merged_event.modifiers);
 
   // Check that only the first event was sent.
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
-              ViewMsg_HandleInputEvent::ID));
+              InputMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // Check that the ACK sends the second message.
   SendInputEventACK(WebInputEvent::GestureScrollBegin,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
-              ViewMsg_HandleInputEvent::ID));
+              InputMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // Enqueued.
   SimulateGestureScrollUpdateEvent(6, -6, 1);
 
   // Check whether coalesced correctly.
   EXPECT_EQ(3U, host_->GestureEventLastQueueEventSize());
   merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
   EXPECT_EQ(6, merged_event.data.pinchUpdate.scale);
   EXPECT_EQ(1, merged_event.modifiers);
   merged_event = host_->GestureEventSecondFromLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
   EXPECT_EQ(13, merged_event.data.scrollUpdate.deltaX);
   EXPECT_EQ(-7, merged_event.data.scrollUpdate.deltaY);
   EXPECT_EQ(1, merged_event.modifiers);
 
   // At this point ACKs shouldn't be getting ignored.
   EXPECT_FALSE(host_->WillIgnoreNextACK());
 
   // Check that the ACK sends both scroll and pinch updates.
   SendInputEventACK(WebInputEvent::GesturePinchBegin,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_TRUE(process_->sink().GetFirstMessageMatching(
-              ViewMsg_HandleInputEvent::ID));
+              InputMsg_HandleInputEvent::ID));
   EXPECT_FALSE(process_->sink().GetUniqueMessageMatching(
-              ViewMsg_HandleInputEvent::ID));
+              InputMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // The next ACK should be getting ignored.
   EXPECT_TRUE(host_->WillIgnoreNextACK());
 
   // Enqueued.
   SimulateGestureScrollUpdateEvent(1, -1, 1);
 
   // Check whether coalesced correctly.
   EXPECT_EQ(3U, host_->GestureEventLastQueueEventSize());
@@ skipping 59 matching lines @@
   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type);
   EXPECT_EQ(0.5, merged_event.data.pinchUpdate.scale);
   EXPECT_EQ(1, merged_event.modifiers);
 
   // Check that the ACK sends the next scroll pinch pair.
   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_TRUE(process_->sink().GetFirstMessageMatching(
-              ViewMsg_HandleInputEvent::ID));
+              InputMsg_HandleInputEvent::ID));
   EXPECT_FALSE(process_->sink().GetUniqueMessageMatching(
-              ViewMsg_HandleInputEvent::ID));
+              InputMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // Check that the ACK sends the second message.
   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(0U, process_->sink().message_count());
 
   // Check that the ACK sends the second message.
   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
-              ViewMsg_HandleInputEvent::ID));
+              InputMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // Check that the queue is empty after ACK and no messages get sent.
   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(0U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
 }
 
@@ skipping 2134 matching lines @@
   EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
 
   // Since the overscroll mode has been reset, the next scroll update events
   // should reach the renderer.
   SimulateGestureScrollUpdateEvent(-20, 0, 0);
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
 }
 
 }  // namespace content