Extract minimal RenderViewHost interface for embedders, leaving

content/browser/tab_contents/render_view_host_manager.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/render_view_host_manager.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 33 matching lines @@
       render_view_host_(NULL),
       pending_render_view_host_(NULL),
       interstitial_page_(NULL) {
 }
 
 RenderViewHostManager::~RenderViewHostManager() {
   if (pending_render_view_host_)
     CancelPending();
 
   // We should always have a main RenderViewHost.
-  RenderViewHost* render_view_host = render_view_host_;
+  RenderViewHostImpl* render_view_host = render_view_host_;
   render_view_host_ = NULL;
   render_view_host->Shutdown();
 
   // Shut down any swapped out RenderViewHosts.
   for (RenderViewHostMap::iterator iter = swapped_out_hosts_.begin();
        iter != swapped_out_hosts_.end();
        ++iter) {
     iter->second->Shutdown();
   }
 }
 
 void RenderViewHostManager::Init(content::BrowserContext* browser_context,
                                  SiteInstance* site_instance,
                                  int routing_id) {
   // Create a RenderViewHost, once we have an instance.  It is important to
   // immediately give this SiteInstance to a RenderViewHost so that it is
   // ref counted.
   if (!site_instance)
     site_instance = SiteInstance::Create(browser_context);
-  render_view_host_ = RenderViewHostFactory::Create(
-      site_instance, render_view_delegate_, routing_id, delegate_->
-      GetControllerForRenderManager().GetSessionStorageNamespace());
+  render_view_host_ = static_cast<RenderViewHostImpl*>(
+      RenderViewHostFactory::Create(
+          site_instance, render_view_delegate_, routing_id, delegate_->
+          GetControllerForRenderManager().GetSessionStorageNamespace()));
 
   // Keep track of renderer processes as they start to shut down.
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSING,
                  content::NotificationService::AllSources());
 }
 
+RenderViewHostImpl* RenderViewHostManager::current_host() const {
+  return render_view_host_;
+}
+
+RenderViewHostImpl* RenderViewHostManager::pending_render_view_host() const {
+  return pending_render_view_host_;
+}
+
 RenderWidgetHostView* RenderViewHostManager::GetRenderWidgetHostView() const {
   if (!render_view_host_)
     return NULL;
-  return render_view_host_->view();
+  return render_view_host_->GetView();
 }
 
-RenderViewHost* RenderViewHostManager::Navigate(
+RenderViewHostImpl* RenderViewHostManager::Navigate(
     const NavigationEntryImpl& entry) {
   // Create a pending RenderViewHost. It will give us the one we should use
-  RenderViewHost* dest_render_view_host = UpdateRendererStateForNavigate(entry);
+  RenderViewHostImpl* dest_render_view_host =
+      static_cast<RenderViewHostImpl*>(UpdateRendererStateForNavigate(entry));
   if (!dest_render_view_host)
     return NULL;  // We weren't able to create a pending render view host.
 
   // If the current render_view_host_ isn't live, we should create it so
   // that we don't show a sad tab while the dest_render_view_host fetches
   // its first page.  (Bug 1145340)
   if (dest_render_view_host != render_view_host_ &&
       !render_view_host_->IsRenderViewLive()) {
     // Note: we don't call InitRenderView here because we are navigating away
     // soon anyway, and we don't have the NavigationEntry for this host.
     delegate_->CreateRenderViewForRenderManager(render_view_host_);
   }
 
   // If the renderer crashed, then try to create a new one to satisfy this
   // navigation request.
   if (!dest_render_view_host->IsRenderViewLive()) {
     if (!InitRenderView(dest_render_view_host, entry))
       return NULL;
 
     // Now that we've created a new renderer, be sure to hide it if it isn't
     // our primary one.  Otherwise, we might crash if we try to call Show()
     // on it later.
     if (dest_render_view_host != render_view_host_ &&
-        dest_render_view_host->view()) {
-      dest_render_view_host->view()->Hide();
+        dest_render_view_host->GetView()) {
+      dest_render_view_host->GetView()->Hide();
     } else {
       // This is our primary renderer, notify here as we won't be calling
       // CommitPending (which does the notify).
       RenderViewHost* null_rvh = NULL;
       std::pair<RenderViewHost*, RenderViewHost*> details =
           std::make_pair(null_rvh, render_view_host_);
       content::NotificationService::current()->Notify(
           content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
           content::Source<NavigationController>(
               &delegate_->GetControllerForRenderManager()),
           content::Details<std::pair<RenderViewHost*, RenderViewHost*> >(
               &details));
     }
   }
 
   return dest_render_view_host;
 }
 
 void RenderViewHostManager::Stop() {
   render_view_host_->Stop();
 
   // If we are cross-navigating, we should stop the pending renderers.  This
   // will lead to a DidFailProvisionalLoad, which will properly destroy them.
   if (cross_navigation_pending_) {
     pending_render_view_host_->Send(
-        new ViewMsg_Stop(pending_render_view_host_->routing_id()));
+        new ViewMsg_Stop(pending_render_view_host_->GetRoutingID()));
   }
 }
 
 void RenderViewHostManager::SetIsLoading(bool is_loading) {
   render_view_host_->SetIsLoading(is_loading);
   if (pending_render_view_host_)
     pending_render_view_host_->SetIsLoading(is_loading);
 }
 
 bool RenderViewHostManager::ShouldCloseTabOnUnresponsiveRenderer() {
@@ skipping 15 matching lines @@
       pending_render_view_host_->SetNavigationsSuspended(false);
   } else {
     // The request has been started and paused while we're waiting for the
     // unload handler to finish.  We'll pretend that it did, by notifying the
     // IO thread to let the response continue.  The pending renderer will then
     // be swapped in as part of the usual DidNavigate logic.  (If the unload
     // handler later finishes, this call will be ignored because the state in
     // CrossSiteResourceHandler will already be cleaned up.)
     ViewMsg_SwapOut_Params params;
     params.new_render_process_host_id =
-        pending_render_view_host_->process()->GetID();
+        pending_render_view_host_->GetProcess()->GetID();
     params.new_request_id = pending_request_id;
-    current_host()->process()->CrossSiteSwapOutACK(params);
+    current_host()->GetProcess()->CrossSiteSwapOutACK(params);
   }
   return false;
 }
 
 void RenderViewHostManager::DidNavigateMainFrame(
     RenderViewHost* render_view_host) {
   if (!cross_navigation_pending_) {
     DCHECK(!pending_render_view_host_);
 
     // We should only hear this from our current renderer.
     DCHECK(render_view_host == render_view_host_);
 
     // Even when there is no pending RVH, there may be a pending Web UI.
     if (pending_web_ui_.get())
       CommitPending();
     return;
   }
 
   if (render_view_host == pending_render_view_host_) {
     // The pending cross-site navigation completed, so show the renderer.
     // If it committed without sending network requests (e.g., data URLs),
     // then we still need to swap out the old RVH first and run its unload
     // handler.  OK for that to happen in the background.
     if (pending_render_view_host_->GetPendingRequestId() == -1) {
-      OnCrossSiteResponse(pending_render_view_host_->process()->GetID(),
-                          pending_render_view_host_->routing_id());
+      OnCrossSiteResponse(pending_render_view_host_->GetProcess()->GetID(),
+                          pending_render_view_host_->GetRoutingID());
     }
 
     CommitPending();
     cross_navigation_pending_ = false;
   } else if (render_view_host == render_view_host_) {
     // A navigation in the original page has taken place.  Cancel the pending
     // one.
     CancelPending();
     cross_navigation_pending_ = false;
   } else {
@@ skipping 23 matching lines @@
 
 void RenderViewHostManager::RendererProcessClosing(
     content::RenderProcessHost* render_process_host) {
   // Remove any swapped out RVHs from this process, so that we don't try to
   // swap them back in while the process is exiting.  Start by finding them,
   // since there could be more than one.
   std::list<int> ids_to_remove;
   for (RenderViewHostMap::iterator iter = swapped_out_hosts_.begin();
        iter != swapped_out_hosts_.end();
        ++iter) {
-    if (iter->second->process() == render_process_host)
+    if (iter->second->GetProcess() == render_process_host)
       ids_to_remove.push_back(iter->first);
   }
 
   // Now delete them.
   while (!ids_to_remove.empty()) {
     swapped_out_hosts_[ids_to_remove.back()]->Shutdown();
     swapped_out_hosts_.erase(ids_to_remove.back());
     ids_to_remove.pop_back();
   }
 }
@@ skipping 80 matching lines @@
     const NavigationEntryImpl* new_entry) const {
   DCHECK(new_entry);
 
   // Check for reasons to swap processes even if we are in a process model that
   // doesn't usually swap (e.g., process-per-tab).
 
   // For security, we should transition between processes when one is a Web UI
   // page and one isn't.  If there's no cur_entry, check the current RVH's
   // site, which might already be committed to a Web UI URL (such as the NTP).
   const GURL& current_url = (cur_entry) ? cur_entry->GetURL() :
-      render_view_host_->site_instance()->GetSite();
+      render_view_host_->GetSiteInstance()->GetSite();
   content::BrowserContext* browser_context =
       delegate_->GetControllerForRenderManager().GetBrowserContext();
   const WebUIControllerFactory* web_ui_factory =
       content::GetContentClient()->browser()->GetWebUIControllerFactory();
   if (web_ui_factory) {
     if (web_ui_factory->UseWebUIForURL(browser_context, current_url)) {
       // Force swap if it's not an acceptable URL for Web UI.
       if (!web_ui_factory->IsURLAcceptableForWebUI(browser_context,
                                                    new_entry->GetURL()))
         return true;
@@ skipping 155 matching lines @@
   // Check if we've already created an RVH for this SiteInstance.
   CHECK(instance);
   RenderViewHostMap::iterator iter =
       swapped_out_hosts_.find(instance->GetId());
   if (iter != swapped_out_hosts_.end()) {
     // Re-use the existing RenderViewHost, which has already been initialized.
     // We'll remove it from the list of swapped out hosts if it commits.
     pending_render_view_host_ = iter->second;
 
     // Prevent the process from exiting while we're trying to use it.
-    pending_render_view_host_->process()->AddPendingView();
+    pending_render_view_host_->GetProcess()->AddPendingView();
 
     return true;
   }
 
-  pending_render_view_host_ = RenderViewHostFactory::Create(
-      instance, render_view_delegate_, MSG_ROUTING_NONE, delegate_->
-      GetControllerForRenderManager().GetSessionStorageNamespace());
+  pending_render_view_host_ = static_cast<RenderViewHostImpl*>(
+      RenderViewHostFactory::Create(
+          instance, render_view_delegate_, MSG_ROUTING_NONE, delegate_->
+          GetControllerForRenderManager().GetSessionStorageNamespace()));
 
   // Prevent the process from exiting while we're trying to use it.
-  pending_render_view_host_->process()->AddPendingView();
+  pending_render_view_host_->GetProcess()->AddPendingView();
 
   bool success = InitRenderView(pending_render_view_host_, entry);
   if (success) {
     // Don't show the view until we get a DidNavigate from it.
-    pending_render_view_host_->view()->Hide();
+    pending_render_view_host_->GetView()->Hide();
   } else {
     CancelPending();
   }
   return success;
 }
 
 bool RenderViewHostManager::InitRenderView(RenderViewHost* render_view_host,
                                            const NavigationEntryImpl& entry) {
   // If the pending navigation is to a WebUI, tell the RenderView about any
   // bindings it will need enabled.
@@ skipping 21 matching lines @@
   // committing above and we're done.
   if (!pending_render_view_host_) {
     if (will_focus_location_bar)
       delegate_->SetFocusToLocationBar(false);
     return;
   }
 
   // Remember if the page was focused so we can focus the new renderer in
   // that case.
   bool focus_render_view = !will_focus_location_bar &&
-      render_view_host_->view() && render_view_host_->view()->HasFocus();
+      render_view_host_->GetView() && render_view_host_->GetView()->HasFocus();
 
   // Swap in the pending view and make it active.
-  RenderViewHost* old_render_view_host = render_view_host_;
+  RenderViewHostImpl* old_render_view_host = render_view_host_;
   render_view_host_ = pending_render_view_host_;
   pending_render_view_host_ = NULL;
 
   // The process will no longer try to exit, so we can decrement the count.
-  render_view_host_->process()->RemovePendingView();
+  render_view_host_->GetProcess()->RemovePendingView();
 
   // If the view is gone, then this RenderViewHost died while it was hidden.
   // We ignored the RenderViewGone call at the time, so we should send it now
   // to make sure the sad tab shows up, etc.
-  if (render_view_host_->view())
-    render_view_host_->view()->Show();
+  if (render_view_host_->GetView())
+    render_view_host_->GetView()->Show();
   else
     delegate_->RenderViewGoneFromRenderManager(render_view_host_);
 
   // Hide the old view now that the new one is visible.
-  if (old_render_view_host->view()) {
-    old_render_view_host->view()->Hide();
+  if (old_render_view_host->GetView()) {
+    old_render_view_host->GetView()->Hide();
     old_render_view_host->WasSwappedOut();
   }
 
   // Make sure the size is up to date.  (Fix for bug 1079768.)
   delegate_->UpdateRenderViewSizeForRenderManager();
 
   if (will_focus_location_bar)
     delegate_->SetFocusToLocationBar(false);
-  else if (focus_render_view && render_view_host_->view())
-    RenderWidgetHostViewPort::FromRWHV(render_view_host_->view())->Focus();
+  else if (focus_render_view && render_view_host_->GetView())
+    RenderWidgetHostViewPort::FromRWHV(render_view_host_->GetView())->Focus();
 
   std::pair<RenderViewHost*, RenderViewHost*> details =
       std::make_pair(old_render_view_host, render_view_host_);
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
       content::Source<NavigationController>(
           &delegate_->GetControllerForRenderManager()),
       content::Details<std::pair<RenderViewHost*, RenderViewHost*> >(&details));
 
   // If the pending view was on the swapped out list, we can remove it.
-  swapped_out_hosts_.erase(render_view_host_->site_instance()->GetId());
+  swapped_out_hosts_.erase(render_view_host_->GetSiteInstance()->GetId());
 
   // If the old RVH is live, we are swapping it out and should keep track of it
   // in case we navigate back to it.
   if (old_render_view_host->IsRenderViewLive()) {
     DCHECK(old_render_view_host->is_swapped_out());
     // Temp fix for http://crbug.com/90867 until we do a better cleanup to make
     // sure we don't get different rvh instances for the same site instance
     // in the same rvhmgr.
     // TODO(creis): Clean this up.
-    int32 old_site_instance_id = old_render_view_host->site_instance()->GetId();
+    int32 old_site_instance_id =
+        old_render_view_host->GetSiteInstance()->GetId();
     RenderViewHostMap::iterator iter =
         swapped_out_hosts_.find(old_site_instance_id);
     if (iter != swapped_out_hosts_.end() &&
         iter->second != old_render_view_host) {
       // Shutdown the RVH that will be replaced in the map to avoid a leak.
       iter->second->Shutdown();
     }
     swapped_out_hosts_[old_site_instance_id] = old_render_view_host;
   } else {
     old_render_view_host->Shutdown();
   }
 
   // Let the task manager know that we've swapped RenderViewHosts, since it
   // might need to update its process groupings.
   delegate_->NotifySwappedFromRenderManager();
 }
 
-RenderViewHost* RenderViewHostManager::UpdateRendererStateForNavigate(
+RenderViewHostImpl* RenderViewHostManager::UpdateRendererStateForNavigate(
     const NavigationEntryImpl& entry) {
   // If we are cross-navigating, then we want to get back to normal and navigate
   // as usual.
   if (cross_navigation_pending_) {
     if (pending_render_view_host_)
       CancelPending();
     cross_navigation_pending_ = false;
   }
 
   // This will possibly create (set to NULL) a Web UI object for the pending
   // page. We'll use this later to give the page special access. This must
   // happen before the new renderer is created below so it will get bindings.
   // It must also happen after the above conditional call to CancelPending(),
   // otherwise CancelPending may clear the pending_web_ui_ and the page will
   // not have it's bindings set appropriately.
   pending_web_ui_.reset(delegate_->CreateWebUIForRenderManager(entry.GetURL()));
 
   // render_view_host_ will not be deleted before the end of this method, so we
   // don't have to worry about this SiteInstance's ref count dropping to zero.
-  SiteInstance* curr_instance = render_view_host_->site_instance();
+  SiteInstance* curr_instance = render_view_host_->GetSiteInstance();
 
   // Determine if we need a new SiteInstance for this entry.
   // Again, new_instance won't be deleted before the end of this method, so it
   // is safe to use a normal pointer here.
   SiteInstance* new_instance = curr_instance;
   bool force_swap = ShouldSwapProcessesForNavigation(
       delegate_->GetLastCommittedNavigationEntryForRenderManager(), &entry);
   if (ShouldTransitionCrossSite() || force_swap)
     new_instance = GetSiteInstanceForEntry(entry, curr_instance);
 
@@ skipping 17 matching lines @@
         CommitPending();
         return render_view_host_;
       } else {
         NOTREACHED();
         return render_view_host_;
       }
     }
     // Otherwise, it's safe to treat this as a pending cross-site transition.
 
     // Make sure the old render view stops, in case a load is in progress.
-    render_view_host_->Send(new ViewMsg_Stop(render_view_host_->routing_id()));
+    render_view_host_->Send(
+        new ViewMsg_Stop(render_view_host_->GetRoutingID()));
 
     // Suspend the new render view (i.e., don't let it send the cross-site
     // Navigate message) until we hear back from the old renderer's
     // onbeforeunload handler.  If the handler returns false, we'll have to
     // cancel the request.
     DCHECK(!pending_render_view_host_->are_navigations_suspended());
     pending_render_view_host_->SetNavigationsSuspended(true);
 
     // Tell the CrossSiteRequestManager that this RVH has a pending cross-site
     // request, so that ResourceDispatcherHost will know to tell us to run the
@@ skipping 11 matching lines @@
 
     return pending_render_view_host_;
   } else {
     if (pending_web_ui_.get() && render_view_host_->IsRenderViewLive())
       pending_web_ui_->GetController()->RenderViewReused(render_view_host_);
 
     // The renderer can exit view source mode when any error or cancellation
     // happen. We must overwrite to recover the mode.
     if (entry.IsViewSourceMode()) {
       render_view_host_->Send(
-          new ViewMsg_EnableViewSourceMode(render_view_host_->routing_id()));
+          new ViewMsg_EnableViewSourceMode(render_view_host_->GetRoutingID()));
     }
   }
 
   // Same SiteInstance can be used.  Navigate render_view_host_ if we are not
   // cross navigating.
   DCHECK(!cross_navigation_pending_);
   return render_view_host_;
 }
 
 void RenderViewHostManager::CancelPending() {
-  RenderViewHost* pending_render_view_host = pending_render_view_host_;
+  RenderViewHostImpl* pending_render_view_host = pending_render_view_host_;
   pending_render_view_host_ = NULL;
 
   content::DevToolsManagerImpl::GetInstance()->OnCancelPendingNavigation(
       pending_render_view_host,
       render_view_host_);
 
   // We no longer need to prevent the process from exiting.
-  pending_render_view_host->process()->RemovePendingView();
+  pending_render_view_host->GetProcess()->RemovePendingView();
 
   // The pending RVH may already be on the swapped out list if we started to
   // swap it back in and then canceled.  If so, make sure it gets swapped out
   // again.  If it's not on the swapped out list (e.g., aborting a pending
   // load), then it's safe to shut down.
   if (IsSwappedOut(pending_render_view_host)) {
     // Any currently suspended navigations are no longer needed.
     pending_render_view_host->CancelSuspendedNavigations();
 
     // We can pass -1,-1 because there is no pending response in the
@@ skipping 29 matching lines @@
        iter != swapped_out_hosts_.end();
        ++iter) {
     if (iter->second == rvh) {
       swapped_out_hosts_.erase(iter);
       break;
     }
   }
 }
 
 bool RenderViewHostManager::IsSwappedOut(RenderViewHost* rvh) {
-  if (!rvh->site_instance())
+  if (!rvh->GetSiteInstance())
     return false;
 
-  return swapped_out_hosts_.find(rvh->site_instance()->GetId()) !=
+  return swapped_out_hosts_.find(rvh->GetSiteInstance()->GetId()) !=
       swapped_out_hosts_.end();
 }