Make the bookmarks bar disappear when the load after the new tab page commits...

chrome/browser/tab_contents/render_view_host_manager.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/tab_contents/render_view_host_manager.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
+#include "chrome/browser/dom_ui/dom_ui.h"
 #include "chrome/browser/dom_ui/dom_ui_factory.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_view_host_delegate.h"
 #include "chrome/browser/renderer_host/render_widget_host_view.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/site_instance.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
@@ skipping 31 matching lines @@
   // immediately give this SiteInstance to a RenderViewHost so that it is
   // ref counted.
   if (!site_instance)
     site_instance = SiteInstance::CreateSiteInstance(profile);
   render_view_host_ = CreateRenderViewHost(
       site_instance, routing_id, modal_dialog_event);
 }
 
 void RenderViewHostManager::Shutdown() {
   if (pending_render_view_host_)
-    CancelPendingRenderView();
+    CancelPending();
 
   // We should always have a main RenderViewHost.
   RenderViewHost* render_view_host = render_view_host_;
   render_view_host_ = NULL;
   render_view_host->Shutdown();
 }
 
 RenderViewHost* RenderViewHostManager::Navigate(const NavigationEntry& entry) {
-  RenderViewHost* dest_render_view_host = UpdateRendererStateNavigate(entry);
+  // This will possibly create (set to NULL) a DOM 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.
+  pending_dom_ui_.reset(delegate_->CreateDOMUIForRenderManager(entry.url()));
+
+  // Create a pending RenderViewHost. It will give us the one we should use
+  RenderViewHost* dest_render_view_host = 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()) {
     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 (!delegate_->CreateRenderViewForRenderManager(dest_render_view_host))
       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();
     } else {
       // This is our primary renderer, notify here as we won't be calling
-      // SwapToRenderView (which does the notify).
+      // CommitPending (which does the notify).
       RenderViewHostSwitchedDetails details;
       details.new_host = render_view_host_;
       details.old_host = NULL;
       NotificationService::current()->Notify(
           NotificationType::RENDER_VIEW_HOST_CHANGED,
           Source<NavigationController>(
               delegate_->GetControllerForRenderManager()),
           Details<RenderViewHostSwitchedDetails>(&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_) {
+  if (cross_navigation_pending_)
     pending_render_view_host_->Stop();
-
-  }
 }
 
 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() {
   if (!cross_navigation_pending_)
@@ skipping 21 matching lines @@
     // CrossSiteResourceHandler will already be cleaned up.)
     current_host()->process()->CrossSiteClosePageACK(
         pending_render_view_host_->process()->pid(), pending_request_id);
   }
   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 DOM UI.
+    if (pending_dom_ui_.get())
+      CommitPending();
     return;
   }
 
   if (render_view_host == pending_render_view_host_) {
     // The pending cross-site navigation completed, so show the renderer.
-    SwapToRenderView(&pending_render_view_host_, true);
+    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.
-    CancelPendingRenderView();
+    CancelPending();
     cross_navigation_pending_ = false;
   } else {
     // No one else should be sending us DidNavigate in this state.
     DCHECK(false);
   }
 }
 
 void RenderViewHostManager::OnCrossSiteResponse(int new_render_process_host_id,
                                                 int new_request_id) {
   // Should only see this while we have a pending renderer.
@@ skipping 47 matching lines @@
   if (proceed) {
     // Ok to unload the current page, so proceed with the cross-site
     // navigation.  Note that if navigations are not currently suspended, it
     // might be because the renderer was deemed unresponsive and this call was
     // already made by ShouldCloseTabOnUnresponsiveRenderer.  In that case, it
     // is ok to do nothing here.
     if (pending_render_view_host_->are_navigations_suspended())
       pending_render_view_host_->SetNavigationsSuspended(false);
   } else {
     // Current page says to cancel.
-    CancelPendingRenderView();
+    CancelPending();
     cross_navigation_pending_ = false;
   }
 }
 
 void RenderViewHostManager::OnJavaScriptMessageBoxClosed(
     IPC::Message* reply_msg,
     bool success,
     const std::wstring& prompt) {
   render_view_host_->JavaScriptMessageBoxClosed(reply_msg, success, prompt);
 }
@@ skipping 139 matching lines @@
 
   pending_render_view_host_ =
       CreateRenderViewHost(instance, MSG_ROUTING_NONE, NULL);
 
   bool success = delegate_->CreateRenderViewForRenderManager(
       pending_render_view_host_);
   if (success) {
     // Don't show the view until we get a DidNavigate from it.
     pending_render_view_host_->view()->Hide();
   } else {
-    CancelPendingRenderView();
+    CancelPending();
   }
   return success;
 }
 
 RenderViewHost* RenderViewHostManager::CreateRenderViewHost(
     SiteInstance* instance,
     int routing_id,
     base::WaitableEvent* modal_dialog_event) {
   if (render_view_factory_) {
     return render_view_factory_->CreateRenderViewHost(
         instance, render_view_delegate_, routing_id, modal_dialog_event);
   } else {
     return new RenderViewHost(instance, render_view_delegate_, routing_id,
                               modal_dialog_event);
   }
 }
 
-void RenderViewHostManager::SwapToRenderView(
-    RenderViewHost** new_render_view_host,
-    bool destroy_after) {
+void RenderViewHostManager::CommitPending() {
+  // First commit the DOM UI, if any.
+  dom_ui_.swap(pending_dom_ui_);
+  pending_dom_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 DOM UI
+  // committing above and we're done.
+  if (!pending_render_view_host_)
+    return;
+
   // Remember if the page was focused so we can focus the new renderer in
   // that case.
   bool focus_render_view = render_view_host_->view() &&
       render_view_host_->view()->HasFocus();
 
   // Hide the current view and prepare to destroy it.
   // TODO(creis): Get the old RenderViewHost to send us an UpdateState message
   // before we destroy it.
   if (render_view_host_->view())
     render_view_host_->view()->Hide();
   RenderViewHost* old_render_view_host = render_view_host_;
 
   // Swap in the pending view and make it active.
-  render_view_host_ = (*new_render_view_host);
-  (*new_render_view_host) = NULL;
+  render_view_host_ = pending_render_view_host_;
+  pending_render_view_host_ = NULL;
 
   // 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();
   else
     delegate_->RenderViewGoneFromRenderManager(render_view_host_);
 
   // Make sure the size is up to date.  (Fix for bug 1079768.)
   delegate_->UpdateRenderViewSizeForRenderManager();
 
   if (focus_render_view && render_view_host_->view())
     render_view_host_->view()->Focus();
 
   RenderViewHostSwitchedDetails details;
   details.new_host = render_view_host_;
   details.old_host = old_render_view_host;
   NotificationService::current()->Notify(
       NotificationType::RENDER_VIEW_HOST_CHANGED,
       Source<NavigationController>(delegate_->GetControllerForRenderManager()),
       Details<RenderViewHostSwitchedDetails>(&details));
 
-  if (destroy_after)
-    old_render_view_host->Shutdown();
+  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::UpdateRendererStateNavigate(
+RenderViewHost* RenderViewHostManager::UpdateRendererStateForNavigate(
     const NavigationEntry& 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_)
-      CancelPendingRenderView();
+      CancelPending();
     cross_navigation_pending_ = false;
   }
 
   // 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();
 
   // 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;
   if (ShouldTransitionCrossSite())
     new_instance = GetSiteInstanceForEntry(entry, curr_instance);
 
-  if (new_instance != curr_instance || ShouldSwapRenderViewsForNavigation(
+  if (new_instance != curr_instance ||
+      ShouldSwapRenderViewsForNavigation(
           delegate_->GetLastCommittedNavigationEntryForRenderManager(),
           &entry)) {
     // New SiteInstance.
     DCHECK(!cross_navigation_pending_);
 
     // Create a pending RVH and navigate it.
     bool success = CreatePendingRenderView(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
         // navigate.  Just switch to the pending RVH now and go back to non
         // cross-navigating (Note that we don't care about on{before}unload
         // handlers if the current RVH isn't live.)
-        SwapToRenderView(&pending_render_view_host_, true);
+        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_->Stop();
@@ skipping 21 matching lines @@
 
     return pending_render_view_host_;
   }
 
   // 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::CancelPendingRenderView() {
+void RenderViewHostManager::CancelPending() {
   RenderViewHost* pending_render_view_host = pending_render_view_host_;
   pending_render_view_host_ = NULL;
   pending_render_view_host->Shutdown();
+
+  pending_dom_ui_.reset();
 }
 
 void RenderViewHostManager::CrossSiteNavigationCanceled() {
   DCHECK(cross_navigation_pending_);
   cross_navigation_pending_ = false;
   if (pending_render_view_host_)
-    CancelPendingRenderView();
+    CancelPending();
 }