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

content/browser/renderer_host/render_widget_host_impl.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 "content/browser/renderer_host/render_widget_host_impl.h"
 
 #include <math.h>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 19 matching lines @@
 #include "content/browser/renderer_host/overscroll_controller.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_helper.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/touch_event_queue.h"
 #include "content/browser/renderer_host/touchpad_tap_suppression_controller.h"
 #include "content/common/accessibility_messages.h"
 #include "content/common/content_constants_internal.h"
 #include "content/common/gpu/gpu_messages.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/port/browser/smooth_scroll_gesture.h"
 #include "content/public/browser/compositor_util.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
@@ skipping 313 matching lines @@
                         OnUpdateScreenRectsAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RequestMove, OnRequestMove)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SetTooltipText, OnSetTooltipText)
     IPC_MESSAGE_HANDLER(ViewHostMsg_PaintAtSize_ACK, OnPaintAtSizeAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_CompositorSurfaceBuffersSwapped,
                         OnCompositorSurfaceBuffersSwapped)
     IPC_MESSAGE_HANDLER_GENERIC(ViewHostMsg_SwapCompositorFrame,
                                 msg_is_ok = OnSwapCompositorFrame(msg))
     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateRect, OnUpdateRect)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateIsDelayed, OnUpdateIsDelayed)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_HandleInputEvent_ACK, OnInputEventAck)
+    IPC_MESSAGE_HANDLER(InputHostMsg_HandleInputEvent_ACK, OnInputEventAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_BeginSmoothScroll, OnBeginSmoothScroll)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SelectRange_ACK, OnSelectRangeAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_MoveCaret_ACK, OnMsgMoveCaretAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Focus, OnFocus)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Blur, OnBlur)
     IPC_MESSAGE_HANDLER(ViewHostMsg_HasTouchEventHandlers,
                         OnHasTouchEventHandlers)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SetCursor, OnSetCursor)
     IPC_MESSAGE_HANDLER(ViewHostMsg_TextInputStateChanged,
                         OnTextInputStateChanged)
@@ skipping 146 matching lines @@
 
 void RenderWidgetHostImpl::ResizeRectChanged(const gfx::Rect& new_rect) {
   Send(new ViewMsg_ChangeResizeRect(routing_id_, new_rect));
 }
 
 void RenderWidgetHostImpl::GotFocus() {
   Focus();
 }
 
 void RenderWidgetHostImpl::Focus() {
-  Send(new ViewMsg_SetFocus(routing_id_, true));
+  Send(new InputMsg_SetFocus(routing_id_, true));
 }
 
 void RenderWidgetHostImpl::Blur() {
   // If there is a pending mouse lock request, we don't want to reject it at
   // this point. The user can switch focus back to this view and approve the
   // request later.
   if (IsMouseLocked())
     view_->UnlockMouse();
 
-  Send(new ViewMsg_SetFocus(routing_id_, false));
+  Send(new InputMsg_SetFocus(routing_id_, false));
 }
 
 void RenderWidgetHostImpl::LostCapture() {
-  Send(new ViewMsg_MouseCaptureLost(routing_id_));
+  Send(new InputMsg_MouseCaptureLost(routing_id_));
 }
 
 void RenderWidgetHostImpl::SetActive(bool active) {
   Send(new ViewMsg_SetActive(routing_id_, active));
 }
 
 void RenderWidgetHostImpl::LostMouseLock() {
   Send(new ViewMsg_MouseLockLost(routing_id_));
 }
 
@@ skipping 578 matching lines @@
     // Only forward the non-native portions of our event.
     ForwardInputEvent(key_event, sizeof(WebKeyboardEvent),
                       is_keyboard_shortcut);
   }
 }
 
 void RenderWidgetHostImpl::SendInputEvent(const WebInputEvent& input_event,
                                           int event_size,
                                           bool is_keyboard_shortcut) {
   input_event_start_time_ = TimeTicks::Now();
-  Send(new ViewMsg_HandleInputEvent(
+  Send(new InputMsg_HandleInputEvent(
       routing_id_, &input_event, is_keyboard_shortcut));
   increment_in_flight_event_count();
 }
 
 void RenderWidgetHostImpl::ForwardInputEvent(const WebInputEvent& input_event,
                                              int event_size,
                                              bool is_keyboard_shortcut) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardInputEvent");
 
   if (!process_->HasConnection())
@@ skipping 1020 matching lines @@
   // TODO(darin): do we need to do something else if our backing store is not
   // the same size as the advertised view?  maybe we just assume there is a
   // full paint on its way?
   BackingStore* backing_store = BackingStoreManager::Lookup(this);
   if (!backing_store || (backing_store->size() != view_size))
     return;
   backing_store->ScrollBackingStore(delta, clip_rect, view_size);
 }
 
 void RenderWidgetHostImpl::Replace(const string16& word) {
-  Send(new ViewMsg_Replace(routing_id_, word));
+  Send(new InputMsg_Replace(routing_id_, word));
 }
 
 void RenderWidgetHostImpl::ReplaceMisspelling(const string16& word) {
-  Send(new ViewMsg_ReplaceMisspelling(routing_id_, word));
+  Send(new InputMsg_ReplaceMisspelling(routing_id_, word));
 }
 
 void RenderWidgetHostImpl::SetIgnoreInputEvents(bool ignore_input_events) {
   ignore_input_events_ = ignore_input_events;
 }
 
 bool RenderWidgetHostImpl::KeyPressListenersHandleEvent(
     const NativeWebKeyboardEvent& event) {
   if (event.skip_in_browser || event.type != WebKeyboardEvent::RawKeyDown)
     return false;
@@ skipping 62 matching lines @@
 void RenderWidgetHostImpl::Stop() {
   Send(new ViewMsg_Stop(GetRoutingID()));
 }
 
 void RenderWidgetHostImpl::SetBackground(const SkBitmap& background) {
   Send(new ViewMsg_SetBackground(GetRoutingID(), background));
 }
 
 void RenderWidgetHostImpl::SetEditCommandsForNextKeyEvent(
     const std::vector<EditCommand>& commands) {
-  Send(new ViewMsg_SetEditCommandsForNextKeyEvent(GetRoutingID(), commands));
+  Send(new InputMsg_SetEditCommandsForNextKeyEvent(GetRoutingID(), commands));
 }
 
 void RenderWidgetHostImpl::SetAccessibilityMode(AccessibilityMode mode) {
   accessibility_mode_ = mode;
   Send(new ViewMsg_SetAccessibilityMode(routing_id_, mode));
 }
 
 void RenderWidgetHostImpl::AccessibilityDoDefaultAction(int object_id) {
   Send(new AccessibilityMsg_DoDefaultAction(GetRoutingID(), object_id));
 }
@@ skipping 19 matching lines @@
   Send(new AccessibilityMsg_SetTextSelection(
       GetRoutingID(), object_id, start_offset, end_offset));
 }
 
 void RenderWidgetHostImpl::FatalAccessibilityTreeError() {
   Send(new AccessibilityMsg_FatalError(GetRoutingID()));
 }
 
 void RenderWidgetHostImpl::ExecuteEditCommand(const std::string& command,
                                               const std::string& value) {
-  Send(new ViewMsg_ExecuteEditCommand(GetRoutingID(), command, value));
+  Send(new InputMsg_ExecuteEditCommand(GetRoutingID(), command, value));
 }
 
 void RenderWidgetHostImpl::ScrollFocusedEditableNodeIntoRect(
     const gfx::Rect& rect) {
-  Send(new ViewMsg_ScrollFocusedEditableNodeIntoRect(GetRoutingID(), rect));
+  Send(new InputMsg_ScrollFocusedEditableNodeIntoRect(GetRoutingID(), rect));
 }
 
 void RenderWidgetHostImpl::SelectRange(const gfx::Point& start,
                                        const gfx::Point& end) {
   if (select_range_pending_) {
     if (!next_selection_range_) {
       next_selection_range_.reset(new SelectionRange());
     }
     next_selection_range_->start = start;
     next_selection_range_->end = end;
     return;
   }
 
   select_range_pending_ = true;
-  Send(new ViewMsg_SelectRange(GetRoutingID(), start, end));
+  Send(new InputMsg_SelectRange(GetRoutingID(), start, end));
 }
 
 void RenderWidgetHostImpl::MoveCaret(const gfx::Point& point) {
   if (move_caret_pending_) {
     next_move_caret_.reset(new gfx::Point(point));
     return;
   }
 
   move_caret_pending_ = true;
-  Send(new ViewMsg_MoveCaret(GetRoutingID(), point));
+  Send(new InputMsg_MoveCaret(GetRoutingID(), point));
 }
 
 void RenderWidgetHostImpl::Undo() {
-  Send(new ViewMsg_Undo(GetRoutingID()));
+  Send(new InputMsg_Undo(GetRoutingID()));
   RecordAction(UserMetricsAction("Undo"));
 }
 
 void RenderWidgetHostImpl::Redo() {
-  Send(new ViewMsg_Redo(GetRoutingID()));
+  Send(new InputMsg_Redo(GetRoutingID()));
   RecordAction(UserMetricsAction("Redo"));
 }
 
 void RenderWidgetHostImpl::Cut() {
-  Send(new ViewMsg_Cut(GetRoutingID()));
+  Send(new InputMsg_Cut(GetRoutingID()));
   RecordAction(UserMetricsAction("Cut"));
 }
 
 void RenderWidgetHostImpl::Copy() {
-  Send(new ViewMsg_Copy(GetRoutingID()));
+  Send(new InputMsg_Copy(GetRoutingID()));
   RecordAction(UserMetricsAction("Copy"));
 }
 
 void RenderWidgetHostImpl::CopyToFindPboard() {
 #if defined(OS_MACOSX)
   // Windows/Linux don't have the concept of a find pasteboard.
-  Send(new ViewMsg_CopyToFindPboard(GetRoutingID()));
+  Send(new InputMsg_CopyToFindPboard(GetRoutingID()));
   RecordAction(UserMetricsAction("CopyToFindPboard"));
 #endif
 }
 
 void RenderWidgetHostImpl::Paste() {
-  Send(new ViewMsg_Paste(GetRoutingID()));
+  Send(new InputMsg_Paste(GetRoutingID()));
   RecordAction(UserMetricsAction("Paste"));
 }
 
 void RenderWidgetHostImpl::PasteAndMatchStyle() {
-  Send(new ViewMsg_PasteAndMatchStyle(GetRoutingID()));
+  Send(new InputMsg_PasteAndMatchStyle(GetRoutingID()));
   RecordAction(UserMetricsAction("PasteAndMatchStyle"));
 }
 
 void RenderWidgetHostImpl::Delete() {
-  Send(new ViewMsg_Delete(GetRoutingID()));
+  Send(new InputMsg_Delete(GetRoutingID()));
   RecordAction(UserMetricsAction("DeleteSelection"));
 }
 
 void RenderWidgetHostImpl::SelectAll() {
-  Send(new ViewMsg_SelectAll(GetRoutingID()));
+  Send(new InputMsg_SelectAll(GetRoutingID()));
   RecordAction(UserMetricsAction("SelectAll"));
 }
 bool RenderWidgetHostImpl::GotResponseToLockMouseRequest(bool allowed) {
   if (!allowed) {
     RejectMouseLockOrUnlockIfNecessary();
     return false;
   } else {
     if (!pending_mouse_lock_request_) {
       // This is possible, e.g., the plugin sends us an unlock request before
       // the user allows to lock to mouse.
@@ skipping 61 matching lines @@
     return;
 
   OnRenderAutoResized(new_size);
 }
 
 void RenderWidgetHostImpl::DetachDelegate() {
   delegate_ = NULL;
 }
 
 }  // namespace content