Extract minimal RenderViewHost interface for embedders, leaving

content/browser/renderer_host/render_widget_host.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.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 62 matching lines @@
   return last_event.modifiers == new_event.modifiers &&
          last_event.scrollByPage == new_event.scrollByPage &&
          last_event.hasPreciseScrollingDeltas
              == new_event.hasPreciseScrollingDeltas &&
          last_event.phase == new_event.phase &&
          last_event.momentumPhase == new_event.momentumPhase;
 }
 
 }  // namespace
 
-RenderWidgetHost::RenderWidgetHost(content::RenderProcessHost* process)
-    : process_(process),
-      view_(NULL) {
-}
-
-content::RenderWidgetHostView* RenderWidgetHost::view() const {
-  return view_;
-}
-
 // static
 RenderWidgetHost* RenderWidgetHost::FromIPCChannelListener(
     IPC::Channel::Listener* listener) {
   return static_cast<RenderWidgetHost*>(
       static_cast<RenderWidgetHostImpl*>(listener));
 }
 
 // static
 const RenderWidgetHost* RenderWidgetHost::FromIPCChannelListener(
     const IPC::Channel::Listener* listener) {
   return static_cast<const RenderWidgetHost*>(
       static_cast<const RenderWidgetHostImpl*>(listener));
 }
 
 // static
 void RenderWidgetHost::RemoveAllBackingStores() {
   BackingStoreManager::RemoveAllBackingStores();
 }
 
 // static
 size_t RenderWidgetHost::BackingStoreMemorySize() {
   return BackingStoreManager::MemorySize();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostImpl
 
 RenderWidgetHostImpl::RenderWidgetHostImpl(content::RenderProcessHost* process,
                                            int routing_id)
-    : RenderWidgetHost(process),
+    : view_(NULL),
       renderer_initialized_(false),
       hung_renderer_delay_ms_(kHungRendererDelayMs),
+      process_(process),
+      routing_id_(routing_id),
       renderer_accessible_(false),
-      routing_id_(routing_id),
       surface_id_(0),
       is_loading_(false),
       is_hidden_(false),
       is_accelerated_compositing_active_(false),
       repaint_ack_pending_(false),
       resize_ack_pending_(false),
       should_auto_resize_(false),
       mouse_move_pending_(false),
       mouse_wheel_pending_(false),
       needs_repainting_on_restore_(false),
@@ skipping 52 matching lines @@
 
   GpuSurfaceTracker::Get()->RemoveSurface(surface_id_);
   surface_id_ = 0;
 
   process_->Release(routing_id_);
 }
 
 // static
 RenderWidgetHostImpl* RenderWidgetHostImpl::FromRWHV(
     content::RenderWidgetHostView* rwhv) {
-  return static_cast<RenderWidgetHostImpl*>(rwhv->GetRenderWidgetHost());
+  return rwhv->GetRenderWidgetHost()->AsRWHImpl();
 }
 
 void RenderWidgetHostImpl::SetView(content::RenderWidgetHostView* view) {
   view_ = RenderWidgetHostViewPort::FromRWHV(view);
 
   if (!view_) {
     GpuSurfaceTracker::Get()->SetSurfaceHandle(
         surface_id_, gfx::GLSurfaceHandle());
   }
 }
 
+content::RenderProcessHost* RenderWidgetHostImpl::GetProcess() const {
+  return process_;
+}
+
+int RenderWidgetHostImpl::GetRoutingID() const {
+  return routing_id_;
+}
+
+content::RenderWidgetHostView* RenderWidgetHostImpl::GetView() const {
+  return view_;
+}
+
+RenderWidgetHostImpl* RenderWidgetHostImpl::AsRWHImpl() {
+  return this;
+}
+
+bool RenderWidgetHostImpl::OnMessageReceivedForTesting(
+    const IPC::Message& msg) {
+  return OnMessageReceived(msg);
+}
+
 gfx::NativeViewId RenderWidgetHostImpl::GetNativeViewId() const {
   if (view_)
     return view_->GetNativeViewId();
   return 0;
 }
 
 gfx::GLSurfaceHandle RenderWidgetHostImpl::GetCompositingSurface() {
   if (view_)
     return view_->GetCompositingSurface();
   return gfx::GLSurfaceHandle();
@@ skipping 86 matching lines @@
                         OnMsgCreatePluginContainer)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DestroyPluginContainer,
                         OnMsgDestroyPluginContainer)
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
 
   if (!msg_is_ok) {
     // The message de-serialization failed. Kill the renderer process.
     content::RecordAction(UserMetricsAction("BadMessageTerminate_RWH"));
-    process()->ReceivedBadMessage();
+    GetProcess()->ReceivedBadMessage();
   }
   return handled;
 }
 
 bool RenderWidgetHostImpl::Send(IPC::Message* msg) {
   return process_->Send(msg);
 }
 
 void RenderWidgetHostImpl::WasHidden() {
   is_hidden_ = true;
 
   // Don't bother reporting hung state when we aren't the active tab.
   StopHangMonitorTimeout();
 
   // If we have a renderer, then inform it that we are being hidden so it can
   // reduce its resource utilization.
   Send(new ViewMsg_WasHidden(routing_id_));
 
   // Tell the RenderProcessHost we were hidden.
   process_->WidgetHidden();
 
   bool is_visible = false;
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
-      content::Source<RenderWidgetHostImpl>(this),
+      content::Source<RenderWidgetHost>(this),
       content::Details<bool>(&is_visible));
 }
 
 void RenderWidgetHostImpl::WasRestored() {
   // When we create the widget, it is created as *not* hidden.
   if (!is_hidden_)
     return;
   is_hidden_ = false;
 
   BackingStore* backing_store = BackingStoreManager::Lookup(this);
   // If we already have a backing store for this widget, then we don't need to
   // repaint on restore _unless_ we know that our backing store is invalid.
   // When accelerated compositing is on, we must always repaint, even when
   // the backing store exists.
   bool needs_repainting;
   if (needs_repainting_on_restore_ || !backing_store ||
       is_accelerated_compositing_active()) {
     needs_repainting = true;
     needs_repainting_on_restore_ = false;
   } else {
     needs_repainting = false;
   }
   Send(new ViewMsg_WasRestored(routing_id_, needs_repainting));
 
   process_->WidgetRestored();
 
   bool is_visible = true;
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
-      content::Source<RenderWidgetHostImpl>(this),
+      content::Source<RenderWidgetHost>(this),
       content::Details<bool>(&is_visible));
 
   // It's possible for our size to be out of sync with the renderer. The
   // following is one case that leads to this:
   // 1. WasResized -> Send ViewMsg_Resize to render
   // 2. WasResized -> do nothing as resize_ack_pending_ is true
   // 3. WasHidden
   // 4. OnMsgUpdateRect from (1) processed. Does NOT invoke WasResized as view
   //    is hidden. Now renderer/browser out of sync with what they think size
   //    is.
@@ skipping 188 matching lines @@
   return backing_store;
 }
 
 BackingStore* RenderWidgetHostImpl::AllocBackingStore(const gfx::Size& size) {
   if (!view_)
     return NULL;
   return view_->AllocBackingStore(size);
 }
 
 void RenderWidgetHostImpl::DonePaintingToBackingStore() {
-  Send(new ViewMsg_UpdateRect_ACK(routing_id()));
+  Send(new ViewMsg_UpdateRect_ACK(GetRoutingID()));
 }
 
 void RenderWidgetHostImpl::ScheduleComposite() {
   if (is_hidden_ || !is_accelerated_compositing_active_) {
       return;
   }
 
   // Send out a request to the renderer to paint the view if required.
   if (!repaint_ack_pending_ && !resize_ack_pending_ && !view_being_painted_) {
     repaint_start_time_ = TimeTicks::Now();
@@ skipping 277 matching lines @@
 }
 
 void RenderWidgetHostImpl::CancelUpdateTextDirection() {
   if (text_direction_updated_)
     text_direction_canceled_ = true;
 }
 
 void RenderWidgetHostImpl::NotifyTextDirection() {
   if (text_direction_updated_) {
     if (!text_direction_canceled_)
-      Send(new ViewMsg_SetTextDirection(routing_id(), text_direction_));
+      Send(new ViewMsg_SetTextDirection(GetRoutingID(), text_direction_));
     text_direction_updated_ = false;
     text_direction_canceled_ = false;
   }
 }
 
 void RenderWidgetHostImpl::SetInputMethodActive(bool activate) {
-  Send(new ViewMsg_SetInputMethodActive(routing_id(), activate));
+  Send(new ViewMsg_SetInputMethodActive(GetRoutingID(), activate));
 }
 
 void RenderWidgetHostImpl::ImeSetComposition(
     const string16& text,
     const std::vector<WebKit::WebCompositionUnderline>& underlines,
     int selection_start,
     int selection_end) {
   Send(new ViewMsg_ImeSetComposition(
-            routing_id(), text, underlines, selection_start, selection_end));
+            GetRoutingID(), text, underlines, selection_start, selection_end));
 }
 
 void RenderWidgetHostImpl::ImeConfirmComposition(const string16& text) {
   ImeConfirmComposition(text, ui::Range::InvalidRange());
 }
 
 void RenderWidgetHostImpl::ImeConfirmComposition(
     const string16& text, const ui::Range& replacement_range) {
   Send(new ViewMsg_ImeConfirmComposition(
-        routing_id(), text, replacement_range));
+        GetRoutingID(), text, replacement_range));
 }
 
 void RenderWidgetHostImpl::ImeConfirmComposition() {
   ImeConfirmComposition(string16());
 }
 
 void RenderWidgetHostImpl::ImeCancelComposition() {
-  Send(new ViewMsg_ImeSetComposition(routing_id(), string16(),
+  Send(new ViewMsg_ImeSetComposition(GetRoutingID(), string16(),
             std::vector<WebKit::WebCompositionUnderline>(), 0, 0));
 }
 
 gfx::Rect RenderWidgetHostImpl::GetRootWindowResizerRect() const {
   return gfx::Rect();
 }
 
 void RenderWidgetHostImpl::RequestToLockMouse() {
   // Directly reject to lock the mouse. Subclass can override this method to
   // decide whether to allow mouse lock or not.
@@ skipping 28 matching lines @@
   DCHECK(enable);
 
   // TODO: Change this to enable instead of true when this supports turning
   // off auto-resize.
   should_auto_resize_ = true;
 }
 
 void RenderWidgetHostImpl::Destroy() {
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
-      content::Source<RenderWidgetHostImpl>(this),
+      content::Source<RenderWidgetHost>(this),
       content::NotificationService::NoDetails());
 
   // Tell the view to die.
   // Note that in the process of the view shutting down, it can call a ton
   // of other messages on us.  So if you do any other deinitialization here,
   // do it after this call to view_->Destroy().
   if (view_)
     view_->Destroy();
 
   delete this;
 }
 
 void RenderWidgetHostImpl::CheckRendererIsUnresponsive() {
   // If we received a call to StopHangMonitorTimeout.
   if (time_when_considered_hung_.is_null())
     return;
 
   // If we have not waited long enough, then wait some more.
   Time now = Time::Now();
   if (now < time_when_considered_hung_) {
     StartHangMonitorTimeout(time_when_considered_hung_ - now);
     return;
   }
 
   // OK, looks like we have a hung renderer!
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDERER_PROCESS_HANG,
-      content::Source<RenderWidgetHostImpl>(this),
+      content::Source<RenderWidgetHost>(this),
       content::NotificationService::NoDetails());
   is_unresponsive_ = true;
   NotifyRendererUnresponsive();
 }
 
 void RenderWidgetHostImpl::RendererIsResponsive() {
   if (is_unresponsive_) {
     is_unresponsive_ = false;
     NotifyRendererResponsive();
   }
@@ skipping 35 matching lines @@
     if (text_direction_hint == WebKit::WebTextDirectionLeftToRight) {
       // Force the tooltip to have LTR directionality.
       wrapped_tooltip_text =
           base::i18n::GetDisplayStringInLTRDirectionality(wrapped_tooltip_text);
     } else if (text_direction_hint == WebKit::WebTextDirectionRightToLeft &&
                !base::i18n::IsRTL()) {
       // Force the tooltip to have RTL directionality.
       base::i18n::WrapStringWithRTLFormatting(&wrapped_tooltip_text);
     }
   }
-  if (view())
+  if (GetView())
     view_->SetTooltipText(wrapped_tooltip_text);
 }
 
 void RenderWidgetHostImpl::OnMsgRequestMove(const gfx::Rect& pos) {
   // Note that we ignore the position.
   if (view_) {
     view_->SetBounds(pos);
     Send(new ViewMsg_Move_ACK(routing_id_));
   }
 }
 
 void RenderWidgetHostImpl::OnMsgPaintAtSizeAck(int tag, const gfx::Size& size) {
   PaintAtSizeAckDetails details = {tag, size};
   gfx::Size size_details = size;
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
-      content::Source<RenderWidgetHostImpl>(this),
+      content::Source<RenderWidgetHost>(this),
       content::Details<PaintAtSizeAckDetails>(&details));
 }
 
 void RenderWidgetHostImpl::OnMsgUpdateRect(
     const ViewHostMsg_UpdateRect_Params& params) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::OnMsgUpdateRect");
   TimeTicks paint_start = TimeTicks::Now();
 
   // Update our knowledge of the RenderWidget's size.
   current_size_ = params.view_size;
@@ skipping 30 matching lines @@
         params.bitmap_rect.width() * 4;
     TransportDIB* dib = process_->GetTransportDIB(params.bitmap);
 
     // If gpu process does painting, scroll_rect and copy_rects are always empty
     // and backing store is never used.
     if (dib) {
       if (dib->size() < size) {
         DLOG(WARNING) << "Transport DIB too small for given rectangle";
         content::RecordAction(
             UserMetricsAction("BadMessageTerminate_RWH1"));
-        process()->ReceivedBadMessage();
+        GetProcess()->ReceivedBadMessage();
       } else {
         UNSHIPPED_TRACE_EVENT_INSTANT2("test_latency", "UpdateRect",
             "x+y", params.bitmap_rect.x() + params.bitmap_rect.y(),
             "color", 0xffffff & *static_cast<uint32*>(dib->memory()));
         UNSHIPPED_TRACE_EVENT_INSTANT1("test_latency", "UpdateRectWidth",
             "width", params.bitmap_rect.width());
 
         // Scroll the backing store.
         if (!params.scroll_rect.IsEmpty()) {
           ScrollBackingStoreRect(params.dx, params.dy,
@@ skipping 65 matching lines @@
   // Now paint the view. Watch out: it might be destroyed already.
   if (view_ && !is_accelerated_compositing_active_) {
     view_being_painted_ = true;
     view_->DidUpdateBackingStore(params.scroll_rect, params.dx, params.dy,
                                  params.copy_rects);
     view_being_painted_ = false;
   }
 
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT,
-      content::Source<RenderWidgetHostImpl>(this),
+      content::Source<RenderWidgetHost>(this),
       content::NotificationService::NoDetails());
 
   // If we got a resize ack, then perhaps we have another resize to send?
   bool is_resize_ack =
       ViewHostMsg_UpdateRect_Flags::is_resize_ack(params.flags);
   if (is_resize_ack && view_) {
     gfx::Rect view_bounds = view_->GetViewBounds();
     if (current_size_ != view_bounds.size())
       WasResized();
   }
 
   // Log the time delta for processing a paint message.
   TimeTicks now = TimeTicks::Now();
   TimeDelta delta = now - update_start;
   UMA_HISTOGRAM_TIMES("MPArch.RWH_DidUpdateBackingStore", delta);
 
   // Measures the time from receiving the MsgUpdateRect IPC to completing the
   // DidUpdateBackingStore() method.  On platforms which have asynchronous
   // painting, such as Linux, this is the sum of MPArch.RWH_OnMsgUpdateRect,
   // MPArch.RWH_DidUpdateBackingStore, and the time spent asynchronously
   // waiting for the paint to complete.
   //
   // On other platforms, this will be equivalent to MPArch.RWH_OnMsgUpdateRect.
   delta = now - paint_start;
   UMA_HISTOGRAM_TIMES("MPArch.RWH_TotalPaintTime", delta);
 }
 
 void RenderWidgetHostImpl::OnMsgInputEventAck(WebInputEvent::Type event_type,
-                                          bool processed) {
+                                              bool processed) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::OnMsgInputEventAck");
 
   // Log the time delta for processing an input event.
   TimeDelta delta = TimeTicks::Now() - input_event_start_time_;
   UMA_HISTOGRAM_TIMES("MPArch.RWH_InputEventDelta", delta);
 
   // Cancel pending hung renderer checks since the renderer is responsive.
   if (--in_flight_event_count_ == 0)
     StopHangMonitorTimeout();
 
   int type = static_cast<int>(event_type);
   if (type < WebInputEvent::Undefined) {
     content::RecordAction(UserMetricsAction("BadMessageTerminate_RWH2"));
-    process()->ReceivedBadMessage();
+    process_->ReceivedBadMessage();
   } else if (type == WebInputEvent::MouseMove) {
     mouse_move_pending_ = false;
 
     // now, we can send the next mouse move event
     if (next_mouse_move_.get()) {
       DCHECK(next_mouse_move_->type == WebInputEvent::MouseMove);
       ForwardMouseEvent(*next_mouse_move_);
     }
   } else if (WebInputEvent::isKeyboardEventType(type)) {
     ProcessKeyboardEventAck(type, processed);
   } else if (type == WebInputEvent::MouseWheel) {
     ProcessWheelAck(processed);
   } else if (WebInputEvent::isTouchEventType(type)) {
     ProcessTouchAck(processed);
   }
-  // This is used only for testing.
+
+  // This is used only for testing, and the other end does not use the
+  // source object.  On linux, specifying
+  // content::Source<RenderWidgetHost> results in a very strange
+  // runtime error in the epilogue of the enclosing
+  // (OnMsgInputEventAck) method, but not on other platforms; using
+  // 'void' instead is just as safe (since content::NotificationSource
+  // is not actually typesafe) and avoids this error.
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_INPUT_EVENT_ACK,
-      content::Source<RenderWidgetHostImpl>(this),
+      content::Source<void>(this),
       content::Details<int>(&type));
 }
 
 void RenderWidgetHostImpl::ProcessWheelAck(bool processed) {
   mouse_wheel_pending_ = false;
 
   // Now send the next (coalesced) mouse wheel event.
   if (!coalesced_mouse_wheel_events_.empty()) {
     WebMouseWheelEvent next_wheel_event =
         coalesced_mouse_wheel_events_.front();
     coalesced_mouse_wheel_events_.pop_front();
     ForwardWheelEvent(next_wheel_event);
   }
 
   if (!processed && !is_hidden_ && view_)
     view_->UnhandledWheelEvent(current_wheel_event_);
 }
 
 void RenderWidgetHostImpl::ProcessTouchAck(bool processed) {
   if (view_)
     view_->ProcessTouchAck(processed);
 }
 
 void RenderWidgetHostImpl::OnMsgFocus() {
   // Only RenderViewHost can deal with that message.
   content::RecordAction(UserMetricsAction("BadMessageTerminate_RWH4"));
-  process()->ReceivedBadMessage();
+  GetProcess()->ReceivedBadMessage();
 }
 
 void RenderWidgetHostImpl::OnMsgBlur() {
   // Only RenderViewHost can deal with that message.
   content::RecordAction(UserMetricsAction("BadMessageTerminate_RWH5"));
-  process()->ReceivedBadMessage();
+  GetProcess()->ReceivedBadMessage();
 }
 
 void RenderWidgetHostImpl::OnMsgDidChangeNumTouchEvents(int count) {
   has_touch_handler_ = count > 0;
 }
 
 void RenderWidgetHostImpl::OnMsgSetCursor(const WebCursor& cursor) {
   if (!view_) {
     return;
   }
@@ skipping 130 matching lines @@
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableRendererAccessibility)) {
     return;
   }
 
   renderer_accessible_ = true;
 
   if (process_->HasConnection()) {
     // Renderer accessibility wasn't enabled on process launch. Enable it now.
-    Send(new AccessibilityMsg_Enable(routing_id()));
+    Send(new AccessibilityMsg_Enable(GetRoutingID()));
   }
 }
 
+void RenderWidgetHostImpl::SetIgnoreInputEvents(bool ignore_input_events) {
+  ignore_input_events_ = ignore_input_events;
+}
+
 void RenderWidgetHostImpl::ProcessKeyboardEventAck(int type, bool processed) {
   if (key_queue_.empty()) {
     LOG(ERROR) << "Got a KeyEvent back from the renderer but we "
                << "don't seem to have sent it to the renderer!";
   } else if (key_queue_.front().type != type) {
     LOG(ERROR) << "We seem to have a different key type sent from "
                << "the renderer. (" << key_queue_.front().type << " vs. "
                << type << "). Ignoring event.";
 
     // Something must be wrong. Clear the |key_queue_| and
@@ skipping 30 matching lines @@
   for (int i = 0; i < static_cast<int>(deferred_plugin_handles_.size()); i++) {
 #if defined(TOOLKIT_USES_GTK)
     view_->CreatePluginContainer(deferred_plugin_handles_[i]);
 #endif
   }
 
   deferred_plugin_handles_.clear();
 #endif
 }
 
+const gfx::Point& RenderWidgetHostImpl::GetLastScrollOffset() const {
+  return last_scroll_offset_;
+}
+
 void RenderWidgetHostImpl::StartUserGesture() {
   OnUserGesture();
 }
 
 void RenderWidgetHostImpl::Stop() {
-  Send(new ViewMsg_Stop(routing_id()));
+  Send(new ViewMsg_Stop(GetRoutingID()));
 }
 
 void RenderWidgetHostImpl::SetBackground(const SkBitmap& background) {
-  Send(new ViewMsg_SetBackground(routing_id(), background));
+  Send(new ViewMsg_SetBackground(GetRoutingID(), background));
 }
 
 void RenderWidgetHostImpl::SetEditCommandsForNextKeyEvent(
     const std::vector<EditCommand>& commands) {
-  Send(new ViewMsg_SetEditCommandsForNextKeyEvent(routing_id(), commands));
+  Send(new ViewMsg_SetEditCommandsForNextKeyEvent(GetRoutingID(), commands));
 }
 
 void RenderWidgetHostImpl::AccessibilityDoDefaultAction(int object_id) {
-  Send(new AccessibilityMsg_DoDefaultAction(routing_id(), object_id));
+  Send(new AccessibilityMsg_DoDefaultAction(GetRoutingID(), object_id));
 }
 
 void RenderWidgetHostImpl::AccessibilitySetFocus(int object_id) {
-  Send(new AccessibilityMsg_SetFocus(routing_id(), object_id));
+  Send(new AccessibilityMsg_SetFocus(GetRoutingID(), object_id));
 }
 
 void RenderWidgetHostImpl::AccessibilityScrollToMakeVisible(
     int acc_obj_id, gfx::Rect subfocus) {
   Send(new AccessibilityMsg_ScrollToMakeVisible(
-      routing_id(), acc_obj_id, subfocus));
+      GetRoutingID(), acc_obj_id, subfocus));
 }
 
 void RenderWidgetHostImpl::AccessibilityScrollToPoint(
     int acc_obj_id, gfx::Point point) {
   Send(new AccessibilityMsg_ScrollToPoint(
-      routing_id(), acc_obj_id, point));
+      GetRoutingID(), acc_obj_id, point));
 }
 
 void RenderWidgetHostImpl::AccessibilitySetTextSelection(
     int object_id, int start_offset, int end_offset) {
   Send(new AccessibilityMsg_SetTextSelection(
-      routing_id(), object_id, start_offset, end_offset));
+      GetRoutingID(), object_id, start_offset, end_offset));
 }
 
 void RenderWidgetHostImpl::ExecuteEditCommand(const std::string& command,
                                               const std::string& value) {
-  Send(new ViewMsg_ExecuteEditCommand(routing_id(), command, value));
+  Send(new ViewMsg_ExecuteEditCommand(GetRoutingID(), command, value));
 }
 
 void RenderWidgetHostImpl::ScrollFocusedEditableNodeIntoRect(
     const gfx::Rect& rect) {
-  Send(new ViewMsg_ScrollFocusedEditableNodeIntoRect(routing_id(), rect));
+  Send(new ViewMsg_ScrollFocusedEditableNodeIntoRect(GetRoutingID(), rect));
 }
 
 void RenderWidgetHostImpl::SelectRange(const gfx::Point& start,
                                        const gfx::Point& end) {
-  Send(new ViewMsg_SelectRange(routing_id(), start, end));
+  Send(new ViewMsg_SelectRange(GetRoutingID(), start, end));
 }
 
 void RenderWidgetHostImpl::Undo() {
-  Send(new ViewMsg_Undo(routing_id()));
+  Send(new ViewMsg_Undo(GetRoutingID()));
   content::RecordAction(UserMetricsAction("Undo"));
 }
 
 void RenderWidgetHostImpl::Redo() {
-  Send(new ViewMsg_Redo(routing_id()));
+  Send(new ViewMsg_Redo(GetRoutingID()));
   content::RecordAction(UserMetricsAction("Redo"));
 }
 
 void RenderWidgetHostImpl::Cut() {
-  Send(new ViewMsg_Cut(routing_id()));
+  Send(new ViewMsg_Cut(GetRoutingID()));
   content::RecordAction(UserMetricsAction("Cut"));
 }
 
 void RenderWidgetHostImpl::Copy() {
-  Send(new ViewMsg_Copy(routing_id()));
+  Send(new ViewMsg_Copy(GetRoutingID()));
   content::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(routing_id()));
+  Send(new ViewMsg_CopyToFindPboard(GetRoutingID()));
   content::RecordAction(UserMetricsAction("CopyToFindPboard"));
 #endif
 }
 
 void RenderWidgetHostImpl::Paste() {
-  Send(new ViewMsg_Paste(routing_id()));
+  Send(new ViewMsg_Paste(GetRoutingID()));
   content::RecordAction(UserMetricsAction("Paste"));
 }
 
 void RenderWidgetHostImpl::PasteAndMatchStyle() {
-  Send(new ViewMsg_PasteAndMatchStyle(routing_id()));
+  Send(new ViewMsg_PasteAndMatchStyle(GetRoutingID()));
   content::RecordAction(UserMetricsAction("PasteAndMatchStyle"));
 }
 
 void RenderWidgetHostImpl::Delete() {
-  Send(new ViewMsg_Delete(routing_id()));
+  Send(new ViewMsg_Delete(GetRoutingID()));
   content::RecordAction(UserMetricsAction("DeleteSelection"));
 }
 
 void RenderWidgetHostImpl::SelectAll() {
-  Send(new ViewMsg_SelectAll(routing_id()));
+  Send(new ViewMsg_SelectAll(GetRoutingID()));
   content::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 19 matching lines @@
     ui_shim->Send(new AcceleratedSurfaceMsg_BuffersSwappedACK(route_id));
 }
 
 // static
 void RenderWidgetHostImpl::AcknowledgePostSubBuffer(int32 route_id,
                                                     int gpu_host_id) {
   GpuProcessHostUIShim* ui_shim = GpuProcessHostUIShim::FromID(gpu_host_id);
   if (ui_shim)
     ui_shim->Send(new AcceleratedSurfaceMsg_PostSubBufferACK(route_id));
 }