Rename RenderViewHostManager to RenderFrameHostManager.

content/browser/frame_host/render_frame_host_manager.cc

 // Copyright 2013 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/frame_host/render_view_host_manager.h"
+#include "content/browser/frame_host/render_frame_host_manager.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/devtools/render_view_devtools_agent_host.h"
 #include "content/browser/frame_host/interstitial_page_impl.h"
 #include "content/browser/frame_host/navigation_controller_impl.h"
@@ skipping 10 matching lines @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_widget_host_iterator.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_ui_controller.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 
 namespace content {
 
-RenderViewHostManager::PendingNavigationParams::PendingNavigationParams()
+RenderFrameHostManager::PendingNavigationParams::PendingNavigationParams()
     : is_transfer(false), frame_id(-1), should_replace_current_entry(false) {
 }
 
-RenderViewHostManager::PendingNavigationParams::PendingNavigationParams(
+RenderFrameHostManager::PendingNavigationParams::PendingNavigationParams(
     const GlobalRequestID& global_request_id,
     bool is_transfer,
     const std::vector<GURL>& transfer_url_chain,
     Referrer referrer,
     PageTransition page_transition,
     int64 frame_id,
     bool should_replace_current_entry)
     : global_request_id(global_request_id),
       is_transfer(is_transfer),
       transfer_url_chain(transfer_url_chain),
       referrer(referrer),
       page_transition(page_transition),
       frame_id(frame_id),
       should_replace_current_entry(should_replace_current_entry) {
 }
 
-RenderViewHostManager::PendingNavigationParams::~PendingNavigationParams() {}
+RenderFrameHostManager::PendingNavigationParams::~PendingNavigationParams() {}
 
-RenderViewHostManager::RenderViewHostManager(
+RenderFrameHostManager::RenderFrameHostManager(
     RenderViewHostDelegate* render_view_delegate,
     RenderWidgetHostDelegate* render_widget_delegate,
     Delegate* delegate)
     : delegate_(delegate),
       cross_navigation_pending_(false),
       render_view_delegate_(render_view_delegate),
       render_widget_delegate_(render_widget_delegate),
       render_view_host_(NULL),
       pending_render_view_host_(NULL),
       interstitial_page_(NULL) {
 }
 
-RenderViewHostManager::~RenderViewHostManager() {
+RenderFrameHostManager::~RenderFrameHostManager() {
   if (pending_render_view_host_)
     CancelPending();
 
   // We should always have a main RenderViewHost except in some tests.
   RenderViewHostImpl* render_view_host = render_view_host_;
   render_view_host_ = NULL;
   if (render_view_host)
     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(BrowserContext* browser_context,
-                                 SiteInstance* site_instance,
-                                 int routing_id,
-                                 int main_frame_routing_id) {
+void RenderFrameHostManager::Init(BrowserContext* browser_context,
+                                  SiteInstance* site_instance,
+                                  int routing_id,
+                                  int main_frame_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_ = static_cast<RenderViewHostImpl*>(
       RenderViewHostFactory::Create(
           site_instance, render_view_delegate_, render_widget_delegate_,
           routing_id, main_frame_routing_id, false,
           delegate_->IsHidden()));
   render_view_host_->AttachToFrameTree();
 
   // Keep track of renderer processes as they start to shut down or are
   // crashed/killed.
   registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  NotificationService::AllSources());
   registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CLOSING,
                  NotificationService::AllSources());
 }
 
-RenderViewHostImpl* RenderViewHostManager::current_host() const {
+RenderViewHostImpl* RenderFrameHostManager::current_host() const {
   return render_view_host_;
 }
 
-RenderViewHostImpl* RenderViewHostManager::pending_render_view_host() const {
+RenderViewHostImpl* RenderFrameHostManager::pending_render_view_host() const {
   return pending_render_view_host_;
 }
 
-RenderWidgetHostView* RenderViewHostManager::GetRenderWidgetHostView() const {
+RenderWidgetHostView* RenderFrameHostManager::GetRenderWidgetHostView() const {
   if (interstitial_page_)
     return interstitial_page_->GetView();
   if (!render_view_host_)
     return NULL;
   return render_view_host_->GetView();
 }
 
-void RenderViewHostManager::SetPendingWebUI(const NavigationEntryImpl& entry) {
+void RenderFrameHostManager::SetPendingWebUI(const NavigationEntryImpl& entry) {
   pending_web_ui_.reset(
       delegate_->CreateWebUIForRenderManager(entry.GetURL()));
   pending_and_current_web_ui_.reset();
 
   // If we have assigned (zero or more) bindings to this NavigationEntry in the
   // past, make sure we're not granting it different bindings than it had
   // before.  If so, note it and don't give it any bindings, to avoid a
   // potential privilege escalation.
   if (pending_web_ui_.get() &&
       entry.bindings() != NavigationEntryImpl::kInvalidBindings &&
       pending_web_ui_->GetBindings() != entry.bindings()) {
     RecordAction(UserMetricsAction("ProcessSwapBindingsMismatch_RVHM"));
     pending_web_ui_.reset();
   }
 }
 
-RenderViewHostImpl* RenderViewHostManager::Navigate(
+RenderViewHostImpl* RenderFrameHostManager::Navigate(
     const NavigationEntryImpl& entry) {
-  TRACE_EVENT0("browser", "RenderViewHostManager:Navigate");
+  TRACE_EVENT0("browser", "RenderFrameHostManager:Navigate");
   // Create a pending RenderViewHost. It will give us the one we should use
   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_ &&
@@ skipping 22 matching lines @@
     } else {
       // This is our primary renderer, notify here as we won't be calling
       // CommitPending (which does the notify).
       delegate_->NotifySwappedFromRenderManager(NULL, render_view_host_);
     }
   }
 
   return dest_render_view_host;
 }
 
-void RenderViewHostManager::Stop() {
+void RenderFrameHostManager::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_->GetRoutingID()));
   }
 }
 
-void RenderViewHostManager::SetIsLoading(bool is_loading) {
+void RenderFrameHostManager::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() {
+bool RenderFrameHostManager::ShouldCloseTabOnUnresponsiveRenderer() {
   if (!cross_navigation_pending_)
     return true;
 
   // We should always have a pending RVH when there's a cross-process navigation
   // in progress.  Sanity check this for http://crbug.com/276333.
   CHECK(pending_render_view_host_);
 
   // If the tab becomes unresponsive during {before}unload while doing a
   // cross-site navigation, proceed with the navigation.  (This assumes that
   // the pending RenderViewHost is still responsive.)
@@ skipping 11 matching lines @@
     // that the beforeunload handler will later finish and possibly return
     // false (meaning the navigation should not proceed), but we'll ignore it
     // in this case because it took too long.
     if (pending_render_view_host_->are_navigations_suspended())
       pending_render_view_host_->SetNavigationsSuspended(
           false, base::TimeTicks::Now());
   }
   return false;
 }
 
-void RenderViewHostManager::SwappedOut(RenderViewHost* render_view_host) {
+void RenderFrameHostManager::SwappedOut(RenderViewHost* render_view_host) {
   // Make sure this is from our current RVH, and that we have a pending
   // navigation from OnCrossSiteResponse.  (There may be no pending navigation
   // for data URLs that don't make network requests, for example.)   If not,
   // just return early and ignore.
   if (render_view_host != render_view_host_ || !pending_nav_params_.get()) {
     pending_nav_params_.reset();
     return;
   }
 
   // Now that the unload handler has run, we need to either initiate the
@@ skipping 24 matching lines @@
   } else if (pending_render_view_host_) {
     RenderProcessHostImpl* pending_process =
         static_cast<RenderProcessHostImpl*>(
             pending_render_view_host_->GetProcess());
     pending_process->ResumeDeferredNavigation(
         pending_nav_params_->global_request_id);
   }
   pending_nav_params_.reset();
 }
 
-void RenderViewHostManager::DidNavigateMainFrame(
+void RenderFrameHostManager::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())
       CommitPending();
@@ skipping 14 matching lines @@
     // A navigation in the original page has taken place.  Cancel the pending
     // one.
     CancelPending();
     cross_navigation_pending_ = false;
   } else {
     // No one else should be sending us DidNavigate in this state.
     DCHECK(false);
   }
 }
 
-void RenderViewHostManager::DidDisownOpener(RenderViewHost* render_view_host) {
+void RenderFrameHostManager::DidDisownOpener(RenderViewHost* render_view_host) {
   // Notify all swapped out hosts, including the pending RVH.
   for (RenderViewHostMap::iterator iter = swapped_out_hosts_.begin();
        iter != swapped_out_hosts_.end();
        ++iter) {
     DCHECK_NE(iter->second->GetSiteInstance(),
               current_host()->GetSiteInstance());
     iter->second->DisownOpener();
   }
 }
 
-void RenderViewHostManager::RendererAbortedProvisionalLoad(
+void RenderFrameHostManager::RendererAbortedProvisionalLoad(
     RenderViewHost* render_view_host) {
   // We used to cancel the pending renderer here for cross-site downloads.
   // However, it's not safe to do that because the download logic repeatedly
   // looks for this WebContents based on a render view ID.  Instead, we just
   // leave the pending renderer around until the next navigation event
   // (Navigate, DidNavigate, etc), which will clean it up properly.
   // TODO(creis): All of this will go away when we move the cross-site logic
   // to ResourceDispatcherHost, so that we intercept responses rather than
   // navigation events.  (That's necessary to support onunload anyway.)  Once
   // we've made that change, we won't create a pending renderer until we know
   // the response is not a download.
 }
 
-void RenderViewHostManager::RendererProcessClosing(
+void RenderFrameHostManager::RendererProcessClosing(
     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->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();
   }
 }
 
-void RenderViewHostManager::ShouldClosePage(
+void RenderFrameHostManager::ShouldClosePage(
     bool for_cross_site_transition,
     bool proceed,
     const base::TimeTicks& proceed_time) {
   if (for_cross_site_transition) {
     // Ignore if we're not in a cross-site navigation.
     if (!cross_navigation_pending_)
       return;
 
     if (proceed) {
       // Ok to unload the current page, so proceed with the cross-site
@@ skipping 24 matching lines @@
         CancelPending();
         cross_navigation_pending_ = false;
       }
 
       // This is not a cross-site navigation, the tab is being closed.
       render_view_host_->ClosePage();
     }
   }
 }
 
-void RenderViewHostManager::OnCrossSiteResponse(
+void RenderFrameHostManager::OnCrossSiteResponse(
     RenderViewHost* pending_render_view_host,
     const GlobalRequestID& global_request_id,
     bool is_transfer,
     const std::vector<GURL>& transfer_url_chain,
     const Referrer& referrer,
     PageTransition page_transition,
     int64 frame_id,
     bool should_replace_current_entry) {
   // This should be called either when the pending RVH is ready to commit or
   // when we realize that the current RVH's request requires a transfer.
   DCHECK(
       pending_render_view_host == pending_render_view_host_ ||
       pending_render_view_host == render_view_host_);
 
   // TODO(creis): Eventually we will want to check all navigation responses
   // here, but currently we pass information for a transfer if
   // ShouldSwapProcessesForRedirect returned true in the network stack.
   // In that case, we should set up a transfer after the unload handler runs.
   // If is_transfer is false, we will just run the unload handler and resume.
   pending_nav_params_.reset(new PendingNavigationParams(
       global_request_id, is_transfer, transfer_url_chain, referrer,
       page_transition, frame_id, should_replace_current_entry));
 
   // Run the unload handler of the current page.
   SwapOutOldPage();
 }
 
-void RenderViewHostManager::SwapOutOldPage() {
+void RenderFrameHostManager::SwapOutOldPage() {
   // Should only see this while we have a pending renderer or transfer.
   CHECK(cross_navigation_pending_ || pending_nav_params_.get());
 
   // Tell the renderer to suppress any further modal dialogs so that we can swap
   // it out.  This must be done before canceling any current dialog, in case
   // there is a loop creating additional dialogs.
   render_view_host_->SuppressDialogsUntilSwapOut();
 
   // Now close any modal dialogs that would prevent us from swapping out.  This
   // must be done separately from SwapOut, so that the PageGroupLoadDeferrer is
   // no longer on the stack when we send the SwapOut message.
   delegate_->CancelModalDialogsForRenderManager();
 
   // Tell the old renderer it is being swapped out.  This will fire the unload
   // handler (without firing the beforeunload handler a second time).  When the
   // unload handler finishes and the navigation completes, we will send a
   // message to the ResourceDispatcherHost, allowing the pending RVH's response
   // to resume.
   render_view_host_->SwapOut();
 
   // ResourceDispatcherHost has told us to run the onunload handler, which
   // means it is not a download or unsafe page, and we are going to perform the
   // navigation.  Thus, we no longer need to remember that the RenderViewHost
   // is part of a pending cross-site request.
   if (pending_render_view_host_)
     pending_render_view_host_->SetHasPendingCrossSiteRequest(false);
 }
 
-void RenderViewHostManager::Observe(
+void RenderFrameHostManager::Observe(
     int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   switch (type) {
     case NOTIFICATION_RENDERER_PROCESS_CLOSED:
     case NOTIFICATION_RENDERER_PROCESS_CLOSING:
       RendererProcessClosing(
           Source<RenderProcessHost>(source).ptr());
       break;
 
     default:
       NOTREACHED();
   }
 }
 
-bool RenderViewHostManager::ShouldTransitionCrossSite() {
+bool RenderFrameHostManager::ShouldTransitionCrossSite() {
   // False in the single-process mode, as it makes RVHs to accumulate
   // in swapped_out_hosts_.
   // True if we are using process-per-site-instance (default) or
   // process-per-site (kProcessPerSite).
   return
       !CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess) &&
       !CommandLine::ForCurrentProcess()->HasSwitch(switches::kProcessPerTab);
 }
 
-bool RenderViewHostManager::ShouldSwapBrowsingInstancesForNavigation(
+bool RenderFrameHostManager::ShouldSwapBrowsingInstancesForNavigation(
     const NavigationEntry* current_entry,
     const NavigationEntryImpl* new_entry) const {
   DCHECK(new_entry);
 
   // If new_entry already has a SiteInstance, assume it is correct and use it.
   if (new_entry->site_instance())
     return false;
 
   // Check for reasons to swap processes even if we are in a process model that
   // doesn't usually swap (e.g., process-per-tab).  Any time we return true,
@@ skipping 41 matching lines @@
   // without screwing up the session history sometimes (when navigating between
   // "view-source:http://foo.com/" and "http://foo.com/", Blink doesn't treat
   // it as a new navigation). So require a BrowsingInstance switch.
   if (current_entry &&
       current_entry->IsViewSourceMode() != new_entry->IsViewSourceMode())
     return true;
 
   return false;
 }
 
-bool RenderViewHostManager::ShouldReuseWebUI(
+bool RenderFrameHostManager::ShouldReuseWebUI(
     const NavigationEntry* current_entry,
     const NavigationEntryImpl* new_entry) const {
   NavigationControllerImpl& controller =
       delegate_->GetControllerForRenderManager();
   return current_entry && web_ui_.get() &&
       (WebUIControllerFactoryRegistry::GetInstance()->GetWebUIType(
           controller.GetBrowserContext(), current_entry->GetURL()) ==
        WebUIControllerFactoryRegistry::GetInstance()->GetWebUIType(
           controller.GetBrowserContext(), new_entry->GetURL()));
 }
 
-SiteInstance* RenderViewHostManager::GetSiteInstanceForEntry(
+SiteInstance* RenderFrameHostManager::GetSiteInstanceForEntry(
     const NavigationEntryImpl& entry,
     SiteInstance* current_instance,
     bool force_browsing_instance_swap) {
   // Determine which SiteInstance to use for navigating to |entry|.
   const GURL& dest_url = entry.GetURL();
   NavigationControllerImpl& controller =
       delegate_->GetControllerForRenderManager();
   BrowserContext* browser_context = controller.GetBrowserContext();
 
   // If a swap is required, we need to force the SiteInstance AND
@@ skipping 132 matching lines @@
   }
 
   // Start the new renderer in a new SiteInstance, but in the current
   // BrowsingInstance.  It is important to immediately give this new
   // SiteInstance to a RenderViewHost (if it is different than our current
   // SiteInstance), so that it is ref counted.  This will happen in
   // CreateRenderView.
   return current_instance->GetRelatedSiteInstance(dest_url);
 }
 
-int RenderViewHostManager::CreateRenderView(
+int RenderFrameHostManager::CreateRenderView(
     SiteInstance* instance,
     int opener_route_id,
     bool swapped_out,
     bool hidden) {
   CHECK(instance);
   DCHECK(!swapped_out || hidden); // Swapped out views should always be hidden.
 
   // We are creating a pending or swapped out RVH here.  We should never create
   // it in the same SiteInstance as our current RVH.
   CHECK_NE(render_view_host_->GetSiteInstance(), instance);
@@ skipping 35 matching lines @@
     }
   }
 
   // Use this as our new pending RVH if it isn't swapped out.
   if (!swapped_out)
     pending_render_view_host_ = new_render_view_host;
 
   return new_render_view_host->GetRoutingID();
 }
 
-bool RenderViewHostManager::InitRenderView(RenderViewHost* render_view_host,
-                                           int opener_route_id) {
+bool RenderFrameHostManager::InitRenderView(RenderViewHost* render_view_host,
+                                            int opener_route_id) {
   // If the pending navigation is to a WebUI and the RenderView is not in a
   // guest process, tell the RenderView about any bindings it will need enabled.
   if (pending_web_ui() && !render_view_host->GetProcess()->IsGuest()) {
     render_view_host->AllowBindings(pending_web_ui()->GetBindings());
   } else {
     // Ensure that we don't create an unprivileged RenderView in a WebUI-enabled
     // process.
     CHECK(!ChildProcessSecurityPolicyImpl::GetInstance()->HasWebUIBindings(
               render_view_host->GetProcess()->GetID()));
   }
 
   return delegate_->CreateRenderViewForRenderManager(render_view_host,
                                                      opener_route_id);
 }
 
-void RenderViewHostManager::CommitPending() {
+void RenderFrameHostManager::CommitPending() {
   // First check whether we're going to want to focus the location bar after
   // this commit.  We do this now because the navigation hasn't formally
   // committed yet, so if we've already cleared |pending_web_ui_| the call chain
   // this triggers won't be able to figure out what's going on.
   bool will_focus_location_bar = delegate_->FocusLocationBarByDefault();
 
   // Next commit the Web UI, if any. Either replace |web_ui_| with
   // |pending_web_ui_|, or clear |web_ui_| if there is no pending WebUI, or
   // leave |web_ui_| as is if reusing it.
   DCHECK(!(pending_web_ui_.get() && pending_and_current_web_ui_.get()));
@@ skipping 84 matching lines @@
       // 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();
     old_render_view_host = NULL;  // Shutdown() deletes it.
   }
 }
 
-void RenderViewHostManager::ShutdownRenderViewHostsInSiteInstance(
+void RenderFrameHostManager::ShutdownRenderViewHostsInSiteInstance(
     int32 site_instance_id) {
   // First remove any swapped out RVH for this SiteInstance from our
   // list.
   swapped_out_hosts_.erase(site_instance_id);
 
   scoped_ptr<RenderWidgetHostIterator> widgets(
       RenderWidgetHostImpl::GetAllRenderWidgetHosts());
   while (RenderWidgetHost* widget = widgets->GetNextHost()) {
     if (!widget->IsRenderView())
       continue;
     RenderViewHostImpl* rvh =
         static_cast<RenderViewHostImpl*>(RenderViewHost::From(widget));
     if (site_instance_id == rvh->GetSiteInstance()->GetId())
       rvh->Shutdown();
   }
 }
 
-RenderViewHostImpl* RenderViewHostManager::UpdateRendererStateForNavigate(
+RenderViewHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate(
     const NavigationEntryImpl& entry) {
   // If we are currently navigating cross-process, we want to get back to normal
   // and then navigate as usual.
   if (cross_navigation_pending_) {
     if (pending_render_view_host_)
       CancelPending();
     cross_navigation_pending_ = false;
   }
 
   // render_view_host_'s SiteInstance and new_instance will not be deleted
@@ skipping 131 matching lines @@
   // 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_->GetRoutingID()));
   }
 
   return render_view_host_;
 }
 
-void RenderViewHostManager::CancelPending() {
+void RenderFrameHostManager::CancelPending() {
   RenderViewHostImpl* pending_render_view_host = pending_render_view_host_;
   pending_render_view_host_ = NULL;
 
   RenderViewDevToolsAgentHost::OnCancelPendingNavigation(
       pending_render_view_host,
       render_view_host_);
 
   // We no longer need to prevent the process from exiting.
   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 (IsOnSwappedOutList(pending_render_view_host)) {
     // Any currently suspended navigations are no longer needed.
     pending_render_view_host->CancelSuspendedNavigations();
 
     pending_render_view_host->SwapOut();
   } else {
     // We won't be coming back, so shut this one down.
     pending_render_view_host->Shutdown();
   }
 
   pending_web_ui_.reset();
   pending_and_current_web_ui_.reset();
 }
 
-void RenderViewHostManager::RenderViewDeleted(RenderViewHost* rvh) {
+void RenderFrameHostManager::RenderViewDeleted(RenderViewHost* rvh) {
   // We are doing this in order to work around and to track a crasher
   // (http://crbug.com/23411) where it seems that pending_render_view_host_ is
   // deleted (not sure from where) but not NULLed.
   if (rvh == pending_render_view_host_) {
     // If you hit this NOTREACHED, please report it in the following bug
     // http://crbug.com/23411 Make sure to include what you were doing when it
     // happened  (navigating to a new page, closing a tab...) and if you can
     // reproduce.
     NOTREACHED();
     pending_render_view_host_ = NULL;
   }
 
   // Make sure deleted RVHs are not kept in the swapped out list while we are
   // still alive.  (If render_view_host_ is null, we're already being deleted.)
   if (!render_view_host_)
     return;
   // We can't look it up by SiteInstance ID, which may no longer be valid.
   for (RenderViewHostMap::iterator iter = swapped_out_hosts_.begin();
        iter != swapped_out_hosts_.end();
        ++iter) {
     if (iter->second == rvh) {
       swapped_out_hosts_.erase(iter);
       break;
     }
   }
 }
 
-bool RenderViewHostManager::IsOnSwappedOutList(RenderViewHost* rvh) const {
+bool RenderFrameHostManager::IsOnSwappedOutList(RenderViewHost* rvh) const {
   if (!rvh->GetSiteInstance())
     return false;
 
   RenderViewHostMap::const_iterator iter = swapped_out_hosts_.find(
       rvh->GetSiteInstance()->GetId());
   if (iter == swapped_out_hosts_.end())
     return false;
 
   return iter->second == rvh;
 }
 
-RenderViewHostImpl* RenderViewHostManager::GetSwappedOutRenderViewHost(
+RenderViewHostImpl* RenderFrameHostManager::GetSwappedOutRenderViewHost(
     SiteInstance* instance) {
   RenderViewHostMap::iterator iter = swapped_out_hosts_.find(instance->GetId());
   if (iter != swapped_out_hosts_.end())
     return iter->second;
 
   return NULL;
 }
 
 }  // namespace content