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 27 matching lines @@
 using content::WebUIControllerFactory;
 
 RenderViewHostManager::RenderViewHostManager(
     content::RenderViewHostDelegate* render_view_delegate,
     Delegate* delegate)
     : delegate_(delegate),
       cross_navigation_pending_(false),
       render_view_delegate_(render_view_delegate),
       render_view_host_(NULL),
       pending_render_view_host_(NULL),
+      pending_web_ui_(NULL),
       interstitial_page_(NULL) {
 }
 
 RenderViewHostManager::~RenderViewHostManager() {
   if (pending_render_view_host_)
     CancelPending();
 
   // We should always have a main RenderViewHost.
   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();
   }
+
+  FreePendingWebUI();
 }
 
 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);
@@ skipping 123 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 179 matching lines @@
   // 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())
     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(),

[Dan Beam, 2012/04/21 02:53:07]

can you split this into multiple lines?

[Evan Stade, 2012/04/24 17:52:40]

not easily.

+                             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())
+  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();
+  if (web_ui_.get() != pending_web_ui_)

[Dan Beam, 2012/04/21 02:53:07]

you don't really need .get() operators for scoped_ptr's IIRC, as they have a T*
operator

+    web_ui_.reset(pending_web_ui_);
+  pending_web_ui_ = NULL;
 
   // 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 62 matching lines @@
     }
     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();
 }
 

[Dan Beam, 2012/04/21 02:53:07]

why \n?

[Evan Stade, 2012/04/24 17:52:40]

Done.

+
 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 it's bindings set appropriately.

[Dan Beam, 2012/04/21 02:53:07]

its

[Evan Stade, 2012/04/24 17:52:40]

Done.

+    pending_web_ui_ = delegate_->CreateWebUIForRenderManager(entry.GetURL());
+
     // 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())
+    if (ShouldReuseWebUI(curr_entry, &entry))
+      pending_web_ui_ = web_ui_.get();
+    else
+      pending_web_ui_ = 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()));
     }
   }
 
@@ skipping 23 matching lines @@
     pending_render_view_host->CancelSuspendedNavigations();
 
     // 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();
+  FreePendingWebUI();
 }
 
 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();
 }
+
+void RenderViewHostManager::FreePendingWebUI() {
+  if (pending_web_ui_ && pending_web_ui_ != web_ui_.get())
+    delete pending_web_ui_;
+
+  pending_web_ui_ = NULL;
+}