Rename RenderViewHostManager to RenderFrameHostManager.

content/browser/web_contents/web_contents_impl.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/web_contents/web_contents_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 113 matching lines @@
 //   whether it is a download.  If so, it sends a message to the new renderer
 //   causing it to cancel the request, and the download proceeds. For now, the
 //   pending RVH remains until the next DidNavigate event for this
 //   WebContentsImpl. This isn't ideal, but it doesn't affect any functionality.
 // - After RDH receives a response and determines that it is safe and not a
 //   download, the CrossSiteResourceHandler checks whether a process swap is
 //   needed (either because CrossSiteRequestManager has state for it or because
 //   a transfer was needed for a redirect).
 // - If so, CrossSiteResourceHandler pauses the response to first run the old
 //   page's unload handler.  It does this by asynchronously calling the
-//   OnCrossSiteResponse method of RenderViewHostManager on the UI thread, which
-//   sends a SwapOut message to the current RVH.
+//   OnCrossSiteResponse method of RenderFrameHostManager on the UI thread,
+//   which sends a SwapOut message to the current RVH.
 // - Once the unload handler is finished, RVHM::SwappedOut checks if a transfer
 //   to a new process is needed, based on the stored pending_nav_params_.  (This
 //   is independent of whether we started out with a cross-process navigation.)
 //   - If not, it just tells the ResourceDispatcherHost to resume the response
 //     to its current RenderViewHost.
 //   - If so, it cancels the current pending RenderViewHost and sets up a new
 //     navigation using RequestTransferURL.  When the transferred request
 //     arrives in the ResourceDispatcherHost, we transfer the response and
 //     resume it.
 // - The pending renderer sends a FrameNavigate message that invokes the
 //   DidNavigate method.  This replaces the current RVH with the
 //   pending RVH.
-// - The previous renderer is kept swapped out in RenderViewHostManager in case
+// - The previous renderer is kept swapped out in RenderFrameHostManager in case
 //   the user goes back.  The process only stays live if another tab is using
 //   it, but if so, the existing frame relationships will be maintained.
 
 namespace content {
 namespace {
 
 const char kDotGoogleDotCom[] = ".google.com";
 
 base::LazyInstance<std::vector<WebContentsImpl::CreatedCallback> >
 g_created_callbacks = LAZY_INSTANCE_INITIALIZER;
@@ skipping 299 matching lines @@
   new_contents->Init(create_params);
 
   // We are instantiating a WebContents for browser plugin. Set its subframe bit
   // to true.
   static_cast<RenderViewHostImpl*>(
       new_contents->GetRenderViewHost())->set_is_subframe(true);
 
   return new_contents->browser_plugin_guest_.get();
 }
 
-RenderViewHostManager* WebContentsImpl::GetRenderManagerForTesting() {
+RenderFrameHostManager* WebContentsImpl::GetRenderManagerForTesting() {
   return GetRenderManager();
 }
 
 bool WebContentsImpl::OnMessageReceived(RenderViewHost* render_view_host,
                                         const IPC::Message& message) {
   if (GetWebUI() &&
       static_cast<WebUIImpl*>(GetWebUI())->OnMessageReceived(message)) {
     return true;
   }
 
@@ skipping 533 matching lines @@
       NOTREACHED();
   }
 }
 
 WebContents* WebContentsImpl::GetWebContents() {
   return this;
 }
 
 void WebContentsImpl::Init(const WebContents::CreateParams& params) {
   // This is set before initializing the render manager since
-  // RenderViewHostManager::Init calls back into us via its delegate to ask if
+  // RenderFrameHostManager::Init calls back into us via its delegate to ask if
   // it should be hidden.
   should_normally_be_visible_ = !params.initially_hidden;
 
   GetRenderManager()->Init(
       params.browser_context, params.site_instance, params.routing_id,
       params.main_frame_routing_id);
 
   view_.reset(GetContentClient()->browser()->
       OverrideCreateWebContentsView(this, &render_view_host_delegate_view_));
   if (view_) {
@@ skipping 584 matching lines @@
 
   // 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() > kMaxURLChars) {
     LOG(WARNING) << "Refusing to load URL as it exceeds " << kMaxURLChars
                  << " characters.";
     return false;
   }
 
   // TODO(creis): Use entry->frame_tree_node_id() to pick which
-  // RenderViewHostManager to use.
+  // RenderFrameHostManager to use.
   RenderViewHostImpl* dest_render_view_host =
       static_cast<RenderViewHostImpl*>(GetRenderManager()->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->GetEnabledBindings();
   bool data_urls_allowed = delegate_ && delegate_->CanLoadDataURLsInWebUI();
   bool is_allowed_in_web_ui_renderer =
@@ skipping 450 matching lines @@
   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
     // which will cause a crash later one. There is also some code in
-    // RenderViewHostManager::RendererAbortedProvisionalLoad that is commented
+    // RenderFrameHostManager::RendererAbortedProvisionalLoad that is commented
     // out because of this problem.
     //
     // http://code.google.com/p/chromium/issues/detail?id=2855
     // Because this will not tear down the interstitial properly, if "back" is
     // back to another tab type, the interstitial will still be somewhat alive
     // in the previous tab type. If you navigate somewhere that activates the
     // tab with the interstitial again, you'll see a flash before the new load
     // commits of the interstitial page.
     if (ShowingInterstitialPage()) {
       LOG(WARNING) << "Discarding message during interstitial.";
@@ skipping 739 matching lines @@
   if (frame_tree_.IsFirstNavigationAfterSwap()) {
     // First navigation should be a main frame navigation.
     DCHECK(PageTransitionIsMainFrame(params.transition));
     frame_tree_.OnFirstNavigationAfterSwap(params.frame_id);
   }
 
   if (PageTransitionIsMainFrame(params.transition)) {
     // When overscroll navigation gesture is enabled, a screenshot of the page
     // in its current state is taken so that it can be used during the
     // nav-gesture. It is necessary to take the screenshot here, before calling
-    // RenderViewHostManager::DidNavigateMainFrame, because that can change
+    // RenderFrameHostManager::DidNavigateMainFrame, because that can change
     // WebContents::GetRenderViewHost to return the new host, instead of the one
     // that may have just been swapped out.
     if (delegate_ && delegate_->CanOverscrollContent())
       controller_.TakeScreenshot();
 
     GetRenderManager()->DidNavigateMainFrame(rvh);
   }
 
   // Update the site of the SiteInstance if it doesn't have one yet, unless
   // assigning a site is not necessary for this URL.  In that case, the
@@ skipping 767 matching lines @@
   RenderWidgetHostView* rwh_view = view_->CreateViewForWidget(rvh);
   // Can be NULL during tests.
   if (rwh_view)
     rwh_view->SetSize(GetView()->GetContainerSize());
 }
 
 bool WebContentsImpl::IsHidden() {
   return capturer_count_ == 0 && !should_normally_be_visible_;
 }
 
-RenderViewHostManager* WebContentsImpl::GetRenderManager() const {
+RenderFrameHostManager* WebContentsImpl::GetRenderManager() const {
   return frame_tree_.root()->render_manager();
 }
 
 RenderViewHostImpl* WebContentsImpl::GetRenderViewHostImpl() {
   return static_cast<RenderViewHostImpl*>(GetRenderViewHost());
 }
 
 BrowserPluginGuest* WebContentsImpl::GetBrowserPluginGuest() const {
   return browser_plugin_guest_.get();
 }
@@ skipping 37 matching lines @@
 }
 
 void WebContentsImpl::OnFrameRemoved(
     RenderViewHostImpl* render_view_host,
     int64 frame_id) {
    FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                      FrameDetached(render_view_host, frame_id));
 }
 
 }  // namespace content