re-use WebUIs

content/browser/web_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/web_contents/render_view_host_manager.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 188 matching lines @@
 
 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())
+    if (pending_web_ui())
       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) {
@@ skipping 131 matching lines @@
   }
 }
 
 bool RenderViewHostManager::ShouldTransitionCrossSite() {
   // True if we are using process-per-site-instance (default) or
   // process-per-site (kProcessPerSite).
   return !CommandLine::ForCurrentProcess()->HasSwitch(switches::kProcessPerTab);
 }
 
 bool RenderViewHostManager::ShouldSwapProcessesForNavigation(
-    const NavigationEntry* cur_entry,
+    const NavigationEntry* curr_entry,
     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
+  // page and one isn't.  If there's no curr_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() :
+  const GURL& current_url = (curr_entry) ? curr_entry->GetURL() :
       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.
       // Here, data URLs are never allowed.
       if (!web_ui_factory->IsURLAcceptableForWebUI(browser_context,
                                                    new_entry->GetURL(), false))
         return true;
     } else {
       // Force swap if it's a Web UI URL.
       if (web_ui_factory->UseWebUIForURL(browser_context, new_entry->GetURL()))
         return true;
     }
   }
 
   if (content::GetContentClient()->browser()->ShouldSwapProcessesForNavigation(
-          cur_entry ? cur_entry->GetURL() : GURL(), new_entry->GetURL())) {
+          curr_entry ? curr_entry->GetURL() : GURL(), new_entry->GetURL())) {
     return true;
   }
 
-  if (!cur_entry)
+  if (!curr_entry)
     return false;
 
   // We can't switch a RenderView between view source and non-view source mode
   // without screwing up the session history sometimes (when navigating between
   // "view-source:http://foo.com/" and "http://foo.com/", WebKit doesn't treat
   // it as a new navigation). So require a view switch.
-  if (cur_entry->IsViewSourceMode() != new_entry->IsViewSourceMode())
+  if (curr_entry->IsViewSourceMode() != new_entry->IsViewSourceMode())
     return true;
 
   return false;
 }
 
+bool RenderViewHostManager::ShouldReuseWebUI(
+    const NavigationEntry* curr_entry,
+    const NavigationEntryImpl* new_entry) const {
+  NavigationControllerImpl& controller =
+      delegate_->GetControllerForRenderManager();
+  WebUIControllerFactory* factory =
+      content::GetContentClient()->browser()->GetWebUIControllerFactory();
+  return curr_entry && web_ui_.get() &&
+      (factory->GetWebUIType(controller.GetBrowserContext(),
+                             curr_entry->GetURL()) ==
+       factory->GetWebUIType(controller.GetBrowserContext(),
+                             new_entry->GetURL()));
+}
+
 SiteInstance* RenderViewHostManager::GetSiteInstanceForEntry(
     const NavigationEntryImpl& entry,
     SiteInstance* curr_instance) {
   // NOTE: This is only called when ShouldTransitionCrossSite is true.
 
   const GURL& dest_url = entry.GetURL();
   NavigationControllerImpl& controller =
       delegate_->GetControllerForRenderManager();
   content::BrowserContext* browser_context = controller.GetBrowserContext();
 
@@ skipping 155 matching lines @@
   } 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.
-  if (pending_web_ui_.get())
-    render_view_host->AllowBindings(pending_web_ui_->GetBindings());
+  if (pending_web_ui())
+    render_view_host->AllowBindings(pending_web_ui()->GetBindings());
 
   return delegate_->CreateRenderViewForRenderManager(render_view_host);
 }
 
 void RenderViewHostManager::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.
-  web_ui_.swap(pending_web_ui_);
-  if (web_ui_.get() && pending_web_ui_.get() && !pending_render_view_host_)
-    web_ui_->GetController()->DidBecomeActiveForReusedRenderView();
-  pending_web_ui_.reset();
+  // 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()));
+  if (pending_web_ui_.get())
+    web_ui_.reset(pending_web_ui_.release());
+  else if (!pending_and_current_web_ui_.get())
+    web_ui_.reset();
 
   // It's possible for the pending_render_view_host_ to be NULL when we aren't
   // crossing process boundaries. If so, we just needed to handle the Web UI
   // committing above and we're done.
   if (!pending_render_view_host_) {
     if (will_focus_location_bar)
       delegate_->SetFocusToLocationBar(false);
     return;
   }
 
@@ skipping 73 matching lines @@
 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_->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);
+  const content::NavigationEntry* curr_entry =
+      delegate_->GetLastCommittedNavigationEntryForRenderManager();
+  bool force_swap = ShouldSwapProcessesForNavigation(curr_entry, &entry);
   if (ShouldTransitionCrossSite() || force_swap)
     new_instance = GetSiteInstanceForEntry(entry, curr_instance);
 
   if (new_instance != curr_instance || force_swap) {
     // New SiteInstance.
     DCHECK(!cross_navigation_pending_);
 
+    // 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 its bindings set appropriately.
+    pending_web_ui_.reset(
+        delegate_->CreateWebUIForRenderManager(entry.GetURL()));
+    pending_and_current_web_ui_.reset();
+
     // Create a pending RVH and navigate it.
     bool success = CreatePendingRenderView(entry, new_instance);
     if (!success)
       return NULL;
 
     // Check if our current RVH is live before we set up a transition.
     if (!render_view_host_->IsRenderViewLive()) {
       if (!cross_navigation_pending_) {
         // The current RVH is not live.  There's no reason to sit around with a
         // sad tab or a newly created RVH while we wait for the pending RVH to
@@ skipping 29 matching lines @@
     DCHECK(!cross_navigation_pending_);
     cross_navigation_pending_ = true;
 
     // Tell the old render view to run its onbeforeunload handler, since it
     // doesn't otherwise know that the cross-site request is happening.  This
     // will trigger a call to ShouldClosePage with the reply.
     render_view_host_->FirePageBeforeUnload(true);
 
     return pending_render_view_host_;
   } else {
-    if (pending_web_ui_.get() && render_view_host_->IsRenderViewLive())
-      pending_web_ui_->GetController()->RenderViewReused(render_view_host_);
+    if (ShouldReuseWebUI(curr_entry, &entry)) {
+      pending_web_ui_.reset();
+      pending_and_current_web_ui_ = web_ui_->AsWeakPtr();
+    } else {
+      pending_and_current_web_ui_.reset();
+      pending_web_ui_.reset(
+          delegate_->CreateWebUIForRenderManager(entry.GetURL()));
+    }
+
+    if (pending_web_ui() && 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_->GetRoutingID()));
     }
   }
 
   // Same SiteInstance can be used.  Navigate render_view_host_ if we are not
@@ skipping 23 matching lines @@
 
     // We can pass -1,-1 because there is no pending response in the
     // ResourceDispatcherHost to unpause.
     pending_render_view_host->SwapOut(-1, -1);
   } 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) {
   // 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
@@ skipping 17 matching lines @@
   }
 }
 
 bool RenderViewHostManager::IsSwappedOut(RenderViewHost* rvh) {
   if (!rvh->GetSiteInstance())
     return false;
 
   return swapped_out_hosts_.find(rvh->GetSiteInstance()->GetId()) !=
       swapped_out_hosts_.end();
 }