Extract minimal RenderViewHost interface for embedders, leaving

content/browser/tab_contents/tab_contents.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/tab_contents/tab_contents.h"
 
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
@@ skipping 279 matching lines @@
       content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
       content::Source<WebContents>(this),
       content::NotificationService::NoDetails());
 
   // TODO(brettw) this should be moved to the view.
 #if defined(OS_WIN) && !defined(USE_AURA)
   // If we still have a window handle, destroy it. GetNativeView can return
   // NULL if this contents was part of a window that closed.
   if (GetNativeView()) {
     RenderViewHost* host = GetRenderViewHost();
-    if (host && host->view())
-      RenderWidgetHostViewPort::FromRWHV(host->view())->WillWmDestroy();
+    if (host && host->GetView())
+      RenderWidgetHostViewPort::FromRWHV(host->GetView())->WillWmDestroy();
   }
 #endif
 
   // OnCloseStarted isn't called in unit tests.
   if (!tab_close_start_time_.is_null()) {
     UMA_HISTOGRAM_TIMES("Tab.Close",
         base::TimeTicks::Now() - tab_close_start_time_);
   }
 
   FOR_EACH_OBSERVER(WebContentsObserver, observers_, TabContentsDestroyed());
@@ skipping 126 matching lines @@
     // Accelerated video and animation are slower than regular when using a
     // software 3d rasterizer. 3D CSS may also be too slow to be worthwhile.
     if (gpu_data_manager->ShouldUseSoftwareRendering()) {
       prefs.accelerated_video_enabled = false;
       prefs.accelerated_animation_enabled = false;
       prefs.accelerated_layers_enabled = false;
     }
   }
 
   if (ChildProcessSecurityPolicyImpl::GetInstance()->HasWebUIBindings(
-          rvh->process()->GetID())) {
+          rvh->GetProcess()->GetID())) {
     prefs.loads_images_automatically = true;
     prefs.javascript_enabled = true;
   }
 
   prefs.is_online = !net::NetworkChangeNotifier::IsOffline();
 
   // Force accelerated compositing and 2d canvas off for chrome:, about: and
   // chrome-devtools: pages (unless it's specifically allowed).
   if ((url.SchemeIs(chrome::kChromeDevToolsScheme) ||
       url.SchemeIs(chrome::kChromeUIScheme) ||
@@ skipping 132 matching lines @@
     return;
   if (delegate_)
     delegate_->Detach(this);
   delegate_ = delegate;
   if (delegate_)
     delegate_->Attach(this);
 }
 
 content::RenderProcessHost* TabContents::GetRenderProcessHost() const {
   if (render_manager_.current_host())
-    return render_manager_.current_host()->process();
+    return render_manager_.current_host()->GetProcess();
   else
     return NULL;
 }
 
 RenderViewHost* TabContents::GetRenderViewHost() const {
   return render_manager_.current_host();
 }
 
 RenderWidgetHostView* TabContents::GetRenderWidgetHostView() const {
   return render_manager_.GetRenderWidgetHostView();
@@ skipping 85 matching lines @@
     SiteInstance* site_instance, int32 page_id) {
   if (GetMaxPageIDForSiteInstance(site_instance) < page_id)
     max_page_ids_[site_instance->GetId()] = page_id;
 }
 
 void TabContents::CopyMaxPageIDsFrom(TabContents* tab_contents) {
   max_page_ids_ = tab_contents->max_page_ids_;
 }
 
 SiteInstance* TabContents::GetSiteInstance() const {
-  return render_manager_.current_host()->site_instance();
+  return render_manager_.current_host()->GetSiteInstance();
 }
 
 SiteInstance* TabContents::GetPendingSiteInstance() const {
   RenderViewHost* dest_rvh = render_manager_.pending_render_view_host() ?
       render_manager_.pending_render_view_host() :
       render_manager_.current_host();
-  return dest_rvh->site_instance();
+  return dest_rvh->GetSiteInstance();
 }
 
 bool TabContents::IsLoading() const {
   return is_loading_;
 }
 
 bool TabContents::IsWaitingForResponse() const {
   return waiting_for_response_;
 }
 
@@ skipping 63 matching lines @@
     rwhv->SetActive(true);
 #endif
   }
 
   last_selected_time_ = base::TimeTicks::Now();
 
   FOR_EACH_OBSERVER(WebContentsObserver, observers_, DidBecomeSelected());
 
   // The resize rect might have changed while this was inactive -- send the new
   // one to make sure it's up to date.
-  RenderViewHost* rvh = GetRenderViewHost();
+  RenderViewHostImpl* rvh =
+      static_cast<RenderViewHostImpl*>(GetRenderViewHost());
   if (rvh) {
     rvh->ResizeRectChanged(GetRootWindowResizerRect());
   }
 }
 
 
 base::TimeTicks TabContents::GetLastSelectedTime() const {
   return last_selected_time_;
 }
 
@@ skipping 31 matching lines @@
   // here practically impossible to understand, this also means we end up
   // calling TabContents::WasHidden() twice if callers call both versions of
   // HideContents() on a TabContents.
   WasHidden();
 }
 
 bool TabContents::NeedToFireBeforeUnload() {
   // TODO(creis): Should we fire even for interstitial pages?
   return WillNotifyDisconnection() &&
       !ShowingInterstitialPage() &&
-      !GetRenderViewHost()->SuddenTerminationAllowed();
+      !static_cast<RenderViewHostImpl*>(
+          GetRenderViewHost())->SuddenTerminationAllowed();
 }
 
 void TabContents::Stop() {
   render_manager_.Stop();
   FOR_EACH_OBSERVER(WebContentsObserver, observers_, StopNavigation());
 }
 
 WebContents* TabContents::Clone() {
   // We create a new SiteInstance so that the new tab won't share processes
   // with the old one. This can be changed in the future if we need it to share
@@ skipping 143 matching lines @@
 }
 
 bool TabContents::NavigateToEntry(
     const NavigationEntryImpl& entry,
     NavigationController::ReloadType reload_type) {
   // The renderer will reject IPC messages with URLs longer than
   // this limit, so don't attempt to navigate with a longer URL.
   if (entry.GetURL().spec().size() > content::kMaxURLChars)
     return false;
 
-  RenderViewHost* dest_render_view_host = render_manager_.Navigate(entry);
+  RenderViewHostImpl* dest_render_view_host =
+      static_cast<RenderViewHostImpl*>(render_manager_.Navigate(entry));
   if (!dest_render_view_host)
     return false;  // Unable to create the desired render view host.
 
   // For security, we should never send non-Web-UI URLs to a Web UI renderer.
   // Double check that here.
-  int enabled_bindings = dest_render_view_host->enabled_bindings();
+  int enabled_bindings = dest_render_view_host->GetEnabledBindings();
   WebUIControllerFactory* factory =
       content::GetContentClient()->browser()->GetWebUIControllerFactory();
   bool is_allowed_in_web_ui_renderer =
       factory &&
       factory->IsURLAcceptableForWebUI(GetBrowserContext(), entry.GetURL());
 #if defined(OS_CHROMEOS)
   is_allowed_in_web_ui_renderer |= entry.GetURL().SchemeIs(chrome::kDataScheme);
 #endif
   CHECK(!(enabled_bindings & content::BINDINGS_POLICY_WEB_UI) ||
         is_allowed_in_web_ui_renderer);
@@ skipping 37 matching lines @@
 void TabContents::SetHistoryLengthAndPrune(
     const SiteInstance* site_instance,
     int history_length,
     int32 minimum_page_id) {
   // SetHistoryLengthAndPrune doesn't work when there are pending cross-site
   // navigations. Callers should ensure that this is the case.
   if (render_manager_.pending_render_view_host()) {
     NOTREACHED();
     return;
   }
-  RenderViewHost* rvh = GetRenderViewHost();
+  RenderViewHostImpl* rvh = GetRenderViewHostImpl();
   if (!rvh) {
     NOTREACHED();
     return;
   }
-  if (site_instance && rvh->site_instance() != site_instance) {
+  if (site_instance && rvh->GetSiteInstance() != site_instance) {
     NOTREACHED();
     return;
   }
-  rvh->Send(new ViewMsg_SetHistoryLengthAndPrune(rvh->routing_id(),
+  rvh->Send(new ViewMsg_SetHistoryLengthAndPrune(rvh->GetRoutingID(),
                                                  history_length,
                                                  minimum_page_id));
 }
 
 void TabContents::FocusThroughTabTraversal(bool reverse) {
   if (ShowingInterstitialPage()) {
     render_manager_.interstitial_page()->FocusThroughTabTraversal(reverse);
     return;
   }
-  GetRenderViewHost()->SetInitialFocus(reverse);
+  GetRenderViewHostImpl()->SetInitialFocus(reverse);
 }
 
 bool TabContents::ShowingInterstitialPage() const {
   return render_manager_.interstitial_page() != NULL;
 }
 
 InterstitialPage* TabContents::GetInterstitialPage() const {
   return render_manager_.interstitial_page();
 }
 
@@ skipping 55 matching lines @@
 const std::string& TabContents::GetContentsMimeType() const {
   return contents_mime_type_;
 }
 
 bool TabContents::WillNotifyDisconnection() const {
   return notify_disconnection_;
 }
 
 void TabContents::SetOverrideEncoding(const std::string& encoding) {
   SetEncoding(encoding);
-  GetRenderViewHost()->Send(new ViewMsg_SetPageEncoding(
-      GetRenderViewHost()->routing_id(), encoding));
+  GetRenderViewHostImpl()->Send(new ViewMsg_SetPageEncoding(
+      GetRenderViewHost()->GetRoutingID(), encoding));
 }
 
 void TabContents::ResetOverrideEncoding() {
   encoding_.clear();
-  GetRenderViewHost()->Send(new ViewMsg_ResetPageEncodingToDefault(
-      GetRenderViewHost()->routing_id()));
+  GetRenderViewHostImpl()->Send(new ViewMsg_ResetPageEncodingToDefault(
+      GetRenderViewHost()->GetRoutingID()));
 }
 
 content::RendererPreferences* TabContents::GetMutableRendererPrefs() {
   return &renderer_preferences_;
 }
 
 void TabContents::SetNewTabStartTime(const base::TimeTicks& time) {
   new_tab_start_time_ = time;
 }
 
@@ skipping 13 matching lines @@
   if (delegate_ && delegate_->IsPopupOrPanel(this))
     return false;
   return true;
 #else
   return true;
 #endif
 }
 
 void TabContents::SystemDragEnded() {
   if (GetRenderViewHost())
-    GetRenderViewHost()->DragSourceSystemDragEnded();
+    GetRenderViewHostImpl()->DragSourceSystemDragEnded();
   if (delegate_)
     delegate_->DragEnded();
 }
 
 void TabContents::SetClosedByUserGesture(bool value) {
   closed_by_user_gesture_ = value;
 }
 
 bool TabContents::GetClosedByUserGesture() const {
   return closed_by_user_gesture_;
 }
 
 double TabContents::GetZoomLevel() const {
   HostZoomMapImpl* zoom_map = static_cast<HostZoomMapImpl*>(
       HostZoomMap::GetForBrowserContext(GetBrowserContext()));
   if (!zoom_map)
     return 0;
 
   double zoom_level;
   if (temporary_zoom_settings_) {
     zoom_level = zoom_map->GetTemporaryZoomLevel(
-        GetRenderProcessHost()->GetID(), GetRenderViewHost()->routing_id());
+        GetRenderProcessHost()->GetID(), GetRenderViewHost()->GetRoutingID());
   } else {
     GURL url;
     NavigationEntry* active_entry = GetController().GetActiveEntry();
     // Since zoom map is updated using rewritten URL, use rewritten URL
     // to get the zoom level.
     url = active_entry ? active_entry->GetURL() : GURL::EmptyGURL();
     zoom_level = zoom_map->GetZoomLevel(net::GetHostOrSpecFromURL(url));
   }
   return zoom_level;
 }
@@ skipping 88 matching lines @@
   //    -> Use committed Web UI.
   if (controller_.GetPendingEntry() &&
       (controller_.GetLastCommittedEntry() ||
        render_manager_.pending_web_ui()))
     return render_manager_.pending_web_ui();
   return render_manager_.web_ui();
 }
 
 bool TabContents::GotResponseToLockMouseRequest(bool allowed) {
   return GetRenderViewHost() ?
-      GetRenderViewHost()->GotResponseToLockMouseRequest(allowed) : false;
+      GetRenderViewHostImpl()->GotResponseToLockMouseRequest(allowed) : false;
 }
 
 bool TabContents::FocusLocationBarByDefault() {
   content::WebUI* web_ui = GetWebUIForCurrentState();
   if (web_ui)
     return web_ui->ShouldFocusLocationBarByDefault();
   NavigationEntry* entry = controller_.GetActiveEntry();
   if (entry && entry->GetURL() == GURL(chrome::kAboutBlankURL))
     return true;
   return false;
@@ skipping 19 matching lines @@
       new WebIntentsDispatcherImpl(this, intent, intent_id);
   delegate_->WebIntentDispatch(this, intents_dispatcher);
 }
 
 void TabContents::OnDidStartProvisionalLoadForFrame(int64 frame_id,
                                                     bool is_main_frame,
                                                     const GURL& opener_url,
                                                     const GURL& url) {
   bool is_error_page = (url.spec() == chrome::kUnreachableWebDataURL);
   GURL validated_url(url);
-  GetRenderViewHost()->FilterURL(ChildProcessSecurityPolicyImpl::GetInstance(),
-      GetRenderProcessHost()->GetID(), &validated_url);
+  GetRenderViewHostImpl()->FilterURL(
+      ChildProcessSecurityPolicyImpl::GetInstance(),
+      GetRenderProcessHost()->GetID(),
+      &validated_url);
 
   RenderViewHost* rvh =
       render_manager_.pending_render_view_host() ?
           render_manager_.pending_render_view_host() : GetRenderViewHost();
   // Notify observers about the start of the provisional load.
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     DidStartProvisionalLoadForFrame(frame_id, is_main_frame,
                     validated_url, is_error_page, rvh));
 
   if (is_main_frame) {
@@ skipping 27 matching lines @@
 void TabContents::OnDidFailProvisionalLoadWithError(
     const ViewHostMsg_DidFailProvisionalLoadWithError_Params& params) {
   VLOG(1) << "Failed Provisional Load: " << params.url.possibly_invalid_spec()
           << ", error_code: " << params.error_code
           << ", error_description: " << params.error_description
           << ", is_main_frame: " << params.is_main_frame
           << ", showing_repost_interstitial: " <<
             params.showing_repost_interstitial
           << ", frame_id: " << params.frame_id;
   GURL validated_url(params.url);
-  GetRenderViewHost()->FilterURL(ChildProcessSecurityPolicyImpl::GetInstance(),
-      GetRenderProcessHost()->GetID(), &validated_url);
+  GetRenderViewHostImpl()->FilterURL(
+      ChildProcessSecurityPolicyImpl::GetInstance(),
+      GetRenderProcessHost()->GetID(),
+      &validated_url);
 
   if (net::ERR_ABORTED == params.error_code) {
     // EVIL HACK ALERT! Ignore failed loads when we're showing interstitials.
     // This means that the interstitial won't be torn down properly, which is
     // bad. But if we have an interstitial, go back to another tab type, and
     // then load the same interstitial again, we could end up getting the first
     // interstitial's "failed" message (as a result of the cancel) when we're on
     // the second one.
     //
     // We can't tell this apart, so we think we're tearing down the current page
@@ skipping 197 matching lines @@
                               int active_match_ordinal,
                               bool final_update) {
   delegate_->FindReply(this, request_id, number_of_matches, selection_rect,
                        active_match_ordinal, final_update);
   // Send a notification to the renderer that we are ready to receive more
   // results from the scoping effort of the Find operation. The FindInPage
   // scoping is asynchronous and periodically sends results back up to the
   // browser using IPC. In an effort to not spam the browser we have the
   // browser send an ACK for each FindReply message and have the renderer
   // queue up the latest status message while waiting for this ACK.
-  GetRenderViewHost()->Send(
-      new ViewMsg_FindReplyACK(GetRenderViewHost()->routing_id()));
+  GetRenderViewHostImpl()->Send(
+      new ViewMsg_FindReplyACK(GetRenderViewHost()->GetRoutingID()));
 }
 
 void TabContents::OnCrashedPlugin(const FilePath& plugin_path) {
   delegate_->CrashedPlugin(this, plugin_path);
 }
 
 void TabContents::OnAppCacheAccessed(const GURL& manifest_url,
                                      bool blocked_by_policy) {
   // Notify observers about navigation.
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
@@ skipping 90 matching lines @@
 }
 
 void TabContents::UpdateMaxPageIDIfNecessary(RenderViewHost* rvh) {
   // If we are creating a RVH for a restored controller, then we need to make
   // sure the RenderView starts with a next_page_id_ larger than the number
   // of restored entries.  This must be called before the RenderView starts
   // navigating (to avoid a race between the browser updating max_page_id and
   // the renderer updating next_page_id_).  Because of this, we only call this
   // from CreateRenderView and allow that to notify the RenderView for us.
   int max_restored_page_id = controller_.GetMaxRestoredPageID();
-  if (max_restored_page_id > GetMaxPageIDForSiteInstance(rvh->site_instance()))
-    UpdateMaxPageIDForSiteInstance(rvh->site_instance(), max_restored_page_id);
+  if (max_restored_page_id >
+      GetMaxPageIDForSiteInstance(rvh->GetSiteInstance()))
+    UpdateMaxPageIDForSiteInstance(rvh->GetSiteInstance(),
+                                   max_restored_page_id);
 }
 
 bool TabContents::UpdateTitleForEntry(NavigationEntryImpl* entry,
                                       const string16& title) {
   // For file URLs without a title, use the pathname instead. In the case of a
   // synthesized title, we don't want the update to count toward the "one set
   // per page of the title to history."
   string16 final_title;
   bool explicit_set;
   if (entry && entry->GetURL().SchemeIsFile() && title.empty()) {
@@ skipping 99 matching lines @@
   if (!entry)
     return;
 
   // When we're creating views, we're still doing initial setup, so we always
   // use the pending Web UI rather than any possibly existing committed one.
   if (render_manager_.pending_web_ui())
     render_manager_.pending_web_ui()->RenderViewCreated(render_view_host);
 
   if (entry->IsViewSourceMode()) {
     // Put the renderer in view source mode.
-    render_view_host->Send(
-        new ViewMsg_EnableViewSourceMode(render_view_host->routing_id()));
+    static_cast<RenderViewHostImpl*>(render_view_host)->Send(
+        new ViewMsg_EnableViewSourceMode(render_view_host->GetRoutingID()));
   }
 
   GetView()->RenderViewCreated(render_view_host);
 
   FOR_EACH_OBSERVER(
       WebContentsObserver, observers_, RenderViewCreated(render_view_host));
 }
 
 void TabContents::RenderViewReady(RenderViewHost* rvh) {
   if (rvh != GetRenderViewHost()) {
@@ skipping 115 matching lines @@
   // the swapped out RVHs.  We don't expect to hear from any other RVHs.
   DCHECK(rvh == GetRenderViewHost() || render_manager_.IsSwappedOut(rvh));
 
   // We must be prepared to handle state updates for any page, these occur
   // when the user is scrolling and entering form data, as well as when we're
   // leaving a page, in which case our state may have already been moved to
   // the next page. The navigation controller will look up the appropriate
   // NavigationEntry and update it when it is notified via the delegate.
 
   int entry_index = controller_.GetEntryIndexWithPageID(
-      rvh->site_instance(), page_id);
+      rvh->GetSiteInstance(), page_id);
   if (entry_index < 0)
     return;
   NavigationEntry* entry = controller_.GetEntryAtIndex(entry_index);
 
   if (state == entry->GetContentState())
     return;  // Nothing to update.
   entry->SetContentState(state);
   controller_.NotifyEntryChanged(entry, entry_index);
 }
 
 void TabContents::UpdateTitle(RenderViewHost* rvh,
                               int32 page_id,
                               const string16& title,
                               base::i18n::TextDirection title_direction) {
   // If we have a title, that's a pretty good indication that we've started
   // getting useful data.
   SetNotWaitingForResponse();
 
   // Try to find the navigation entry, which might not be the current one.
   // For example, it might be from a pending RVH for the pending entry.
   NavigationEntryImpl* entry = controller_.GetEntryWithPageID(
-      rvh->site_instance(), page_id);
+      rvh->GetSiteInstance(), page_id);
 
   // We can handle title updates when we don't have an entry in
   // UpdateTitleForEntry, but only if the update is from the current RVH.
   if (!entry && rvh != GetRenderViewHost())
     return;
 
   // TODO(evan): make use of title_direction.
   // http://code.google.com/p/chromium/issues/detail?id=27094
   if (!UpdateTitleForEntry(entry, title))
     return;
@@ skipping 168 matching lines @@
     const string16& message,
     const string16& default_prompt,
     const GURL& frame_url,
     ui::JavascriptMessageType javascript_message_type,
     IPC::Message* reply_msg,
     bool* did_suppress_message) {
   // Suppress JavaScript dialogs when requested. Also suppress messages when
   // showing an interstitial as it's shown over the previous page and we don't
   // want the hidden page's dialogs to interfere with the interstitial.
   bool suppress_this_message =
-      rvh->is_swapped_out() ||
+      static_cast<RenderViewHostImpl*>(rvh)->is_swapped_out() ||
       ShowingInterstitialPage() ||
       !delegate_ ||
       delegate_->ShouldSuppressDialogs() ||
       !delegate_->GetJavaScriptDialogCreator();
 
   if (!suppress_this_message) {
     std::string accept_lang = content::GetContentClient()->browser()->
       GetAcceptLangs(GetBrowserContext());
     dialog_creator_ = delegate_->GetJavaScriptDialogCreator();
     dialog_creator_->RunJavaScriptDialog(
@@ skipping 14 matching lines @@
     OnDialogClosed(rvh, reply_msg, false, string16());
   }
 
   *did_suppress_message = suppress_this_message;
 }
 
 void TabContents::RunBeforeUnloadConfirm(RenderViewHost* rvh,
                                          const string16& message,
                                          bool is_reload,
                                          IPC::Message* reply_msg) {
+  RenderViewHostImpl* rvhi = static_cast<RenderViewHostImpl*>(rvh);
   if (delegate_)
     delegate_->WillRunBeforeUnloadConfirm();
 
   bool suppress_this_message =
-      rvh->is_swapped_out() ||
+      rvhi->is_swapped_out() ||
       !delegate_ ||
       delegate_->ShouldSuppressDialogs() ||
       !delegate_->GetJavaScriptDialogCreator();
   if (suppress_this_message) {
     // The reply must be sent to the RVH that sent the request.
-    rvh->JavaScriptDialogClosed(reply_msg, true, string16());
+    rvhi->JavaScriptDialogClosed(reply_msg, true, string16());
     return;
   }
 
   is_showing_before_unload_dialog_ = true;
   dialog_creator_ = delegate_->GetJavaScriptDialogCreator();
   dialog_creator_->RunBeforeUnloadDialog(
       this, message, is_reload,
       base::Bind(&TabContents::OnDialogClosed, base::Unretained(this), rvh,
                  reply_msg));
 }
@@ skipping 15 matching lines @@
   // Notify observers.
   FOR_EACH_OBSERVER(WebContentsObserver, observers_, DidGetIgnoredUIEvent());
 }
 
 void TabContents::RendererUnresponsive(RenderViewHost* rvh,
                                        bool is_during_unload) {
   // Don't show hung renderer dialog for a swapped out RVH.
   if (rvh != GetRenderViewHost())
     return;
 
+  RenderViewHostImpl* rvhi = static_cast<RenderViewHostImpl*>(rvh);
+
   // Ignore renderer unresponsive event if debugger is attached to the tab
   // since the event may be a result of the renderer sitting on a breakpoint.
   // See http://crbug.com/65458
   DevToolsAgentHost* agent =
       content::DevToolsAgentHostRegistry::GetDevToolsAgentHost(rvh);
   if (agent &&
       DevToolsManagerImpl::GetInstance()->GetDevToolsClientHostFor(agent))
     return;
 
   if (is_during_unload) {
     // Hang occurred while firing the beforeunload/unload handler.
     // Pretend the handler fired so tab closing continues as if it had.
-    rvh->set_sudden_termination_allowed(true);
+    rvhi->set_sudden_termination_allowed(true);
 
     if (!render_manager_.ShouldCloseTabOnUnresponsiveRenderer())
       return;
 
     // If the tab hangs in the beforeunload/unload handler there's really
     // nothing we can do to recover. Pretend the unload listeners have
     // all fired and close the tab. If the hang is in the beforeunload handler
     // then the user will not have the option of cancelling the close.
     Close(rvh);
     return;
   }
 
-  if (!GetRenderViewHost() || !GetRenderViewHost()->IsRenderViewLive())
+  if (!GetRenderViewHostImpl() || !GetRenderViewHostImpl()->IsRenderViewLive())
     return;
 
   if (delegate_)
     delegate_->RendererUnresponsive(this);
 }
 
 void TabContents::RendererResponsive(RenderViewHost* render_view_host) {
   if (delegate_)
     delegate_->RendererResponsive(this);
 }
@@ skipping 72 matching lines @@
   // Can be NULL during tests.
   RenderWidgetHostView* rwh_view = view_->CreateViewForWidget(render_view_host);
 
   // Now that the RenderView has been created, we need to tell it its size.
   if (rwh_view)
     rwh_view->SetSize(view_->GetContainerSize());
 
   // Make sure we use the correct starting page_id in the new RenderView.
   UpdateMaxPageIDIfNecessary(render_view_host);
   int32 max_page_id =
-      GetMaxPageIDForSiteInstance(render_view_host->site_instance());
+      GetMaxPageIDForSiteInstance(render_view_host->GetSiteInstance());
 
-  if (!render_view_host->CreateRenderView(string16(), max_page_id))
+  if (!static_cast<RenderViewHostImpl*>(
+          render_view_host)->CreateRenderView(string16(), max_page_id))
     return false;
 
 #if defined(OS_LINUX) || defined(OS_OPENBSD)
   // Force a ViewMsg_Resize to be sent, needed to make plugins show up on
   // linux. See crbug.com/83941.
   if (rwh_view) {
     if (RenderWidgetHost* render_widget_host = rwh_view->GetRenderWidgetHost())
       render_widget_host->WasResized();
   }
 #endif
 
   return true;
 }
 
 void TabContents::OnDialogClosed(RenderViewHost* rvh,
                                  IPC::Message* reply_msg,
                                  bool success,
                                  const string16& user_input) {
   if (is_showing_before_unload_dialog_ && !success) {
     // If a beforeunload dialog is canceled, we need to stop the throbber from
     // spinning, since we forced it to start spinning in Navigate.
     DidStopLoading();
 
     tab_close_start_time_ = base::TimeTicks();
   }
   is_showing_before_unload_dialog_ = false;
-  rvh->JavaScriptDialogClosed(reply_msg, success, user_input);
+  static_cast<RenderViewHostImpl*>(
+      rvh)->JavaScriptDialogClosed(reply_msg, success, user_input);
 }
 
 void TabContents::SetEncoding(const std::string& encoding) {
   encoding_ = content::GetContentClient()->browser()->
       GetCanonicalEncodingNameByAliasName(encoding);
 }
 
 void TabContents::SaveURL(const GURL& url,
                           const GURL& referrer,
                           bool is_main_frame) {
@@ skipping 16 matching lines @@
                    save_info,
                    this);
 }
 
 void TabContents::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = GetView()->CreateViewForWidget(rvh);
   // Can be NULL during tests.
   if (rwh_view)
     rwh_view->SetSize(GetView()->GetContainerSize());
 }
+
+RenderViewHostImpl* TabContents::GetRenderViewHostImpl() {
+  return static_cast<RenderViewHostImpl*>(GetRenderViewHost());
+}