Extract first version of a RenderWidgetHost interface.

This begins the process of extracting RWH and RVH interfaces and
leaving RenderWidgetHostImpl and RenderViewImpl classes in content.
There will be parallel inheritance hierarchies, i.e. RWHImpl inherits
from RWH, RVH inherits from RWH, RVHImpl inherits from RVH and
RWHImpl.  Thus, chrome will only see the interfaces.

I fully expect that some of the things chrome needs from the RVH
interface, once I introduce that, will more properly belong on the RWH
interface, in which case I expect to move them there.  But first to
define the base interfaces.

BUG=98716

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=123227

Review URL: https://chromiumcodereview.appspot.com/9432027

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

29 files changed, 484 insertions, 315 deletions

diff --git a/content/browser/accessibility/renderer_accessibility_browsertest.cc b/content/browser/accessibility/renderer_accessibility_browsertest.cc
index a063f0d..212488a 100644
--- a/content/browser/accessibility/renderer_accessibility_browsertest.cc
+++ b/content/browser/accessibility/renderer_accessibility_browsertest.cc
@@ -40,7 +40,8 @@ class RendererAccessibilityBrowserTest : public InProcessBrowserTest {
         content::NotificationService::AllSources());
     content::RenderWidgetHostView* host_view =
         browser()->GetSelectedWebContents()->GetRenderWidgetHostView();
-    RenderWidgetHost* host = host_view->GetRenderWidgetHost();
+    RenderWidgetHostImpl* host = static_cast<RenderWidgetHostImpl*>(
+        host_view->GetRenderWidgetHost());
     RenderViewHost* view_host = static_cast<RenderViewHost*>(host);
     view_host->set_save_accessibility_tree_for_testing(true);
     view_host->EnableRendererAccessibility();
diff --git a/content/browser/gpu/gpu_process_host_ui_shim.cc b/content/browser/gpu/gpu_process_host_ui_shim.cc
index d4495ff..d247c48 100644
--- a/content/browser/gpu/gpu_process_host_ui_shim.cc
+++ b/content/browser/gpu/gpu_process_host_ui_shim.cc
@@ -88,7 +88,7 @@ RenderWidgetHostViewPort* GetRenderWidgetHostViewFromSurfaceID(
   if (!process)
     return NULL;
 
-  RenderWidgetHost* host = static_cast<RenderWidgetHost*>(
+  RenderWidgetHostImpl* host = static_cast<RenderWidgetHostImpl*>(
       process->GetListenerByID(render_widget_id));
   return host ? RenderWidgetHostViewPort::FromRWHV(host->view()) : NULL;
 }
diff --git a/content/browser/renderer_host/backing_store_manager.cc b/content/browser/renderer_host/backing_store_manager.cc
index ffd33f6..e4b1b90 100644
--- a/content/browser/renderer_host/backing_store_manager.cc
+++ b/content/browser/renderer_host/backing_store_manager.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -145,7 +145,8 @@ BackingStore* CreateBackingStore(RenderWidgetHost* host,
   } else {
     cache = small_cache;
   }
-  BackingStore* backing_store = host->AllocBackingStore(backing_store_size);
+  BackingStore* backing_store = static_cast<RenderWidgetHostImpl*>(
+      host)->AllocBackingStore(backing_store_size);
   if (backing_store)
     cache->Put(host, backing_store);
   return backing_store;
diff --git a/content/browser/renderer_host/gtk_im_context_wrapper.cc b/content/browser/renderer_host/gtk_im_context_wrapper.cc
index 8ce3475..3ca6117 100644
--- a/content/browser/renderer_host/gtk_im_context_wrapper.cc
+++ b/content/browser/renderer_host/gtk_im_context_wrapper.cc
@@ -284,7 +284,8 @@ void GtkIMContextWrapper::OnFocusIn() {
   // Enables RenderWidget's IME related events, so that we can be notified
   // when WebKit wants to enable or disable IME.
   if (host_view_->GetRenderWidgetHost())
-    host_view_->GetRenderWidgetHost()->SetInputMethodActive(true);
+    static_cast<RenderWidgetHostImpl*>(
+        host_view_->GetRenderWidgetHost())->SetInputMethodActive(true);
 }
 
 void GtkIMContextWrapper::OnFocusOut() {
@@ -311,7 +312,8 @@ void GtkIMContextWrapper::OnFocusOut() {
 
   // Disable RenderWidget's IME related events to save bandwidth.
   if (host_view_->GetRenderWidgetHost())
-    host_view_->GetRenderWidgetHost()->SetInputMethodActive(false);
+    static_cast<RenderWidgetHostImpl*>(
+        host_view_->GetRenderWidgetHost())->SetInputMethodActive(false);
 }
 
 #if !defined(TOOLKIT_VIEWS)
@@ -407,7 +409,7 @@ void GtkIMContextWrapper::ProcessUnfilteredKeyPressEvent(
 
 void GtkIMContextWrapper::ProcessInputMethodResult(const GdkEventKey* event,
                                                    bool filtered) {
-  RenderWidgetHost* host = host_view_->GetRenderWidgetHost();
+  RenderWidgetHostImpl* host = RenderWidgetHostImpl::FromRWHV(host_view_);
   if (!host)
     return;
 
@@ -470,7 +472,8 @@ void GtkIMContextWrapper::ConfirmComposition() {
 
   if (is_composing_text_) {
     if (host_view_->GetRenderWidgetHost())
-      host_view_->GetRenderWidgetHost()->ImeConfirmComposition();
+      static_cast<RenderWidgetHostImpl*>(
+          host_view_->GetRenderWidgetHost())->ImeConfirmComposition();
 
     // Reset the input method.
     CancelComposition();
@@ -495,7 +498,8 @@ void GtkIMContextWrapper::HandleCommit(const string16& text) {
   if (!is_in_key_event_handler_ && host_view_->GetRenderWidgetHost()) {
     // Workaround http://crbug.com/45478 by sending fake key down/up events.
     SendFakeCompositionKeyEvent(WebKit::WebInputEvent::RawKeyDown);
-    host_view_->GetRenderWidgetHost()->ImeConfirmComposition(text);
+    static_cast<RenderWidgetHostImpl*>(
+        host_view_->GetRenderWidgetHost())->ImeConfirmComposition(text);
     SendFakeCompositionKeyEvent(WebKit::WebInputEvent::KeyUp);
   }
 }
@@ -543,7 +547,8 @@ void GtkIMContextWrapper::HandlePreeditChanged(const gchar* text,
     const std::vector<WebKit::WebCompositionUnderline>& underlines =
         reinterpret_cast<const std::vector<WebKit::WebCompositionUnderline>&>(
             composition_.underlines);
-    host_view_->GetRenderWidgetHost()->ImeSetComposition(
+    static_cast<RenderWidgetHostImpl*>(
+        host_view_->GetRenderWidgetHost())->ImeSetComposition(
         composition_.text, underlines, composition_.selection.start(),
         composition_.selection.end());
     SendFakeCompositionKeyEvent(WebKit::WebInputEvent::KeyUp);
@@ -560,7 +565,8 @@ void GtkIMContextWrapper::HandlePreeditEnd() {
     // we need inform webkit to clear it.
     // It's only necessary when it's not in ProcessKeyEvent ().
     if (!is_in_key_event_handler_ && host_view_->GetRenderWidgetHost())
-      host_view_->GetRenderWidgetHost()->ImeCancelComposition();
+      static_cast<RenderWidgetHostImpl*>(
+          host_view_->GetRenderWidgetHost())->ImeCancelComposition();
   }
 
   // Don't set is_composing_text_ to false here, because "preedit_end"
diff --git a/content/browser/renderer_host/render_view_host.cc b/content/browser/renderer_host/render_view_host.cc
index bd2ed9d..e86d7fb 100644
--- a/content/browser/renderer_host/render_view_host.cc
+++ b/content/browser/renderer_host/render_view_host.cc
@@ -106,7 +106,7 @@ RenderViewHost* RenderViewHost::FromID(int render_process_id,
       content::RenderProcessHost::FromID(render_process_id);
   if (!process)
     return NULL;
-  RenderWidgetHost* widget = static_cast<RenderWidgetHost*>(
+  RenderWidgetHost* widget = RenderWidgetHost::FromIPCChannelListener(
       process->GetListenerByID(render_view_id));
   if (!widget || !widget->IsRenderView())
     return NULL;
@@ -117,7 +117,7 @@ RenderViewHost::RenderViewHost(SiteInstance* instance,
                                RenderViewHostDelegate* delegate,
                                int routing_id,
                                SessionStorageNamespace* session_storage)
-    : RenderWidgetHost(instance->GetProcess(), routing_id),
+    : RenderWidgetHostImpl(instance->GetProcess(), routing_id),
       instance_(static_cast<SiteInstanceImpl*>(instance)),
       delegate_(delegate),
       waiting_for_drag_context_response_(false),
@@ -628,7 +628,7 @@ void RenderViewHost::SetWebUIProperty(const std::string& name,
 }
 
 void RenderViewHost::GotFocus() {
-  RenderWidgetHost::GotFocus();  // Notifies the renderer it got focus.
+  RenderWidgetHostImpl::GotFocus();  // Notifies the renderer it got focus.
 
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
   if (view)
@@ -636,12 +636,12 @@ void RenderViewHost::GotFocus() {
 }
 
 void RenderViewHost::LostCapture() {
-  RenderWidgetHost::LostCapture();
+  RenderWidgetHostImpl::LostCapture();
   delegate_->LostCapture();
 }
 
 void RenderViewHost::LostMouseLock() {
-  RenderWidgetHost::LostMouseLock();
+  RenderWidgetHostImpl::LostMouseLock();
   delegate_->LostMouseLock();
 }
 
@@ -793,7 +793,8 @@ bool RenderViewHost::OnMessageReceived(const IPC::Message& msg) {
     IPC_MESSAGE_HANDLER(AccessibilityHostMsg_Notifications,
                         OnAccessibilityNotifications)
     // Have the super handle all other messages.
-    IPC_MESSAGE_UNHANDLED(handled = RenderWidgetHost::OnMessageReceived(msg))
+    IPC_MESSAGE_UNHANDLED(
+        handled = RenderWidgetHostImpl::OnMessageReceived(msg))
   IPC_END_MESSAGE_MAP_EX()
 
   if (!msg_is_ok) {
@@ -813,7 +814,7 @@ void RenderViewHost::Shutdown() {
     run_modal_reply_msg_ = NULL;
   }
 
-  RenderWidgetHost::Shutdown();
+  RenderWidgetHostImpl::Shutdown();
 }
 
 bool RenderViewHost::IsRenderView() const {
@@ -1283,7 +1284,7 @@ void RenderViewHost::ForwardMouseEvent(
   // We make a copy of the mouse event because
   // RenderWidgetHost::ForwardMouseEvent will delete |mouse_event|.
   WebKit::WebMouseEvent event_copy(mouse_event);
-  RenderWidgetHost::ForwardMouseEvent(event_copy);
+  RenderWidgetHostImpl::ForwardMouseEvent(event_copy);
 
   switch (event_copy.type) {
     case WebInputEvent::MouseMove:
@@ -1318,7 +1319,7 @@ void RenderViewHost::ForwardKeyboardEvent(
       delegate_->OnIgnoredUIEvent();
     return;
   }
-  RenderWidgetHost::ForwardKeyboardEvent(key_event);
+  RenderWidgetHostImpl::ForwardKeyboardEvent(key_event);
 }
 
 #if defined(OS_MACOSX)
diff --git a/content/browser/renderer_host/render_view_host.h b/content/browser/renderer_host/render_view_host.h
index ff7e572..ab46e8e 100644
--- a/content/browser/renderer_host/render_view_host.h
+++ b/content/browser/renderer_host/render_view_host.h
@@ -126,7 +126,8 @@ class ExecuteNotificationObserver : public content::NotificationObserver {
 //  if we want to bring that and other functionality down into this object so
 //  it can be shared by others.
 //
-class CONTENT_EXPORT RenderViewHost : public RenderWidgetHost {
+// TODO(joi): Hide most of this from chrome.
+class CONTENT_EXPORT RenderViewHost : public RenderWidgetHostImpl {
  public:
   // Returns the RenderViewHost given its ID and the ID of its render process.
   // Returns NULL if the IDs do not correspond to a live RenderViewHost.
diff --git a/content/browser/renderer_host/render_widget_host.cc b/content/browser/renderer_host/render_widget_host.cc
index d35c6ad..4d1f857 100644
--- a/content/browser/renderer_host/render_widget_host.cc
+++ b/content/browser/renderer_host/render_widget_host.cc
@@ -19,6 +19,7 @@
 #include "content/browser/renderer_host/backing_store.h"
 #include "content/browser/renderer_host/backing_store_manager.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
+#include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_widget_helper.h"
 #include "content/common/accessibility_messages.h"
 #include "content/common/gpu/gpu_messages.h"
@@ -73,16 +74,38 @@ bool ShouldCoalesceMouseWheelEvents(const WebMouseWheelEvent& last_event,
 
 }  // 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));
+}
+
 ///////////////////////////////////////////////////////////////////////////////
-// RenderWidgetHost
+// RenderWidgetHostImpl
 
-RenderWidgetHost::RenderWidgetHost(content::RenderProcessHost* process,
-                                   int routing_id)
-    : view_(NULL),
+RenderWidgetHostImpl::RenderWidgetHostImpl(content::RenderProcessHost* process,
+                                           int routing_id)
+    : RenderWidgetHost(process),
       renderer_initialized_(false),
       hung_renderer_delay_ms_(kHungRendererDelayMs),
       renderer_accessible_(false),
-      process_(process),
       routing_id_(routing_id),
       surface_id_(0),
       is_loading_(false),
@@ -141,7 +164,7 @@ RenderWidgetHost::RenderWidgetHost(content::RenderProcessHost* process,
   }
 }
 
-RenderWidgetHost::~RenderWidgetHost() {
+RenderWidgetHostImpl::~RenderWidgetHostImpl() {
   SetView(NULL);
 
   // Clear our current or cached backing store if either remains.
@@ -153,7 +176,13 @@ RenderWidgetHost::~RenderWidgetHost() {
   process_->Release(routing_id_);
 }
 
-void RenderWidgetHost::SetView(content::RenderWidgetHostView* view) {
+// static
+RenderWidgetHostImpl* RenderWidgetHostImpl::FromRWHV(
+    content::RenderWidgetHostView* rwhv) {
+  return static_cast<RenderWidgetHostImpl*>(rwhv->GetRenderWidgetHost());
+}
+
+void RenderWidgetHostImpl::SetView(content::RenderWidgetHostView* view) {
   view_ = RenderWidgetHostViewPort::FromRWHV(view);
 
   if (!view_) {
@@ -162,29 +191,25 @@ void RenderWidgetHost::SetView(content::RenderWidgetHostView* view) {
   }
 }
 
-content::RenderWidgetHostView* RenderWidgetHost::view() const {
-  return view_;
-}
-
-gfx::NativeViewId RenderWidgetHost::GetNativeViewId() const {
+gfx::NativeViewId RenderWidgetHostImpl::GetNativeViewId() const {
   if (view_)
     return view_->GetNativeViewId();
   return 0;
 }
 
-gfx::GLSurfaceHandle RenderWidgetHost::GetCompositingSurface() {
+gfx::GLSurfaceHandle RenderWidgetHostImpl::GetCompositingSurface() {
   if (view_)
     return view_->GetCompositingSurface();
   return gfx::GLSurfaceHandle();
 }
 
-bool RenderWidgetHost::PreHandleKeyboardEvent(
+bool RenderWidgetHostImpl::PreHandleKeyboardEvent(
     const NativeWebKeyboardEvent& event,
     bool* is_keyboard_shortcut) {
   return false;
 }
 
-void RenderWidgetHost::Init() {
+void RenderWidgetHostImpl::Init() {
   DCHECK(process_->HasConnection());
 
   renderer_initialized_ = true;
@@ -197,7 +222,7 @@ void RenderWidgetHost::Init() {
   WasResized();
 }
 
-void RenderWidgetHost::Shutdown() {
+void RenderWidgetHostImpl::Shutdown() {
   if (process_->HasConnection()) {
     // Tell the renderer object to close.
     bool rv = Send(new ViewMsg_Close(routing_id_));
@@ -207,14 +232,14 @@ void RenderWidgetHost::Shutdown() {
   Destroy();
 }
 
-bool RenderWidgetHost::IsRenderView() const {
+bool RenderWidgetHostImpl::IsRenderView() const {
   return false;
 }
 
-bool RenderWidgetHost::OnMessageReceived(const IPC::Message &msg) {
+bool RenderWidgetHostImpl::OnMessageReceived(const IPC::Message &msg) {
   bool handled = true;
   bool msg_is_ok = true;
-  IPC_BEGIN_MESSAGE_MAP_EX(RenderWidgetHost, msg, msg_is_ok)
+  IPC_BEGIN_MESSAGE_MAP_EX(RenderWidgetHostImpl, msg, msg_is_ok)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RenderViewReady, OnMsgRenderViewReady)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RenderViewGone, OnMsgRenderViewGone)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Close, OnMsgClose)
@@ -277,11 +302,11 @@ bool RenderWidgetHost::OnMessageReceived(const IPC::Message &msg) {
   return handled;
 }
 
-bool RenderWidgetHost::Send(IPC::Message* msg) {
+bool RenderWidgetHostImpl::Send(IPC::Message* msg) {
   return process_->Send(msg);
 }
 
-void RenderWidgetHost::WasHidden() {
+void RenderWidgetHostImpl::WasHidden() {
   is_hidden_ = true;
 
   // Don't bother reporting hung state when we aren't the active tab.
@@ -297,11 +322,11 @@ void RenderWidgetHost::WasHidden() {
   bool is_visible = false;
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
-      content::Source<RenderWidgetHost>(this),
+      content::Source<RenderWidgetHostImpl>(this),
       content::Details<bool>(&is_visible));
 }
 
-void RenderWidgetHost::WasRestored() {
+void RenderWidgetHostImpl::WasRestored() {
   // When we create the widget, it is created as *not* hidden.
   if (!is_hidden_)
     return;
@@ -327,7 +352,7 @@ void RenderWidgetHost::WasRestored() {
   bool is_visible = true;
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
-      content::Source<RenderWidgetHost>(this),
+      content::Source<RenderWidgetHostImpl>(this),
       content::Details<bool>(&is_visible));
 
   // It's possible for our size to be out of sync with the renderer. The
@@ -348,7 +373,7 @@ void RenderWidgetHost::WasRestored() {
   WasResized();
 }
 
-void RenderWidgetHost::WasResized() {
+void RenderWidgetHostImpl::WasResized() {
   if (resize_ack_pending_ || !process_->HasConnection() || !view_ ||
       !renderer_initialized_ || should_auto_resize_) {
     return;
@@ -386,19 +411,19 @@ void RenderWidgetHost::WasResized() {
   }
 }
 
-void RenderWidgetHost::ResizeRectChanged(const gfx::Rect& new_rect) {
+void RenderWidgetHostImpl::ResizeRectChanged(const gfx::Rect& new_rect) {
   Send(new ViewMsg_ChangeResizeRect(routing_id_, new_rect));
 }
 
-void RenderWidgetHost::GotFocus() {
+void RenderWidgetHostImpl::GotFocus() {
   Focus();
 }
 
-void RenderWidgetHost::Focus() {
+void RenderWidgetHostImpl::Focus() {
   Send(new ViewMsg_SetFocus(routing_id_, true));
 }
 
-void RenderWidgetHost::Blur() {
+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.
@@ -408,19 +433,19 @@ void RenderWidgetHost::Blur() {
   Send(new ViewMsg_SetFocus(routing_id_, false));
 }
 
-void RenderWidgetHost::LostCapture() {
+void RenderWidgetHostImpl::LostCapture() {
   Send(new ViewMsg_MouseCaptureLost(routing_id_));
 }
 
-void RenderWidgetHost::SetActive(bool active) {
+void RenderWidgetHostImpl::SetActive(bool active) {
   Send(new ViewMsg_SetActive(routing_id_, active));
 }
 
-void RenderWidgetHost::LostMouseLock() {
+void RenderWidgetHostImpl::LostMouseLock() {
   Send(new ViewMsg_MouseLockLost(routing_id_));
 }
 
-void RenderWidgetHost::ViewDestroyed() {
+void RenderWidgetHostImpl::ViewDestroyed() {
   RejectMouseLockOrUnlockIfNecessary();
 
   // TODO(evanm): tracking this may no longer be necessary;
@@ -428,14 +453,14 @@ void RenderWidgetHost::ViewDestroyed() {
   SetView(NULL);
 }
 
-void RenderWidgetHost::SetIsLoading(bool is_loading) {
+void RenderWidgetHostImpl::SetIsLoading(bool is_loading) {
   is_loading_ = is_loading;
   if (!view_)
     return;
   view_->SetIsLoading(is_loading);
 }
 
-void RenderWidgetHost::PaintAtSize(TransportDIB::Handle dib_handle,
+void RenderWidgetHostImpl::PaintAtSize(TransportDIB::Handle dib_handle,
                                    int tag,
                                    const gfx::Size& page_size,
                                    const gfx::Size& desired_size) {
@@ -446,8 +471,8 @@ void RenderWidgetHost::PaintAtSize(TransportDIB::Handle dib_handle,
                                page_size, desired_size));
 }
 
-BackingStore* RenderWidgetHost::GetBackingStore(bool force_create) {
-  TRACE_EVENT2("renderer_host", "RenderWidgetHost::GetBackingStore",
+BackingStore* RenderWidgetHostImpl::GetBackingStore(bool force_create) {
+  TRACE_EVENT2("renderer_host", "RenderWidgetHostImpl::GetBackingStore",
                "width", base::IntToString(current_size_.width()),
                "height", base::IntToString(current_size_.height()));
 
@@ -493,17 +518,17 @@ BackingStore* RenderWidgetHost::GetBackingStore(bool force_create) {
   return backing_store;
 }
 
-BackingStore* RenderWidgetHost::AllocBackingStore(const gfx::Size& size) {
+BackingStore* RenderWidgetHostImpl::AllocBackingStore(const gfx::Size& size) {
   if (!view_)
     return NULL;
   return view_->AllocBackingStore(size);
 }
 
-void RenderWidgetHost::DonePaintingToBackingStore() {
+void RenderWidgetHostImpl::DonePaintingToBackingStore() {
   Send(new ViewMsg_UpdateRect_ACK(routing_id()));
 }
 
-void RenderWidgetHost::ScheduleComposite() {
+void RenderWidgetHostImpl::ScheduleComposite() {
   if (is_hidden_ || !is_accelerated_compositing_active_) {
       return;
   }
@@ -516,7 +541,7 @@ void RenderWidgetHost::ScheduleComposite() {
   }
 }
 
-void RenderWidgetHost::StartHangMonitorTimeout(TimeDelta delay) {
+void RenderWidgetHostImpl::StartHangMonitorTimeout(TimeDelta delay) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableHangMonitor)) {
     return;
@@ -544,25 +569,25 @@ void RenderWidgetHost::StartHangMonitorTimeout(TimeDelta delay) {
   time_when_considered_hung_ = requested_end_time;
   hung_renderer_timer_.Stop();
   hung_renderer_timer_.Start(FROM_HERE, delay, this,
-      &RenderWidgetHost::CheckRendererIsUnresponsive);
+      &RenderWidgetHostImpl::CheckRendererIsUnresponsive);
 }
 
-void RenderWidgetHost::RestartHangMonitorTimeout() {
+void RenderWidgetHostImpl::RestartHangMonitorTimeout() {
   // Setting to null will cause StartHangMonitorTimeout to restart the timer.
   time_when_considered_hung_ = Time();
   StartHangMonitorTimeout(
       TimeDelta::FromMilliseconds(hung_renderer_delay_ms_));
 }
 
-void RenderWidgetHost::StopHangMonitorTimeout() {
+void RenderWidgetHostImpl::StopHangMonitorTimeout() {
   time_when_considered_hung_ = Time();
   RendererIsResponsive();
   // We do not bother to stop the hung_renderer_timer_ here in case it will be
   // started again shortly, which happens to be the common use case.
 }
 
-void RenderWidgetHost::ForwardMouseEvent(const WebMouseEvent& mouse_event) {
-  TRACE_EVENT2("renderer_host", "RenderWidgetHost::ForwardMouseEvent",
+void RenderWidgetHostImpl::ForwardMouseEvent(const WebMouseEvent& mouse_event) {
+  TRACE_EVENT2("renderer_host", "RenderWidgetHostImpl::ForwardMouseEvent",
                "x", mouse_event.x, "y", mouse_event.y);
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
@@ -593,12 +618,12 @@ void RenderWidgetHost::ForwardMouseEvent(const WebMouseEvent& mouse_event) {
   ForwardInputEvent(mouse_event, sizeof(WebMouseEvent), false);
 }
 
-void RenderWidgetHost::OnMouseActivate() {
+void RenderWidgetHostImpl::OnMouseActivate() {
 }
 
-void RenderWidgetHost::ForwardWheelEvent(
+void RenderWidgetHostImpl::ForwardWheelEvent(
     const WebMouseWheelEvent& wheel_event) {
-  TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardWheelEvent");
+  TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardWheelEvent");
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
@@ -633,18 +658,18 @@ void RenderWidgetHost::ForwardWheelEvent(
   ForwardInputEvent(wheel_event, sizeof(WebMouseWheelEvent), false);
 }
 
-void RenderWidgetHost::ForwardGestureEvent(
+void RenderWidgetHostImpl::ForwardGestureEvent(
     const WebKit::WebGestureEvent& gesture_event) {
-  TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardGestureEvent");
+  TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardGestureEvent");
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
   ForwardInputEvent(gesture_event, sizeof(WebGestureEvent), false);
 }
 
-void RenderWidgetHost::ForwardKeyboardEvent(
+void RenderWidgetHostImpl::ForwardKeyboardEvent(
     const NativeWebKeyboardEvent& key_event) {
-  TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardKeyboardEvent");
+  TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardKeyboardEvent");
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
@@ -703,10 +728,10 @@ void RenderWidgetHost::ForwardKeyboardEvent(
   }
 }
 
-void RenderWidgetHost::ForwardInputEvent(const WebInputEvent& input_event,
-                                         int event_size,
-                                         bool is_keyboard_shortcut) {
-  TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardInputEvent");
+void RenderWidgetHostImpl::ForwardInputEvent(const WebInputEvent& input_event,
+                                             int event_size,
+                                             bool is_keyboard_shortcut) {
+  TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardInputEvent");
 
   if (!process_->HasConnection())
     return;
@@ -736,9 +761,9 @@ void RenderWidgetHost::ForwardInputEvent(const WebInputEvent& input_event,
       TimeDelta::FromMilliseconds(hung_renderer_delay_ms_));
 }
 
-void RenderWidgetHost::ForwardTouchEvent(
+void RenderWidgetHostImpl::ForwardTouchEvent(
     const WebKit::WebTouchEvent& touch_event) {
-  TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardTouchEvent");
+  TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardTouchEvent");
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
@@ -746,8 +771,8 @@ void RenderWidgetHost::ForwardTouchEvent(
   ForwardInputEvent(touch_event, sizeof(WebKit::WebTouchEvent), false);
 }
 
-void RenderWidgetHost::RendererExited(base::TerminationStatus status,
-                                      int exit_code) {
+void RenderWidgetHostImpl::RendererExited(base::TerminationStatus status,
+                                          int exit_code) {
   // Clearing this flag causes us to re-create the renderer when recovering
   // from a crashed renderer.
   renderer_initialized_ = false;
@@ -785,17 +810,17 @@ void RenderWidgetHost::RendererExited(base::TerminationStatus status,
   BackingStoreManager::RemoveBackingStore(this);
 }
 
-void RenderWidgetHost::UpdateTextDirection(WebTextDirection direction) {
+void RenderWidgetHostImpl::UpdateTextDirection(WebTextDirection direction) {
   text_direction_updated_ = true;
   text_direction_ = direction;
 }
 
-void RenderWidgetHost::CancelUpdateTextDirection() {
+void RenderWidgetHostImpl::CancelUpdateTextDirection() {
   if (text_direction_updated_)
     text_direction_canceled_ = true;
 }
 
-void RenderWidgetHost::NotifyTextDirection() {
+void RenderWidgetHostImpl::NotifyTextDirection() {
   if (text_direction_updated_) {
     if (!text_direction_canceled_)
       Send(new ViewMsg_SetTextDirection(routing_id(), text_direction_));
@@ -804,11 +829,11 @@ void RenderWidgetHost::NotifyTextDirection() {
   }
 }
 
-void RenderWidgetHost::SetInputMethodActive(bool activate) {
+void RenderWidgetHostImpl::SetInputMethodActive(bool activate) {
   Send(new ViewMsg_SetInputMethodActive(routing_id(), activate));
 }
 
-void RenderWidgetHost::ImeSetComposition(
+void RenderWidgetHostImpl::ImeSetComposition(
     const string16& text,
     const std::vector<WebKit::WebCompositionUnderline>& underlines,
     int selection_start,
@@ -817,36 +842,36 @@ void RenderWidgetHost::ImeSetComposition(
             routing_id(), text, underlines, selection_start, selection_end));
 }
 
-void RenderWidgetHost::ImeConfirmComposition(const string16& text) {
+void RenderWidgetHostImpl::ImeConfirmComposition(const string16& text) {
   ImeConfirmComposition(text, ui::Range::InvalidRange());
 }
 
-void RenderWidgetHost::ImeConfirmComposition(
+void RenderWidgetHostImpl::ImeConfirmComposition(
     const string16& text, const ui::Range& replacement_range) {
   Send(new ViewMsg_ImeConfirmComposition(
         routing_id(), text, replacement_range));
 }
 
-void RenderWidgetHost::ImeConfirmComposition() {
+void RenderWidgetHostImpl::ImeConfirmComposition() {
   ImeConfirmComposition(string16());
 }
 
-void RenderWidgetHost::ImeCancelComposition() {
+void RenderWidgetHostImpl::ImeCancelComposition() {
   Send(new ViewMsg_ImeSetComposition(routing_id(), string16(),
             std::vector<WebKit::WebCompositionUnderline>(), 0, 0));
 }
 
-gfx::Rect RenderWidgetHost::GetRootWindowResizerRect() const {
+gfx::Rect RenderWidgetHostImpl::GetRootWindowResizerRect() const {
   return gfx::Rect();
 }
 
-void RenderWidgetHost::RequestToLockMouse() {
+void RenderWidgetHostImpl::RequestToLockMouse() {
   // Directly reject to lock the mouse. Subclass can override this method to
   // decide whether to allow mouse lock or not.
   GotResponseToLockMouseRequest(false);
 }
 
-void RenderWidgetHost::RejectMouseLockOrUnlockIfNecessary() {
+void RenderWidgetHostImpl::RejectMouseLockOrUnlockIfNecessary() {
   DCHECK(!pending_mouse_lock_request_ || !IsMouseLocked());
   if (pending_mouse_lock_request_) {
     pending_mouse_lock_request_ = false;
@@ -856,15 +881,15 @@ void RenderWidgetHost::RejectMouseLockOrUnlockIfNecessary() {
   }
 }
 
-bool RenderWidgetHost::IsMouseLocked() const {
+bool RenderWidgetHostImpl::IsMouseLocked() const {
   return view_ ? view_->IsMouseLocked() : false;
 }
 
-bool RenderWidgetHost::IsFullscreen() const {
+bool RenderWidgetHostImpl::IsFullscreen() const {
   return false;
 }
 
-void RenderWidgetHost::SetShouldAutoResize(bool enable) {
+void RenderWidgetHostImpl::SetShouldAutoResize(bool enable) {
   // Note if this switches from true to false then one has to verify that the
   // mechanics about all the messaging works. For example, what happens to a
   // update message rect that was in progress from the render widget. Perhaps,
@@ -878,10 +903,10 @@ void RenderWidgetHost::SetShouldAutoResize(bool enable) {
   should_auto_resize_ = true;
 }
 
-void RenderWidgetHost::Destroy() {
+void RenderWidgetHostImpl::Destroy() {
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
-      content::Source<RenderWidgetHost>(this),
+      content::Source<RenderWidgetHostImpl>(this),
       content::NotificationService::NoDetails());
 
   // Tell the view to die.
@@ -894,7 +919,7 @@ void RenderWidgetHost::Destroy() {
   delete this;
 }
 
-void RenderWidgetHost::CheckRendererIsUnresponsive() {
+void RenderWidgetHostImpl::CheckRendererIsUnresponsive() {
   // If we received a call to StopHangMonitorTimeout.
   if (time_when_considered_hung_.is_null())
     return;
@@ -909,35 +934,35 @@ void RenderWidgetHost::CheckRendererIsUnresponsive() {
   // OK, looks like we have a hung renderer!
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDERER_PROCESS_HANG,
-      content::Source<RenderWidgetHost>(this),
+      content::Source<RenderWidgetHostImpl>(this),
       content::NotificationService::NoDetails());
   is_unresponsive_ = true;
   NotifyRendererUnresponsive();
 }
 
-void RenderWidgetHost::RendererIsResponsive() {
+void RenderWidgetHostImpl::RendererIsResponsive() {
   if (is_unresponsive_) {
     is_unresponsive_ = false;
     NotifyRendererResponsive();
   }
 }
 
-void RenderWidgetHost::OnMsgRenderViewReady() {
+void RenderWidgetHostImpl::OnMsgRenderViewReady() {
   WasResized();
 }
 
-void RenderWidgetHost::OnMsgRenderViewGone(int status, int exit_code) {
+void RenderWidgetHostImpl::OnMsgRenderViewGone(int status, int exit_code) {
   // TODO(evanm): This synchronously ends up calling "delete this".
   // Is that really what we want in response to this message?  I'm matching
   // previous behavior of the code here.
   Destroy();
 }
 
-void RenderWidgetHost::OnMsgClose() {
+void RenderWidgetHostImpl::OnMsgClose() {
   Shutdown();
 }
 
-void RenderWidgetHost::OnMsgSetTooltipText(
+void RenderWidgetHostImpl::OnMsgSetTooltipText(
     const string16& tooltip_text,
     WebTextDirection text_direction_hint) {
   // First, add directionality marks around tooltip text if necessary.
@@ -969,7 +994,7 @@ void RenderWidgetHost::OnMsgSetTooltipText(
     view_->SetTooltipText(wrapped_tooltip_text);
 }
 
-void RenderWidgetHost::OnMsgRequestMove(const gfx::Rect& pos) {
+void RenderWidgetHostImpl::OnMsgRequestMove(const gfx::Rect& pos) {
   // Note that we ignore the position.
   if (view_) {
     view_->SetBounds(pos);
@@ -977,18 +1002,18 @@ void RenderWidgetHost::OnMsgRequestMove(const gfx::Rect& pos) {
   }
 }
 
-void RenderWidgetHost::OnMsgPaintAtSizeAck(int tag, const gfx::Size& size) {
+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<RenderWidgetHost>(this),
+      content::Source<RenderWidgetHostImpl>(this),
       content::Details<PaintAtSizeAckDetails>(&details));
 }
 
-void RenderWidgetHost::OnMsgUpdateRect(
+void RenderWidgetHostImpl::OnMsgUpdateRect(
     const ViewHostMsg_UpdateRect_Params& params) {
-  TRACE_EVENT0("renderer_host", "RenderWidgetHost::OnMsgUpdateRect");
+  TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::OnMsgUpdateRect");
   TimeTicks paint_start = TimeTicks::Now();
 
   // Update our knowledge of the RenderWidget's size.
@@ -1056,7 +1081,7 @@ void RenderWidgetHost::OnMsgUpdateRect(
             params.bitmap_rect,
             params.copy_rects,
             params.view_size,
-            base::Bind(&RenderWidgetHost::DidUpdateBackingStore,
+            base::Bind(&RenderWidgetHostImpl::DidUpdateBackingStore,
                        weak_factory_.GetWeakPtr(), params, paint_start));
       }
     }
@@ -1077,14 +1102,14 @@ void RenderWidgetHost::OnMsgUpdateRect(
   UMA_HISTOGRAM_TIMES("MPArch.RWH_OnMsgUpdateRect", delta);
 }
 
-void RenderWidgetHost::OnMsgUpdateIsDelayed() {
+void RenderWidgetHostImpl::OnMsgUpdateIsDelayed() {
   // Nothing to do, this message was just to unblock the UI thread.
 }
 
-void RenderWidgetHost::DidUpdateBackingStore(
+void RenderWidgetHostImpl::DidUpdateBackingStore(
     const ViewHostMsg_UpdateRect_Params& params,
     const TimeTicks& paint_start) {
-  TRACE_EVENT0("renderer_host", "RenderWidgetHost::DidUpdateBackingStore");
+  TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::DidUpdateBackingStore");
   TimeTicks update_start = TimeTicks::Now();
 
   if (params.needs_ack) {
@@ -1119,7 +1144,7 @@ void RenderWidgetHost::DidUpdateBackingStore(
 
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT,
-      content::Source<RenderWidgetHost>(this),
+      content::Source<RenderWidgetHostImpl>(this),
       content::NotificationService::NoDetails());
 
   // If we got a resize ack, then perhaps we have another resize to send?
@@ -1147,9 +1172,9 @@ void RenderWidgetHost::DidUpdateBackingStore(
   UMA_HISTOGRAM_TIMES("MPArch.RWH_TotalPaintTime", delta);
 }
 
-void RenderWidgetHost::OnMsgInputEventAck(WebInputEvent::Type event_type,
+void RenderWidgetHostImpl::OnMsgInputEventAck(WebInputEvent::Type event_type,
                                           bool processed) {
-  TRACE_EVENT0("renderer_host", "RenderWidgetHost::OnMsgInputEventAck");
+  TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::OnMsgInputEventAck");
 
   // Log the time delta for processing an input event.
   TimeDelta delta = TimeTicks::Now() - input_event_start_time_;
@@ -1181,11 +1206,11 @@ void RenderWidgetHost::OnMsgInputEventAck(WebInputEvent::Type event_type,
   // This is used only for testing.
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_INPUT_EVENT_ACK,
-      content::Source<RenderWidgetHost>(this),
+      content::Source<RenderWidgetHostImpl>(this),
       content::Details<int>(&type));
 }
 
-void RenderWidgetHost::ProcessWheelAck(bool processed) {
+void RenderWidgetHostImpl::ProcessWheelAck(bool processed) {
   mouse_wheel_pending_ = false;
 
   // Now send the next (coalesced) mouse wheel event.
@@ -1200,61 +1225,63 @@ void RenderWidgetHost::ProcessWheelAck(bool processed) {
     view_->UnhandledWheelEvent(current_wheel_event_);
 }
 
-void RenderWidgetHost::ProcessTouchAck(bool processed) {
+void RenderWidgetHostImpl::ProcessTouchAck(bool processed) {
   if (view_)
     view_->ProcessTouchAck(processed);
 }
 
-void RenderWidgetHost::OnMsgFocus() {
+void RenderWidgetHostImpl::OnMsgFocus() {
   // Only RenderViewHost can deal with that message.
   content::RecordAction(UserMetricsAction("BadMessageTerminate_RWH4"));
   process()->ReceivedBadMessage();
 }
 
-void RenderWidgetHost::OnMsgBlur() {
+void RenderWidgetHostImpl::OnMsgBlur() {
   // Only RenderViewHost can deal with that message.
   content::RecordAction(UserMetricsAction("BadMessageTerminate_RWH5"));
   process()->ReceivedBadMessage();
 }
 
-void RenderWidgetHost::OnMsgDidChangeNumTouchEvents(int count) {
+void RenderWidgetHostImpl::OnMsgDidChangeNumTouchEvents(int count) {
   has_touch_handler_ = count > 0;
 }
 
-void RenderWidgetHost::OnMsgSetCursor(const WebCursor& cursor) {
+void RenderWidgetHostImpl::OnMsgSetCursor(const WebCursor& cursor) {
   if (!view_) {
     return;
   }
   view_->UpdateCursor(cursor);
 }
 
-void RenderWidgetHost::OnMsgTextInputStateChanged(
+void RenderWidgetHostImpl::OnMsgTextInputStateChanged(
     ui::TextInputType type,
     bool can_compose_inline) {
   if (view_)
     view_->TextInputStateChanged(type, can_compose_inline);
 }
 
-void RenderWidgetHost::OnMsgImeCompositionRangeChanged(const ui::Range& range) {
+void RenderWidgetHostImpl::OnMsgImeCompositionRangeChanged(
+    const ui::Range& range) {
   if (view_)
     view_->ImeCompositionRangeChanged(range);
 }
 
-void RenderWidgetHost::OnMsgImeCancelComposition() {
+void RenderWidgetHostImpl::OnMsgImeCancelComposition() {
   if (view_)
     view_->ImeCancelComposition();
 }
 
-void RenderWidgetHost::OnMsgDidActivateAcceleratedCompositing(bool activated) {
+void RenderWidgetHostImpl::OnMsgDidActivateAcceleratedCompositing(
+    bool activated) {
   TRACE_EVENT1("renderer_host",
-               "RenderWidgetHost::OnMsgDidActivateAcceleratedCompositing",
+               "RenderWidgetHostImpl::OnMsgDidActivateAcceleratedCompositing",
                "activated", activated);
   is_accelerated_compositing_active_ = activated;
   if (view_)
     view_->OnAcceleratedCompositingStateChange();
 }
 
-void RenderWidgetHost::OnMsgLockMouse() {
+void RenderWidgetHostImpl::OnMsgLockMouse() {
   if (pending_mouse_lock_request_) {
     Send(new ViewMsg_LockMouse_ACK(routing_id_, false));
     return;
@@ -1267,12 +1294,12 @@ void RenderWidgetHost::OnMsgLockMouse() {
   RequestToLockMouse();
 }
 
-void RenderWidgetHost::OnMsgUnlockMouse() {
+void RenderWidgetHostImpl::OnMsgUnlockMouse() {
   RejectMouseLockOrUnlockIfNecessary();
 }
 
 #if defined(OS_POSIX) || defined(USE_AURA)
-void RenderWidgetHost::OnMsgGetScreenInfo(gfx::NativeViewId window_id,
+void RenderWidgetHostImpl::OnMsgGetScreenInfo(gfx::NativeViewId window_id,
                                           WebKit::WebScreenInfo* results) {
   if (view_)
     view_->GetScreenInfo(results);
@@ -1280,20 +1307,20 @@ void RenderWidgetHost::OnMsgGetScreenInfo(gfx::NativeViewId window_id,
     RenderWidgetHostViewPort::GetDefaultScreenInfo(results);
 }
 
-void RenderWidgetHost::OnMsgGetWindowRect(gfx::NativeViewId window_id,
-                                          gfx::Rect* results) {
+void RenderWidgetHostImpl::OnMsgGetWindowRect(gfx::NativeViewId window_id,
+                                              gfx::Rect* results) {
   if (view_)
     *results = view_->GetViewBounds();
 }
 
-void RenderWidgetHost::OnMsgGetRootWindowRect(gfx::NativeViewId window_id,
+void RenderWidgetHostImpl::OnMsgGetRootWindowRect(gfx::NativeViewId window_id,
                                               gfx::Rect* results) {
   if (view_)
     *results = view_->GetRootWindowBounds();
 }
 #endif
 
-bool RenderWidgetHost::PaintBackingStoreRect(
+bool RenderWidgetHostImpl::PaintBackingStoreRect(
     TransportDIB::Id bitmap,
     const gfx::Rect& bitmap_rect,
     const std::vector<gfx::Rect>& copy_rects,
@@ -1326,9 +1353,9 @@ bool RenderWidgetHost::PaintBackingStoreRect(
   return scheduled_completion_callback;
 }
 
-void RenderWidgetHost::ScrollBackingStoreRect(int dx, int dy,
-                                              const gfx::Rect& clip_rect,
-                                              const gfx::Size& view_size) {
+void RenderWidgetHostImpl::ScrollBackingStoreRect(int dx, int dy,
+                                                  const gfx::Rect& clip_rect,
+                                                  const gfx::Size& view_size) {
   if (is_hidden_) {
     // Don't bother updating the backing store when we're hidden. Just mark it
     // as being totally invalid. This will cause a complete repaint when the
@@ -1346,11 +1373,11 @@ void RenderWidgetHost::ScrollBackingStoreRect(int dx, int dy,
   backing_store->ScrollBackingStore(dx, dy, clip_rect, view_size);
 }
 
-void RenderWidgetHost::Replace(const string16& word) {
+void RenderWidgetHostImpl::Replace(const string16& word) {
   Send(new ViewMsg_Replace(routing_id_, word));
 }
 
-void RenderWidgetHost::EnableRendererAccessibility() {
+void RenderWidgetHostImpl::EnableRendererAccessibility() {
   if (renderer_accessible_)
     return;
 
@@ -1367,7 +1394,7 @@ void RenderWidgetHost::EnableRendererAccessibility() {
   }
 }
 
-void RenderWidgetHost::ProcessKeyboardEventAck(int type, bool processed) {
+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!";
@@ -1395,14 +1422,14 @@ void RenderWidgetHost::ProcessKeyboardEventAck(int type, bool processed) {
     if (!processed && !is_hidden_ && !front_item.skip_in_browser) {
       UnhandledKeyboardEvent(front_item);
 
-      // WARNING: This RenderWidgetHost can be deallocated at this point
+      // WARNING: This RenderWidgetHostImpl can be deallocated at this point
       // (i.e.  in the case of Ctrl+W, where the call to
-      // UnhandledKeyboardEvent destroys this RenderWidgetHost).
+      // UnhandledKeyboardEvent destroys this RenderWidgetHostImpl).
     }
   }
 }
 
-void RenderWidgetHost::ActivateDeferredPluginHandles() {
+void RenderWidgetHostImpl::ActivateDeferredPluginHandles() {
 #if !defined(USE_AURA)
   if (view_ == NULL)
     return;
@@ -1417,85 +1444,85 @@ void RenderWidgetHost::ActivateDeferredPluginHandles() {
 #endif
 }
 
-void RenderWidgetHost::StartUserGesture() {
+void RenderWidgetHostImpl::StartUserGesture() {
   OnUserGesture();
 }
 
-void RenderWidgetHost::Stop() {
+void RenderWidgetHostImpl::Stop() {
   Send(new ViewMsg_Stop(routing_id()));
 }
 
-void RenderWidgetHost::SetBackground(const SkBitmap& background) {
+void RenderWidgetHostImpl::SetBackground(const SkBitmap& background) {
   Send(new ViewMsg_SetBackground(routing_id(), background));
 }
 
-void RenderWidgetHost::SetEditCommandsForNextKeyEvent(
+void RenderWidgetHostImpl::SetEditCommandsForNextKeyEvent(
     const std::vector<EditCommand>& commands) {
   Send(new ViewMsg_SetEditCommandsForNextKeyEvent(routing_id(), commands));
 }
 
-void RenderWidgetHost::AccessibilityDoDefaultAction(int object_id) {
+void RenderWidgetHostImpl::AccessibilityDoDefaultAction(int object_id) {
   Send(new AccessibilityMsg_DoDefaultAction(routing_id(), object_id));
 }
 
-void RenderWidgetHost::AccessibilitySetFocus(int object_id) {
+void RenderWidgetHostImpl::AccessibilitySetFocus(int object_id) {
   Send(new AccessibilityMsg_SetFocus(routing_id(), object_id));
 }
 
-void RenderWidgetHost::AccessibilityScrollToMakeVisible(
+void RenderWidgetHostImpl::AccessibilityScrollToMakeVisible(
     int acc_obj_id, gfx::Rect subfocus) {
   Send(new AccessibilityMsg_ScrollToMakeVisible(
       routing_id(), acc_obj_id, subfocus));
 }
 
-void RenderWidgetHost::AccessibilityScrollToPoint(
+void RenderWidgetHostImpl::AccessibilityScrollToPoint(
     int acc_obj_id, gfx::Point point) {
   Send(new AccessibilityMsg_ScrollToPoint(
       routing_id(), acc_obj_id, point));
 }
 
-void RenderWidgetHost::AccessibilitySetTextSelection(
+void RenderWidgetHostImpl::AccessibilitySetTextSelection(
     int object_id, int start_offset, int end_offset) {
   Send(new AccessibilityMsg_SetTextSelection(
       routing_id(), object_id, start_offset, end_offset));
 }
 
-void RenderWidgetHost::ExecuteEditCommand(const std::string& command,
-                                          const std::string& value) {
+void RenderWidgetHostImpl::ExecuteEditCommand(const std::string& command,
+                                              const std::string& value) {
   Send(new ViewMsg_ExecuteEditCommand(routing_id(), command, value));
 }
 
-void RenderWidgetHost::ScrollFocusedEditableNodeIntoRect(
+void RenderWidgetHostImpl::ScrollFocusedEditableNodeIntoRect(
     const gfx::Rect& rect) {
   Send(new ViewMsg_ScrollFocusedEditableNodeIntoRect(routing_id(), rect));
 }
 
-void RenderWidgetHost::SelectRange(const gfx::Point& start,
-                                   const gfx::Point& end) {
+void RenderWidgetHostImpl::SelectRange(const gfx::Point& start,
+                                       const gfx::Point& end) {
   Send(new ViewMsg_SelectRange(routing_id(), start, end));
 }
 
-void RenderWidgetHost::Undo() {
+void RenderWidgetHostImpl::Undo() {
   Send(new ViewMsg_Undo(routing_id()));
   content::RecordAction(UserMetricsAction("Undo"));
 }
 
-void RenderWidgetHost::Redo() {
+void RenderWidgetHostImpl::Redo() {
   Send(new ViewMsg_Redo(routing_id()));
   content::RecordAction(UserMetricsAction("Redo"));
 }
 
-void RenderWidgetHost::Cut() {
+void RenderWidgetHostImpl::Cut() {
   Send(new ViewMsg_Cut(routing_id()));
   content::RecordAction(UserMetricsAction("Cut"));
 }
 
-void RenderWidgetHost::Copy() {
+void RenderWidgetHostImpl::Copy() {
   Send(new ViewMsg_Copy(routing_id()));
   content::RecordAction(UserMetricsAction("Copy"));
 }
 
-void RenderWidgetHost::CopyToFindPboard() {
+void RenderWidgetHostImpl::CopyToFindPboard() {
 #if defined(OS_MACOSX)
   // Windows/Linux don't have the concept of a find pasteboard.
   Send(new ViewMsg_CopyToFindPboard(routing_id()));
@@ -1503,26 +1530,26 @@ void RenderWidgetHost::CopyToFindPboard() {
 #endif
 }
 
-void RenderWidgetHost::Paste() {
+void RenderWidgetHostImpl::Paste() {
   Send(new ViewMsg_Paste(routing_id()));
   content::RecordAction(UserMetricsAction("Paste"));
 }
 
-void RenderWidgetHost::PasteAndMatchStyle() {
+void RenderWidgetHostImpl::PasteAndMatchStyle() {
   Send(new ViewMsg_PasteAndMatchStyle(routing_id()));
   content::RecordAction(UserMetricsAction("PasteAndMatchStyle"));
 }
 
-void RenderWidgetHost::Delete() {
+void RenderWidgetHostImpl::Delete() {
   Send(new ViewMsg_Delete(routing_id()));
   content::RecordAction(UserMetricsAction("DeleteSelection"));
 }
 
-void RenderWidgetHost::SelectAll() {
+void RenderWidgetHostImpl::SelectAll() {
   Send(new ViewMsg_SelectAll(routing_id()));
   content::RecordAction(UserMetricsAction("SelectAll"));
 }
-bool RenderWidgetHost::GotResponseToLockMouseRequest(bool allowed) {
+bool RenderWidgetHostImpl::GotResponseToLockMouseRequest(bool allowed) {
   if (!allowed) {
     RejectMouseLockOrUnlockIfNecessary();
     return false;
@@ -1545,15 +1572,16 @@ bool RenderWidgetHost::GotResponseToLockMouseRequest(bool allowed) {
 }
 
 // static
-void RenderWidgetHost::AcknowledgeSwapBuffers(int32 route_id, int gpu_host_id) {
+void RenderWidgetHostImpl::AcknowledgeSwapBuffers(int32 route_id,
+                                                  int gpu_host_id) {
   GpuProcessHostUIShim* ui_shim = GpuProcessHostUIShim::FromID(gpu_host_id);
   if (ui_shim)
     ui_shim->Send(new AcceleratedSurfaceMsg_BuffersSwappedACK(route_id));
 }
 
 // static
-void RenderWidgetHost::AcknowledgePostSubBuffer(int32 route_id,
-                                                int gpu_host_id) {
+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));
diff --git a/content/browser/renderer_host/render_widget_host.h b/content/browser/renderer_host/render_widget_host.h
index 6c8f084..31fb45e 100644
--- a/content/browser/renderer_host/render_widget_host.h
+++ b/content/browser/renderer_host/render_widget_host.h
@@ -31,7 +31,7 @@
 
 class BackingStore;
 struct EditCommand;
-class RenderWidgetHostViewBase;
+class RenderViewHost;
 class TransportDIB;
 struct ViewHostMsg_UpdateRect_Params;
 class WebCursor;
@@ -61,6 +61,87 @@ struct WebCompositionUnderline;
 struct WebScreenInfo;
 }
 
+// TODO(joi): Extract relevant bit of class documentation from
+// RenderWidgetHostImpl documentation.  TODO(joi): Move to
+// content/public/browser/render_widget_host.h
+//
+// TODO(joi): Once I finish defining this interface (once
+// RenderViewHost interface is also in place), group together
+// implementation functions in subclasses.
+class CONTENT_EXPORT RenderWidgetHost {
+ public:
+  explicit RenderWidgetHost(content::RenderProcessHost* process);
+  virtual ~RenderWidgetHost() {}
+
+  // Used as the details object for a
+  // RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK notification.
+  // TODO(joi): Switch out for a std::pair.
+  struct PaintAtSizeAckDetails {
+    // The tag that was passed to the PaintAtSize() call that triggered this
+    // ack.
+    int tag;
+    gfx::Size size;
+  };
+
+  // This tells the renderer to paint into a bitmap and return it,
+  // regardless of whether the tab is hidden or not.  It resizes the
+  // web widget to match the |page_size| and then returns the bitmap
+  // scaled so it matches the |desired_size|, so that the scaling
+  // happens on the rendering thread.  When the bitmap is ready, the
+  // renderer sends a PaintAtSizeACK to this host, and a
+  // RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK notification is issued.
+  // Note that this bypasses most of the update logic that is normally invoked,
+  // and doesn't put the results into the backing store.
+  virtual void PaintAtSize(TransportDIB::Handle dib_handle,
+                           int tag,
+                           const gfx::Size& page_size,
+                           const gfx::Size& desired_size) = 0;
+
+  // Get access to the widget's backing store.  If a resize is in progress,
+  // then the current size of the backing store may be less than the size of
+  // the widget's view.  If you pass |force_create| as true, then the backing
+  // store will be created if it doesn't exist. Otherwise, NULL will be returned
+  // if the backing store doesn't already exist. It will also return NULL if the
+  // backing store could not be created.
+  virtual BackingStore* GetBackingStore(bool force_create) = 0;
+
+  // Returns true if this is a RenderViewHost, false if not.
+  virtual bool IsRenderView() const = 0;
+
+  // Called to notify the RenderWidget that it has been resized.
+  virtual void WasResized() = 0;
+
+  // TODO(joi): Get rid of these inline accessors and the associated
+  // data from the interface, make them into pure virtual GetFoo
+  // methods instead.
+  content::RenderProcessHost* process() const { return process_; }
+
+  // Gets the View of this RenderWidgetHost. Can be NULL, e.g. if the
+  // RenderWidget is being destroyed or the render process crashed. You should
+  // never cache this pointer since it can become NULL if the renderer crashes,
+  // instead you should always ask for it using the accessor.
+  content::RenderWidgetHostView* view() const;
+
+  // Gets a RenderVidgetHost pointer from an IPC::Channel::Listener pointer.
+  static RenderWidgetHost* FromIPCChannelListener(
+      IPC::Channel::Listener* listener);
+  static const RenderWidgetHost* FromIPCChannelListener(
+      const IPC::Channel::Listener* listener);
+
+ protected:
+  // Created during construction but initialized during Init*(). Therefore, it
+  // is guaranteed never to be NULL, but its channel may be NULL if the
+  // renderer crashed, so you must always check that.
+  content::RenderProcessHost* process_;
+
+  // The View associated with the RenderViewHost. The lifetime of this object
+  // is associated with the lifetime of the Render process. If the Renderer
+  // crashes, its View is destroyed and this pointer becomes NULL, even though
+  // render_view_host_ lives on to load another URL (creating a new View while
+  // doing so).
+  content::RenderWidgetHostViewPort* view_;
+};
+
 // This class manages the browser side of a browser<->renderer HWND connection.
 // The HWND lives in the browser process, and windows events are sent over
 // IPC to the corresponding object in the renderer.  The renderer paints into
@@ -135,31 +216,21 @@ struct WebScreenInfo;
 // anything else. When the view is live, these messages are forwarded to it by
 // the RenderWidgetHost's IPC message map.
 //
-class CONTENT_EXPORT RenderWidgetHost : public IPC::Channel::Listener,
-                                        public IPC::Channel::Sender {
+// TODO(joi): Move to content namespace.
+class CONTENT_EXPORT RenderWidgetHostImpl : public RenderWidgetHost,
+                                            public IPC::Channel::Listener,
+                                            public IPC::Channel::Sender {
  public:
-  // Used as the details object for a
-  // RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK notification.
-  struct PaintAtSizeAckDetails {
-    // The tag that was passed to the PaintAtSize() call that triggered this
-    // ack.
-    int tag;
-    gfx::Size size;
-  };
-
   // routing_id can be MSG_ROUTING_NONE, in which case the next available
   // routing id is taken from the RenderProcessHost.
-  RenderWidgetHost(content::RenderProcessHost* process, int routing_id);
-  virtual ~RenderWidgetHost();
+  RenderWidgetHostImpl(content::RenderProcessHost* process, int routing_id);
+  virtual ~RenderWidgetHostImpl();
 
-  // Gets/Sets the View of this RenderWidgetHost. Can be NULL, e.g. if the
-  // RenderWidget is being destroyed or the render process crashed. You should
-  // never cache this pointer since it can become NULL if the renderer crashes,
-  // instead you should always ask for it using the accessor.
+  static RenderWidgetHostImpl* FromRWHV(content::RenderWidgetHostView* rwhv);
+
+  // Sets the View of this RenderWidgetHost.
   void SetView(content::RenderWidgetHostView* view);
-  content::RenderWidgetHostView* view() const;
 
-  content::RenderProcessHost* process() const { return process_; }
   int routing_id() const { return routing_id_; }
   int surface_id() const { return surface_id_; }
   bool renderer_accessible() { return renderer_accessible_; }
@@ -181,7 +252,7 @@ class CONTENT_EXPORT RenderWidgetHost : public IPC::Channel::Listener,
   virtual void Shutdown();
 
   // Manual RTTI FTW. We are not hosting a web page.
-  virtual bool IsRenderView() const;
+  virtual bool IsRenderView() const OVERRIDE;
 
   // IPC::Channel::Listener
   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
@@ -194,8 +265,7 @@ class CONTENT_EXPORT RenderWidgetHost : public IPC::Channel::Listener,
   void WasHidden();
   void WasRestored();
 
-  // Called to notify the RenderWidget that it has been resized.
-  void WasResized();
+  virtual void WasResized() OVERRIDE;
 
   // Called to notify the RenderWidget that the resize rect has changed without
   // the size of the RenderWidget itself changing.
@@ -230,27 +300,12 @@ class CONTENT_EXPORT RenderWidgetHost : public IPC::Channel::Listener,
   // Indicates if the page has finished loading.
   void SetIsLoading(bool is_loading);
 
-  // This tells the renderer to paint into a bitmap and return it,
-  // regardless of whether the tab is hidden or not.  It resizes the
-  // web widget to match the |page_size| and then returns the bitmap
-  // scaled so it matches the |desired_size|, so that the scaling
-  // happens on the rendering thread.  When the bitmap is ready, the
-  // renderer sends a PaintAtSizeACK to this host, and a
-  // RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK notification is issued.
-  // Note that this bypasses most of the update logic that is normally invoked,
-  // and doesn't put the results into the backing store.
-  void PaintAtSize(TransportDIB::Handle dib_handle,
-                   int tag,
-                   const gfx::Size& page_size,
-                   const gfx::Size& desired_size);
+  virtual void PaintAtSize(TransportDIB::Handle dib_handle,
+                           int tag,
+                           const gfx::Size& page_size,
+                           const gfx::Size& desired_size) OVERRIDE;
 
-  // Get access to the widget's backing store.  If a resize is in progress,
-  // then the current size of the backing store may be less than the size of
-  // the widget's view.  If you pass |force_create| as true, then the backing
-  // store will be created if it doesn't exist. Otherwise, NULL will be returned
-  // if the backing store doesn't already exist. It will also return NULL if the
-  // backing store could not be created.
-  BackingStore* GetBackingStore(bool force_create);
+  virtual BackingStore* GetBackingStore(bool force_create) OVERRIDE;
 
   // Allocate a new backing store of the given size. Returns NULL on failure
   // (for example, if we don't currently have a RenderWidgetHostView.)
@@ -544,13 +599,6 @@ class CONTENT_EXPORT RenderWidgetHost : public IPC::Channel::Listener,
   void SetShouldAutoResize(bool enable);
 
  protected:
-  // The View associated with the RenderViewHost. The lifetime of this object
-  // is associated with the lifetime of the Render process. If the Renderer
-  // crashes, its View is destroyed and this pointer becomes NULL, even though
-  // render_view_host_ lives on to load another URL (creating a new View while
-  // doing so).
-  content::RenderWidgetHostViewPort* view_;
-
   // true if a renderer has once been valid. We use this flag to display a sad
   // tab only when we lose our renderer and not if a paint occurs during
   // initialization.
@@ -672,11 +720,6 @@ class CONTENT_EXPORT RenderWidgetHost : public IPC::Channel::Listener,
   // screenreader is detected as it can potentially slow down Chrome.
   bool renderer_accessible_;
 
-  // Created during construction but initialized during Init*(). Therefore, it
-  // is guaranteed never to be NULL, but its channel may be NULL if the
-  // renderer crashed, so you must always check that.
-  content::RenderProcessHost* process_;
-
   // Stores random bits of data for others to associate with this object.
   base::PropertyBag property_bag_;
 
@@ -760,7 +803,7 @@ class CONTENT_EXPORT RenderWidgetHost : public IPC::Channel::Listener,
   int in_flight_event_count_;
 
   // This timer runs to check if time_when_considered_hung_ has past.
-  base::OneShotTimer<RenderWidgetHost> hung_renderer_timer_;
+  base::OneShotTimer<RenderWidgetHostImpl> hung_renderer_timer_;
 
   // Flag to detect recursive calls to GetBackingStore().
   bool in_get_backing_store_;
@@ -819,9 +862,9 @@ class CONTENT_EXPORT RenderWidgetHost : public IPC::Channel::Listener,
   // not sent to the renderer.
   bool has_touch_handler_;
 
-  base::WeakPtrFactory<RenderWidgetHost> weak_factory_;
+  base::WeakPtrFactory<RenderWidgetHostImpl> weak_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(RenderWidgetHost);
+  DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostImpl);
 };
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_H_
diff --git a/content/browser/renderer_host/render_widget_host_gtk.cc b/content/browser/renderer_host/render_widget_host_gtk.cc
index 2824b48..cc10a9c 100644
--- a/content/browser/renderer_host/render_widget_host_gtk.cc
+++ b/content/browser/renderer_host/render_widget_host_gtk.cc
@@ -6,7 +6,8 @@
 
 #include "content/port/browser/render_widget_host_view_port.h"
 
-void RenderWidgetHost::OnMsgCreatePluginContainer(gfx::PluginWindowHandle id) {
+void RenderWidgetHostImpl::OnMsgCreatePluginContainer(
+    gfx::PluginWindowHandle id) {
   // TODO(piman): view_ can only be NULL with delayed view creation in
   // extensions (see ExtensionHost::CreateRenderViewSoon). Figure out how to
   // support plugins in that case.
@@ -17,7 +18,8 @@ void RenderWidgetHost::OnMsgCreatePluginContainer(gfx::PluginWindowHandle id) {
   }
 }
 
-void RenderWidgetHost::OnMsgDestroyPluginContainer(gfx::PluginWindowHandle id) {
+void RenderWidgetHostImpl::OnMsgDestroyPluginContainer(
+    gfx::PluginWindowHandle id) {
   if (view_) {
     view_->DestroyPluginContainer(id);
   } else {
diff --git a/content/browser/renderer_host/render_widget_host_mac.cc b/content/browser/renderer_host/render_widget_host_mac.cc
index fa93807..8632623 100644
--- a/content/browser/renderer_host/render_widget_host_mac.cc
+++ b/content/browser/renderer_host/render_widget_host_mac.cc
@@ -6,17 +6,18 @@
 #include "content/common/gpu/gpu_messages.h"
 #include "content/port/browser/render_widget_host_view_port.h"
 
-void RenderWidgetHost::OnMsgPluginFocusChanged(bool focused, int plugin_id) {
+void RenderWidgetHostImpl::OnMsgPluginFocusChanged(bool focused,
+                                                   int plugin_id) {
   if (view_)
     view_->PluginFocusChanged(focused, plugin_id);
 }
 
-void RenderWidgetHost::OnMsgStartPluginIme() {
+void RenderWidgetHostImpl::OnMsgStartPluginIme() {
   if (view_)
     view_->StartPluginIme();
 }
 
-void RenderWidgetHost::OnAllocateFakePluginWindowHandle(
+void RenderWidgetHostImpl::OnAllocateFakePluginWindowHandle(
     bool opaque,
     bool root,
     gfx::PluginWindowHandle* id) {
@@ -29,7 +30,7 @@ void RenderWidgetHost::OnAllocateFakePluginWindowHandle(
   }
 }
 
-void RenderWidgetHost::OnDestroyFakePluginWindowHandle(
+void RenderWidgetHostImpl::OnDestroyFakePluginWindowHandle(
     gfx::PluginWindowHandle id) {
   if (view_) {
     view_->DestroyFakePluginWindowHandle(id);
@@ -38,7 +39,7 @@ void RenderWidgetHost::OnDestroyFakePluginWindowHandle(
   }
 }
 
-void RenderWidgetHost::OnAcceleratedSurfaceSetIOSurface(
+void RenderWidgetHostImpl::OnAcceleratedSurfaceSetIOSurface(
     gfx::PluginWindowHandle window,
     int32 width,
     int32 height,
@@ -48,7 +49,7 @@ void RenderWidgetHost::OnAcceleratedSurfaceSetIOSurface(
   }
 }
 
-void RenderWidgetHost::OnAcceleratedSurfaceSetTransportDIB(
+void RenderWidgetHostImpl::OnAcceleratedSurfaceSetTransportDIB(
     gfx::PluginWindowHandle window,
     int32 width,
     int32 height,
@@ -59,7 +60,7 @@ void RenderWidgetHost::OnAcceleratedSurfaceSetTransportDIB(
   }
 }
 
-void RenderWidgetHost::OnAcceleratedSurfaceBuffersSwapped(
+void RenderWidgetHostImpl::OnAcceleratedSurfaceBuffersSwapped(
     gfx::PluginWindowHandle window, uint64 surface_id) {
   if (view_) {
     // This code path could be updated to implement flow control for
diff --git a/content/browser/renderer_host/render_widget_host_unittest.cc b/content/browser/renderer_host/render_widget_host_unittest.cc
index 2375e7d..6e79111 100644
--- a/content/browser/renderer_host/render_widget_host_unittest.cc
+++ b/content/browser/renderer_host/render_widget_host_unittest.cc
@@ -119,7 +119,7 @@ bool RenderWidgetHostProcess::WaitForUpdateMsg(int render_widget_id,
 // This test view allows us to specify the size.
 class TestView : public content::TestRenderWidgetHostView {
  public:
-  explicit TestView(RenderWidgetHost* rwh)
+  explicit TestView(RenderWidgetHostImpl* rwh)
       : content::TestRenderWidgetHostView(rwh) {
   }
 
@@ -146,10 +146,10 @@ class TestView : public content::TestRenderWidgetHostView {
 
 // MockRenderWidgetHost ----------------------------------------------------
 
-class MockRenderWidgetHost : public RenderWidgetHost {
+class MockRenderWidgetHost : public RenderWidgetHostImpl {
  public:
   MockRenderWidgetHost(content::RenderProcessHost* process, int routing_id)
-      : RenderWidgetHost(process, routing_id),
+      : RenderWidgetHostImpl(process, routing_id),
         prehandle_keyboard_event_(false),
         prehandle_keyboard_event_called_(false),
         prehandle_keyboard_event_type_(WebInputEvent::Undefined),
@@ -220,7 +220,7 @@ class MockRenderWidgetHost : public RenderWidgetHost {
 
 class MockPaintingObserver : public content::NotificationObserver {
  public:
-  void WidgetDidReceivePaintAtSizeAck(RenderWidgetHost* host,
+  void WidgetDidReceivePaintAtSizeAck(RenderWidgetHostImpl* host,
                                       int tag,
                                       const gfx::Size& size) {
     host_ = reinterpret_cast<MockRenderWidgetHost*>(host);
@@ -233,11 +233,11 @@ class MockPaintingObserver : public content::NotificationObserver {
                const content::NotificationDetails& details) {
     if (type ==
         content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK) {
-      RenderWidgetHost::PaintAtSizeAckDetails* size_ack_details =
-          content::Details<RenderWidgetHost::PaintAtSizeAckDetails>(details).
-              ptr();
+      RenderWidgetHostImpl::PaintAtSizeAckDetails* size_ack_details =
+          content::Details<RenderWidgetHostImpl::PaintAtSizeAckDetails>(
+              details).ptr();
       WidgetDidReceivePaintAtSizeAck(
-          content::Source<RenderWidgetHost>(source).ptr(),
+          content::Source<RenderWidgetHostImpl>(source).ptr(),
           size_ack_details->tag,
           size_ack_details->size);
     }
@@ -585,7 +585,7 @@ TEST_F(RenderWidgetHostTest, PaintAtSize) {
   registrar.Add(
       &observer,
       content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
-      content::Source<RenderWidgetHost>(host_.get()));
+      content::Source<RenderWidgetHostImpl>(host_.get()));
 
   host_->OnMsgPaintAtSizeAck(kPaintAtSizeTag, gfx::Size(20, 30));
   EXPECT_EQ(host_.get(), observer.host());
diff --git a/content/browser/renderer_host/render_widget_host_view_aura.cc b/content/browser/renderer_host/render_widget_host_view_aura.cc
index 4d55177..88983f8 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura.cc
+++ b/content/browser/renderer_host/render_widget_host_view_aura.cc
@@ -122,8 +122,7 @@ class RenderWidgetHostViewAura::WindowObserver : public aura::WindowObserver {
 // RenderWidgetHostViewAura, public:
 
 RenderWidgetHostViewAura::RenderWidgetHostViewAura(RenderWidgetHost* host)
-    : host_(host),
-      ALLOW_THIS_IN_INITIALIZER_LIST(window_(new aura::Window(this))),
+    : ALLOW_THIS_IN_INITIALIZER_LIST(window_(new aura::Window(this))),
       is_fullscreen_(false),
       popup_parent_host_view_(NULL),
       popup_child_host_view_(NULL),
@@ -136,6 +135,7 @@ RenderWidgetHostViewAura::RenderWidgetHostViewAura(RenderWidgetHost* host)
 #endif
       paint_canvas_(NULL),
       synthetic_move_sent_(false) {
+  host_ = static_cast<RenderWidgetHostImpl*>(host);
   host_->SetView(this);
   window_observer_.reset(new WindowObserver(this));
   window_->AddObserver(window_observer_.get());
@@ -389,7 +389,7 @@ void RenderWidgetHostViewAura::AcceleratedSurfaceBuffersSwapped(
   if (!compositor) {
     // We have no compositor, so we have no way to display the surface.
     // Must still send the ACK.
-    RenderWidgetHost::AcknowledgeSwapBuffers(params.route_id, gpu_host_id);
+    RenderWidgetHostImpl::AcknowledgeSwapBuffers(params.route_id, gpu_host_id);
   } else {
     gfx::Size surface_size =
         image_transport_clients_[params.surface_handle]->size();
@@ -397,7 +397,7 @@ void RenderWidgetHostViewAura::AcceleratedSurfaceBuffersSwapped(
 
     // Add sending an ACK to the list of things to do OnCompositingEnded
     on_compositing_ended_callbacks_.push_back(
-        base::Bind(&RenderWidgetHost::AcknowledgeSwapBuffers,
+        base::Bind(&RenderWidgetHostImpl::AcknowledgeSwapBuffers,
                    params.route_id, gpu_host_id));
     if (!compositor->HasObserver(this))
       compositor->AddObserver(this);
@@ -418,7 +418,8 @@ void RenderWidgetHostViewAura::AcceleratedSurfacePostSubBuffer(
   if (!compositor) {
     // We have no compositor, so we have no way to display the surface
     // Must still send the ACK
-    RenderWidgetHost::AcknowledgePostSubBuffer(params.route_id, gpu_host_id);
+    RenderWidgetHostImpl::AcknowledgePostSubBuffer(
+        params.route_id, gpu_host_id);
   } else {
     gfx::Size surface_size =
         image_transport_clients_[params.surface_handle]->size();
@@ -433,7 +434,7 @@ void RenderWidgetHostViewAura::AcceleratedSurfacePostSubBuffer(
 
     // Add sending an ACK to the list of things to do OnCompositingEnded
     on_compositing_ended_callbacks_.push_back(
-        base::Bind(&RenderWidgetHost::AcknowledgePostSubBuffer,
+        base::Bind(&RenderWidgetHostImpl::AcknowledgePostSubBuffer,
                    params.route_id, gpu_host_id));
     if (!compositor->HasObserver(this))
       compositor->AddObserver(this);
diff --git a/content/browser/renderer_host/render_widget_host_view_aura.h b/content/browser/renderer_host/render_widget_host_view_aura.h
index 28f339e..6574b81 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura.h
+++ b/content/browser/renderer_host/render_widget_host_view_aura.h
@@ -38,6 +38,7 @@ namespace WebKit {
 class WebTouchEvent;
 }
 
+class RenderWidgetHostImpl;
 #if defined(UI_COMPOSITOR_IMAGE_TRANSPORT)
 class ImageTransportClient;
 #endif
@@ -210,7 +211,7 @@ class RenderWidgetHostViewAura
   ui::Compositor* GetCompositor();
 
   // The model object.
-  RenderWidgetHost* host_;
+  RenderWidgetHostImpl* host_;
 
   aura::Window* window_;
 
diff --git a/content/browser/renderer_host/render_widget_host_view_base.cc b/content/browser/renderer_host/render_widget_host_view_base.cc
index 9fe86f6..8059272 100644
--- a/content/browser/renderer_host/render_widget_host_view_base.cc
+++ b/content/browser/renderer_host/render_widget_host_view_base.cc
@@ -6,6 +6,7 @@
 
 #include "base/logging.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
+#include "content/browser/renderer_host/render_widget_host.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScreenInfo.h"
 
 #if defined(TOOLKIT_USES_GTK)
@@ -54,11 +55,6 @@ BrowserAccessibilityManager*
   return browser_accessibility_manager_.get();
 }
 
-void RenderWidgetHostViewBase::SetBrowserAccessibilityManager(
-    BrowserAccessibilityManager* manager) {
-  browser_accessibility_manager_.reset(manager);
-}
-
 void RenderWidgetHostViewBase::SelectionChanged(const string16& text,
                                                 size_t offset,
                                                 const ui::Range& range) {
@@ -89,4 +85,13 @@ WebKit::WebPopupType RenderWidgetHostViewBase::GetPopupType() {
   return popup_type_;
 }
 
+void RenderWidgetHostViewBase::SetBrowserAccessibilityManager(
+    BrowserAccessibilityManager* manager) {
+  browser_accessibility_manager_.reset(manager);
+}
+
+RenderWidgetHostImpl* RenderWidgetHostViewBase::GetRenderWidgetHostImpl() {
+  return static_cast<RenderWidgetHostImpl*>(GetRenderWidgetHost());
+}
+
 }  // namespace content
diff --git a/content/browser/renderer_host/render_widget_host_view_base.h b/content/browser/renderer_host/render_widget_host_view_base.h
index 5834536..480c9f7 100644
--- a/content/browser/renderer_host/render_widget_host_view_base.h
+++ b/content/browser/renderer_host/render_widget_host_view_base.h
@@ -23,6 +23,8 @@
 #include "content/port/browser/render_widget_host_view_port.h"
 #include "ui/base/range/range.h"
 
+class RenderWidgetHostImpl;
+
 namespace content {
 
 // Basic implementation shared by concrete RenderWidgetHostView
@@ -55,6 +57,8 @@ class CONTENT_EXPORT RenderWidgetHostViewBase
 
   void SetBrowserAccessibilityManager(BrowserAccessibilityManager* manager);
 
+  RenderWidgetHostImpl* GetRenderWidgetHostImpl();
+
  protected:
   // Interface class only, do not construct.
   RenderWidgetHostViewBase();
diff --git a/content/browser/renderer_host/render_widget_host_view_gtk.cc b/content/browser/renderer_host/render_widget_host_view_gtk.cc
index 201e325..2724063 100644
--- a/content/browser/renderer_host/render_widget_host_view_gtk.cc
+++ b/content/browser/renderer_host/render_widget_host_view_gtk.cc
@@ -212,7 +212,7 @@ class RenderWidgetHostViewGtkWidget {
         (host_view->IsPopup() && host_view->NeedsInputGrab()) ||
         host_view->is_fullscreen_;
     if (should_close_on_escape && GDK_Escape == event->keyval) {
-      host_view->host_->Shutdown();
+      static_cast<RenderWidgetHostImpl*>(host_view->host_)->Shutdown();
     } else {
       // Send key event to input method.
       host_view->im_context_->ProcessKeyEvent(event);
@@ -228,8 +228,8 @@ class RenderWidgetHostViewGtkWidget {
                             GdkEventFocus* focus,
                             RenderWidgetHostViewGtk* host_view) {
     host_view->ShowCurrentCursor();
-    host_view->GetRenderWidgetHost()->GotFocus();
-    host_view->GetRenderWidgetHost()->SetActive(true);
+    RenderWidgetHostImpl::FromRWHV(host_view)->GotFocus();
+    RenderWidgetHostImpl::FromRWHV(host_view)->SetActive(true);
 
     // The only way to enable a GtkIMContext object is to call its focus in
     // handler.
@@ -247,8 +247,8 @@ class RenderWidgetHostViewGtkWidget {
     // If we are showing a context menu, maintain the illusion that webkit has
     // focus.
     if (!host_view->IsShowingContextMenu()) {
-      host_view->GetRenderWidgetHost()->SetActive(false);
-      host_view->GetRenderWidgetHost()->Blur();
+      RenderWidgetHostImpl::FromRWHV(host_view)->SetActive(false);
+      RenderWidgetHostImpl::FromRWHV(host_view)->Blur();
     }
 
     // Prevents us from stealing input context focus in OnGrabNotify() handler.
@@ -311,7 +311,8 @@ class RenderWidgetHostViewGtkWidget {
       scroll_event.y_root = event->y_root;
       WebMouseWheelEvent web_event =
           WebInputEventFactory::mouseWheelEvent(&scroll_event);
-      host_view->GetRenderWidgetHost()->ForwardWheelEvent(web_event);
+      RenderWidgetHostImpl::FromRWHV(
+          host_view)->ForwardWheelEvent(web_event);
     }
 #endif
 
@@ -365,7 +366,8 @@ class RenderWidgetHostViewGtkWidget {
       gtk_widget_grab_focus(widget);
 
     host_view->is_popup_first_mouse_release_ = false;
-    RenderWidgetHost* widget_host = host_view->GetRenderWidgetHost();
+    RenderWidgetHostImpl* widget_host =
+        RenderWidgetHostImpl::FromRWHV(host_view);
     if (widget_host)
       widget_host->ForwardMouseEvent(WebInputEventFactory::mouseEvent(event));
 
@@ -409,11 +411,13 @@ class RenderWidgetHostViewGtkWidget {
         GdkScreen* screen = gtk_widget_get_screen(widget);
         gdk_display_warp_pointer(display, screen, center.x(), center.y());
         if (host_view->mouse_has_been_warped_to_new_center_)
-          host_view->GetRenderWidgetHost()->ForwardMouseEvent(mouse_event);
+          RenderWidgetHostImpl::FromRWHV(
+              host_view)->ForwardMouseEvent(mouse_event);
       }
     } else {  // Mouse is not locked.
       host_view->ModifyEventMovementAndCoords(&mouse_event);
-      host_view->GetRenderWidgetHost()->ForwardMouseEvent(mouse_event);
+      RenderWidgetHostImpl::FromRWHV(
+          host_view)->ForwardMouseEvent(mouse_event);
     }
     return FALSE;
   }
@@ -442,7 +446,8 @@ class RenderWidgetHostViewGtkWidget {
       // from the exit to re-entry point.
       mouse_event.movementX = 0;
       mouse_event.movementY = 0;
-      host_view->GetRenderWidgetHost()->ForwardMouseEvent(mouse_event);
+      RenderWidgetHostImpl::FromRWHV(
+          host_view)->ForwardMouseEvent(mouse_event);
     }
 
     return FALSE;
@@ -556,7 +561,7 @@ class RenderWidgetHostViewGtkWidget {
         web_event.deltaX = -GetScrollPixelsPerTick();
       web_event.deltaX += GetPendingScrollDelta(false, event->state);
     }
-    host_view->GetRenderWidgetHost()->ForwardWheelEvent(web_event);
+    RenderWidgetHostImpl::FromRWHV(host_view)->ForwardWheelEvent(web_event);
     return FALSE;
   }
 
@@ -564,8 +569,7 @@ class RenderWidgetHostViewGtkWidget {
 };
 
 RenderWidgetHostViewGtk::RenderWidgetHostViewGtk(RenderWidgetHost* widget_host)
-    : host_(widget_host),
-      about_to_validate_and_paint_(false),
+    : about_to_validate_and_paint_(false),
       is_hidden_(false),
       is_loading_(false),
       parent_(NULL),
@@ -578,6 +582,7 @@ RenderWidgetHostViewGtk::RenderWidgetHostViewGtk(RenderWidgetHost* widget_host)
       dragged_at_vertical_edge_(0),
       compositing_surface_(gfx::kNullPluginWindow),
       last_mouse_down_(NULL) {
+  host_ = static_cast<RenderWidgetHostImpl*>(widget_host);
   host_->SetView(this);
 }
 
@@ -688,7 +693,7 @@ void RenderWidgetHostViewGtk::WasHidden() {
 
   // If we have a renderer, then inform it that we are being hidden so it can
   // reduce its resource utilization.
-  GetRenderWidgetHost()->WasHidden();
+  host_->WasHidden();
 }
 
 void RenderWidgetHostViewGtk::SetSize(const gfx::Size& size) {
@@ -1015,13 +1020,13 @@ BackingStore* RenderWidgetHostViewGtk::AllocBackingStore(
 void RenderWidgetHostViewGtk::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
     int gpu_host_id) {
-  RenderWidgetHost::AcknowledgeSwapBuffers(params.route_id, gpu_host_id);
+  RenderWidgetHostImpl::AcknowledgeSwapBuffers(params.route_id, gpu_host_id);
 }
 
 void RenderWidgetHostViewGtk::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
-  RenderWidgetHost::AcknowledgePostSubBuffer(params.route_id, gpu_host_id);
+  RenderWidgetHostImpl::AcknowledgePostSubBuffer(params.route_id, gpu_host_id);
 }
 
 void RenderWidgetHostViewGtk::AcceleratedSurfaceSuspend() {
@@ -1091,7 +1096,8 @@ void RenderWidgetHostViewGtk::Paint(const gfx::Rect& damage_rect) {
 
   // If the GPU process is rendering directly into the View,
   // call the compositor directly.
-  RenderWidgetHost* render_widget_host = GetRenderWidgetHost();
+  RenderWidgetHostImpl* render_widget_host =
+      static_cast<RenderWidgetHostImpl*>(GetRenderWidgetHost());
   if (render_widget_host->is_accelerated_compositing_active()) {
     host_->ScheduleComposite();
     return;
diff --git a/content/browser/renderer_host/render_widget_host_view_gtk.h b/content/browser/renderer_host/render_widget_host_view_gtk.h
index 3c8a180..564053e 100644
--- a/content/browser/renderer_host/render_widget_host_view_gtk.h
+++ b/content/browser/renderer_host/render_widget_host_view_gtk.h
@@ -27,6 +27,7 @@
 #include "webkit/plugins/npapi/gtk_plugin_container_manager.h"
 
 class RenderWidgetHost;
+class RenderWidgetHostImpl;
 class GtkIMContextWrapper;
 struct NativeWebKeyboardEvent;
 
@@ -184,7 +185,7 @@ class RenderWidgetHostViewGtk : public content::RenderWidgetHostViewBase {
   gfx::Point GetWidgetCenter();
 
   // The model object.
-  RenderWidgetHost* host_;
+  RenderWidgetHostImpl* host_;
 
   // The native UI widget.
   ui::OwnedWidgetGtk view_;
diff --git a/content/browser/renderer_host/render_widget_host_view_mac.h b/content/browser/renderer_host/render_widget_host_view_mac.h
index e0fed94..c6aa5f4 100644
--- a/content/browser/renderer_host/render_widget_host_view_mac.h
+++ b/content/browser/renderer_host/render_widget_host_view_mac.h
@@ -21,6 +21,7 @@
 #include "webkit/glue/webcursor.h"
 
 @class AcceleratedPluginView;
+class RenderWidgetHostImpl;
 class RenderWidgetHostViewMac;
 @protocol RenderWidgetHostViewMacDelegate;
 class RenderWidgetHostViewMacEditCommandHelper;
@@ -308,7 +309,7 @@ class RenderWidgetHostViewMac : public content::RenderWidgetHostViewBase {
 
   // The associated Model.  Can be NULL if Destroy() is called when
   // someone (other than superview) has retained |cocoa_view_|.
-  RenderWidgetHost* render_widget_host_;
+  RenderWidgetHostImpl* render_widget_host_;
 
   // This is true when we are currently painting and thus should handle extra
   // paint requests by expanding the invalid rect rather than actually painting.
diff --git a/content/browser/renderer_host/render_widget_host_view_mac.mm b/content/browser/renderer_host/render_widget_host_view_mac.mm
index 65c37ce..8e0c780 100644
--- a/content/browser/renderer_host/render_widget_host_view_mac.mm
+++ b/content/browser/renderer_host/render_widget_host_view_mac.mm
@@ -26,6 +26,7 @@
 #include "content/browser/renderer_host/backing_store_mac.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host.h"
+#include "content/browser/renderer_host/render_widget_host.h"
 #import "content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper.h"
 #import "content/browser/renderer_host/text_input_client_mac.h"
 #include "content/common/accessibility_messages.h"
@@ -230,8 +231,7 @@ void content::RenderWidgetHostViewPort::GetDefaultScreenInfo(
 // RenderWidgetHostViewMac, public:
 
 RenderWidgetHostViewMac::RenderWidgetHostViewMac(RenderWidgetHost* widget)
-    : render_widget_host_(widget),
-      about_to_validate_and_paint_(false),
+    : about_to_validate_and_paint_(false),
       call_set_needs_display_in_rect_pending_(false),
       last_frame_was_accelerated_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
@@ -241,6 +241,8 @@ RenderWidgetHostViewMac::RenderWidgetHostViewMac(RenderWidgetHost* widget)
       accelerated_compositing_active_(false),
       needs_gpu_visibility_update_after_repaint_(false),
       compositing_surface_(gfx::kNullPluginWindow) {
+  render_widget_host_ = static_cast<RenderWidgetHostImpl*>(widget);
+
   // |cocoa_view_| owns us and we will be deleted when |cocoa_view_|
   // goes away.  Since we autorelease it, our caller must put
   // |GetNativeView()| into the view hierarchy right after calling us.
@@ -897,7 +899,7 @@ void RenderWidgetHostViewMac::AcceleratedSurfaceBuffersSwapped(
   }
 
   if (params.route_id != 0) {
-    RenderWidgetHost::AcknowledgeSwapBuffers(params.route_id, gpu_host_id);
+    RenderWidgetHostImpl::AcknowledgeSwapBuffers(params.route_id, gpu_host_id);
   }
 }
 
@@ -924,7 +926,8 @@ void RenderWidgetHostViewMac::AcceleratedSurfacePostSubBuffer(
   }
 
   if (params.route_id != 0) {
-    RenderWidgetHost::AcknowledgePostSubBuffer(params.route_id, gpu_host_id);
+    RenderWidgetHostImpl::AcknowledgePostSubBuffer(
+        params.route_id, gpu_host_id);
   }
 }
 
@@ -967,7 +970,8 @@ void RenderWidgetHostViewMac::HandleDelayedGpuViewHiding() {
 
 void RenderWidgetHostViewMac::OnAcceleratedCompositingStateChange() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  bool activated = GetRenderWidgetHost()->is_accelerated_compositing_active();
+  bool activated =
+      GetRenderWidgetHostImpl()->is_accelerated_compositing_active();
   bool changed = accelerated_compositing_active_ != activated;
   accelerated_compositing_active_ = activated;
   if (!changed)
@@ -1461,7 +1465,7 @@ void RenderWidgetHostViewMac::SetTextInputActive(bool active) {
   // Don't cancel child popups; the key events are probably what's triggering
   // the popup in the first place.
 
-  RenderWidgetHost* widgetHost = renderWidgetHostView_->render_widget_host_;
+  RenderWidgetHostImpl* widgetHost = renderWidgetHostView_->render_widget_host_;
   DCHECK(widgetHost);
 
   NativeWebKeyboardEvent event(theEvent);
@@ -2034,7 +2038,7 @@ void RenderWidgetHostViewMac::SetTextInputActive(bool active) {
 }
 
 - (void)doDefaultAction:(int32)accessibilityObjectId {
-  RenderWidgetHost* rwh = renderWidgetHostView_->render_widget_host_;
+  RenderWidgetHostImpl* rwh = renderWidgetHostView_->render_widget_host_;
   rwh->Send(new AccessibilityMsg_DoDefaultAction(
       rwh->routing_id(), accessibilityObjectId));
 }
@@ -2055,7 +2059,7 @@ void RenderWidgetHostViewMac::SetTextInputActive(bool active) {
 - (void)setAccessibilityFocus:(BOOL)focus
               accessibilityId:(int32)accessibilityObjectId {
   if (focus) {
-    RenderWidgetHost* rwh = renderWidgetHostView_->render_widget_host_;
+    RenderWidgetHostImpl* rwh = renderWidgetHostView_->render_widget_host_;
     rwh->Send(new AccessibilityMsg_SetFocus(
         rwh->routing_id(), accessibilityObjectId));
   }
@@ -2507,7 +2511,7 @@ extern NSString *NSTextInputReplacementRangeAttributeName;
     if (!StartsWithASCII(command, "insert", false))
       editCommands_.push_back(EditCommand(command, ""));
   } else {
-    RenderWidgetHost* rwh = renderWidgetHostView_->render_widget_host_;
+    RenderWidgetHostImpl* rwh = renderWidgetHostView_->render_widget_host_;
     rwh->Send(new ViewMsg_ExecuteEditCommand(rwh->routing_id(), command, ""));
   }
 }
@@ -2728,14 +2732,14 @@ extern NSString *NSTextInputReplacementRangeAttributeName;
 
 - (void)viewWillStartLiveResize {
   [super viewWillStartLiveResize];
-  RenderWidgetHost* widget = renderWidgetHostView_->render_widget_host_;
+  RenderWidgetHostImpl* widget = renderWidgetHostView_->render_widget_host_;
   if (widget)
     widget->Send(new ViewMsg_SetInLiveResize(widget->routing_id(), true));
 }
 
 - (void)viewDidEndLiveResize {
   [super viewDidEndLiveResize];
-  RenderWidgetHost* widget = renderWidgetHostView_->render_widget_host_;
+  RenderWidgetHostImpl* widget = renderWidgetHostView_->render_widget_host_;
   if (widget)
     widget->Send(new ViewMsg_SetInLiveResize(widget->routing_id(), false));
 }
diff --git a/content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper.mm b/content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper.mm
index 4ad3b76..3d19ced 100644
--- a/content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper.mm
+++ b/content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper.mm
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -138,7 +138,7 @@ void EditCommandImp(id self, SEL _cmd, id sender) {
   DCHECK(rwhv);
 
   // The second parameter is the core command value which isn't used here.
-  RenderWidgetHost* rwh = rwhv->GetRenderWidgetHost();
+  RenderWidgetHostImpl* rwh = RenderWidgetHostImpl::FromRWHV(rwhv);
   rwh->ExecuteEditCommand(command, "");
 }
 
diff --git a/content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper_unittest.mm b/content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper_unittest.mm
index 910b8bc..67738ca 100644
--- a/content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper_unittest.mm
+++ b/content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper_unittest.mm
@@ -69,18 +69,18 @@ namespace {
 }  // namespace
 
 // Create a RenderWidget for which we can filter messages.
-class RenderWidgetHostEditCommandCounter : public RenderWidgetHost {
+class RenderWidgetHostEditCommandCounter : public RenderWidgetHostImpl {
  public:
   RenderWidgetHostEditCommandCounter(content::RenderProcessHost* process,
                                      int routing_id)
-    : RenderWidgetHost(process, routing_id),
+    : RenderWidgetHostImpl(process, routing_id),
       edit_command_message_count_(0) {
   }
 
   virtual bool Send(IPC::Message* message) {
     if (message->type() == ViewMsg_ExecuteEditCommand::ID)
       edit_command_message_count_++;
-    return RenderWidgetHost::Send(message);
+    return RenderWidgetHostImpl::Send(message);
   }
 
   unsigned int edit_command_message_count_;
diff --git a/content/browser/renderer_host/render_widget_host_view_win.cc b/content/browser/renderer_host/render_widget_host_view_win.cc
index 38f504d..6e3c5ec 100644
--- a/content/browser/renderer_host/render_widget_host_view_win.cc
+++ b/content/browser/renderer_host/render_widget_host_view_win.cc
@@ -307,8 +307,7 @@ inline void SetTouchType(TOUCHINPUT* point, int type) {
 // RenderWidgetHostViewWin, public:
 
 RenderWidgetHostViewWin::RenderWidgetHostViewWin(RenderWidgetHost* widget)
-    : render_widget_host_(widget),
-      compositor_host_window_(NULL),
+    : compositor_host_window_(NULL),
       hide_compositor_window_at_next_paint_(false),
       track_mouse_leave_(false),
       ime_notification_(false),
@@ -331,6 +330,7 @@ RenderWidgetHostViewWin::RenderWidgetHostViewWin(RenderWidgetHost* widget)
       focus_on_editable_field_(false),
       received_focus_change_after_pointer_down_(false),
       transparent_region_(0) {
+  render_widget_host_ = static_cast<RenderWidgetHostImpl*>(widget);
   render_widget_host_->SetView(this);
   registrar_.Add(this,
                  content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
diff --git a/content/browser/renderer_host/render_widget_host_view_win.h b/content/browser/renderer_host/render_widget_host_view_win.h
index 419bae2..839fdde 100644
--- a/content/browser/renderer_host/render_widget_host_view_win.h
+++ b/content/browser/renderer_host/render_widget_host_view_win.h
@@ -371,7 +371,7 @@ class RenderWidgetHostViewWin
   // The associated Model.  While |this| is being Destroyed,
   // |render_widget_host_| is NULL and the Windows message loop is run one last
   // time. Message handlers must check for a NULL |render_widget_host_|.
-  RenderWidgetHost* render_widget_host_;
+  RenderWidgetHostImpl* render_widget_host_;
 
   // When we are doing accelerated compositing
   HWND compositor_host_window_;
diff --git a/content/browser/renderer_host/test_render_view_host.cc b/content/browser/renderer_host/test_render_view_host.cc
index 8a529ed..b4272ba 100644
--- a/content/browser/renderer_host/test_render_view_host.cc
+++ b/content/browser/renderer_host/test_render_view_host.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "content/browser/browser_url_handler.h"
+#include "content/browser/renderer_host/backing_store_skia.h"
 #include "content/browser/renderer_host/test_backing_store.h"
 #include "content/browser/renderer_host/test_render_view_host.h"
 #include "content/browser/site_instance_impl.h"
@@ -56,7 +57,7 @@ void SimulateUpdateRect(RenderWidgetHost* widget,
   params.bitmap = bitmap;
 
   ViewHostMsg_UpdateRect msg(1, params);
-  widget->OnMessageReceived(msg);
+  static_cast<RenderWidgetHostImpl*>(widget)->OnMessageReceived(msg);
 }
 
 TestRenderViewHost* TestRenderViewHost::GetPendingForController(
@@ -157,8 +158,8 @@ void TestRenderViewHost::set_contents_mime_type(const std::string& mime_type) {
 namespace content {
 
 TestRenderWidgetHostView::TestRenderWidgetHostView(RenderWidgetHost* rwh)
-    : rwh_(rwh),
-      is_showing_(false) {
+    : is_showing_(false) {
+  rwh_ = static_cast<RenderWidgetHostImpl*>(rwh);
 }
 
 TestRenderWidgetHostView::~TestRenderWidgetHostView() {
@@ -421,3 +422,31 @@ void RenderViewHostTestHarness::TearDown() {
   message_loop_.DeleteSoon(FROM_HERE, browser_context_.release());
   message_loop_.RunAllPending();
 }
+
+TestRenderWidgetHostViewWithBackingStoreSkia::
+~TestRenderWidgetHostViewWithBackingStoreSkia() {
+  delete rwh_;
+}
+
+RenderWidgetHost*
+TestRenderWidgetHostViewWithBackingStoreSkia::GetRenderWidgetHost() const {
+  return rwh_;
+}
+
+BackingStore* TestRenderWidgetHostViewWithBackingStoreSkia::AllocBackingStore(
+    const gfx::Size& size) {
+  return new BackingStoreSkia(rwh_, size);
+}
+
+// static
+TestRenderWidgetHostViewWithBackingStoreSkia*
+TestRenderWidgetHostViewWithBackingStoreSkia::Construct(
+    content::RenderProcessHost* process,
+    int routing_id) {
+  RenderWidgetHostImpl* rwh = new RenderWidgetHostImpl(process, routing_id);
+  TestRenderWidgetHostViewWithBackingStoreSkia* rwhv =
+      new TestRenderWidgetHostViewWithBackingStoreSkia(rwh);
+  // Painting will be skipped if there's no view.
+  rwh->SetView(rwhv);
+  return rwhv;
+}
diff --git a/content/browser/renderer_host/test_render_view_host.h b/content/browser/renderer_host/test_render_view_host.h
index d028ae3..06b8c1a 100644
--- a/content/browser/renderer_host/test_render_view_host.h
+++ b/content/browser/renderer_host/test_render_view_host.h
@@ -175,8 +175,10 @@ class TestRenderWidgetHostView : public RenderWidgetHostViewBase {
 
   bool is_showing() const { return is_showing_; }
 
+ protected:
+  RenderWidgetHostImpl* rwh_;
+
  private:
-  RenderWidgetHost* rwh_;
   bool is_showing_;
 };
 
@@ -372,4 +374,31 @@ class RenderViewHostTestHarness : public testing::Test {
   DISALLOW_COPY_AND_ASSIGN(RenderViewHostTestHarness);
 };
 
+// This test render widget host view uses BackingStoreSkia instead of
+// TestBackingStore, so that basic operations like CopyFromBackingStore()
+// works. The skia implementation doesn't have any hardware or system
+// dependencies.
+class TestRenderWidgetHostViewWithBackingStoreSkia
+    : public content::TestRenderWidgetHostView {
+ public:
+  virtual ~TestRenderWidgetHostViewWithBackingStoreSkia();
+
+  virtual RenderWidgetHost* GetRenderWidgetHost() const OVERRIDE;
+  virtual BackingStore* AllocBackingStore(const gfx::Size& size) OVERRIDE;
+
+  // Creates a RWH with the given parameters, and uses it to create
+  // the test RWHV.  Also ensures painting is done.
+  static TestRenderWidgetHostViewWithBackingStoreSkia* Construct(
+      content::RenderProcessHost* process, int routing_id);
+
+ private:
+  // Takes ownership of rwh, private since it should be constructed
+  // via Construct.
+  explicit TestRenderWidgetHostViewWithBackingStoreSkia(RenderWidgetHost* rwh)
+      : content::TestRenderWidgetHostView(rwh) {}
+
+  DISALLOW_COPY_AND_ASSIGN(TestRenderWidgetHostViewWithBackingStoreSkia);
+};
+
+
 #endif  // CONTENT_BROWSER_RENDERER_HOST_TEST_RENDER_VIEW_HOST_H_
diff --git a/content/browser/renderer_host/text_input_client_mac.mm b/content/browser/renderer_host/text_input_client_mac.mm
index b65c854..0892080 100644
--- a/content/browser/renderer_host/text_input_client_mac.mm
+++ b/content/browser/renderer_host/text_input_client_mac.mm
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -35,8 +35,9 @@ NSUInteger TextInputClientMac::GetCharacterIndexAtPoint(RenderWidgetHost* rwh,
   base::TimeTicks start = base::TimeTicks::Now();
 
   BeforeRequest();
-  rwh->Send(new TextInputClientMsg_CharacterIndexForPoint(rwh->routing_id(),
-      point));
+  RenderWidgetHostImpl* rwhi = static_cast<RenderWidgetHostImpl*>(rwh);
+  rwhi->Send(new TextInputClientMsg_CharacterIndexForPoint(rwhi->routing_id(),
+                                                          point));
   condition_.TimedWait(base::TimeDelta::FromMilliseconds(kWaitTimeout));
   AfterRequest();
 
@@ -52,8 +53,10 @@ NSRect TextInputClientMac::GetFirstRectForRange(RenderWidgetHost* rwh,
   base::TimeTicks start = base::TimeTicks::Now();
 
   BeforeRequest();
-  rwh->Send(new TextInputClientMsg_FirstRectForCharacterRange(rwh->routing_id(),
-      ui::Range(range)));
+  RenderWidgetHostImpl* rwhi = static_cast<RenderWidgetHostImpl*>(rwh);
+  rwhi->Send(
+      new TextInputClientMsg_FirstRectForCharacterRange(rwhi->routing_id(),
+                                                        ui::Range(range)));
   condition_.TimedWait(base::TimeDelta::FromMilliseconds(kWaitTimeout));
   AfterRequest();
 
@@ -70,8 +73,9 @@ NSAttributedString* TextInputClientMac::GetAttributedSubstringFromRange(
   base::TimeTicks start = base::TimeTicks::Now();
 
   BeforeRequest();
-  rwh->Send(new TextInputClientMsg_StringForRange(rwh->routing_id(),
-      ui::Range(range)));
+  RenderWidgetHostImpl* rwhi = static_cast<RenderWidgetHostImpl*>(rwh);
+  rwhi->Send(new TextInputClientMsg_StringForRange(rwhi->routing_id(),
+                                                   ui::Range(range)));
   condition_.TimedWait(base::TimeDelta::FromMilliseconds(kWaitTimeout));
   AfterRequest();
 
diff --git a/content/browser/renderer_host/text_input_client_mac_unittest.mm b/content/browser/renderer_host/text_input_client_mac_unittest.mm
index 7de8a09..dbab62f 100644
--- a/content/browser/renderer_host/text_input_client_mac_unittest.mm
+++ b/content/browser/renderer_host/text_input_client_mac_unittest.mm
@@ -46,7 +46,7 @@ class TextInputClientMacTest : public testing::Test {
     thread_.message_loop()->PostDelayedTask(from_here, task, delay);
   }
 
-  RenderWidgetHost* widget() {
+  RenderWidgetHostImpl* widget() {
     return &widget_;
   }
 
@@ -62,7 +62,7 @@ class TextInputClientMacTest : public testing::Test {
 
   // Gets deleted when the last RWH in the "process" gets destroyed.
   MockRenderProcessHostFactory process_factory_;
-  RenderWidgetHost widget_;
+  RenderWidgetHostImpl widget_;
 
   base::Thread thread_;
 };
diff --git a/content/browser/tab_contents/tab_contents_view_gtk.cc b/content/browser/tab_contents/tab_contents_view_gtk.cc
index 4053d27..a61b3d35 100644
--- a/content/browser/tab_contents/tab_contents_view_gtk.cc
+++ b/content/browser/tab_contents/tab_contents_view_gtk.cc
@@ -30,7 +30,6 @@
 
 using WebKit::WebDragOperation;
 using WebKit::WebDragOperationsMask;
-using content::RenderWidgetHostView;
 using content::WebContents;
 
 namespace {
diff --git a/content/browser/tab_contents/tab_contents_view_helper.cc b/content/browser/tab_contents/tab_contents_view_helper.cc
index 66128c5..72bccb0 100644
--- a/content/browser/tab_contents/tab_contents_view_helper.cc
+++ b/content/browser/tab_contents/tab_contents_view_helper.cc
@@ -93,7 +93,8 @@ RenderWidgetHostView* TabContentsViewHelper::CreateNewWidget(
     bool is_fullscreen,
     WebKit::WebPopupType popup_type) {
   content::RenderProcessHost* process = web_contents->GetRenderProcessHost();
-  RenderWidgetHost* widget_host = new RenderWidgetHost(process, route_id);
+  RenderWidgetHostImpl* widget_host =
+      new RenderWidgetHostImpl(process, route_id);
   RenderWidgetHostViewPort* widget_view =
       RenderWidgetHostViewPort::CreateViewForWidget(widget_host);
   if (!is_fullscreen) {
@@ -177,6 +178,6 @@ RenderWidgetHostView* TabContentsViewHelper::ShowCreatedWidget(
     widget_host_view->InitAsPopup(web_contents->GetRenderWidgetHostView(),
                                   initial_pos);
   }
-  widget_host_view->GetRenderWidgetHost()->Init();
+  RenderWidgetHostImpl::FromRWHV(widget_host_view)->Init();
   return widget_host_view;
 }