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

chrome/browser/tab_contents/web_contents.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/web_contents.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_version_info.h"
 #include "base/process_util.h"
@@ skipping 329 matching lines @@
   // Clean up subwindows like plugins and the find in page bar.
   view_->OnContentsDestroy();
 
   NotifyDisconnected();
   HungRendererWarning::HideForWebContents(this);
   render_manager_.Shutdown();
   TabContents::Destroy();
 }
 
 const string16& WebContents::GetTitle() const {
-  if (dom_ui_.get()) {
+  DOMUI* our_dom_ui = render_manager_.pending_dom_ui() ?
+      render_manager_.pending_dom_ui() : render_manager_.dom_ui();
+  if (our_dom_ui) {
     // Give the DOM UI the chance to override our title.
-    const string16& title = dom_ui_->overridden_title();
+    const string16& title = our_dom_ui->overridden_title();
     if (!title.empty())
       return title;
   }
   return TabContents::GetTitle();
 }
 
 SiteInstance* WebContents::GetSiteInstance() const {
   return render_manager_.current_host()->site_instance();
 }
 
 bool WebContents::ShouldDisplayURL() {
-  if (dom_ui_.get())
-    return !dom_ui_->should_hide_url();
+  if (controller()->GetPendingEntry()) {
+    // When there is a pending entry, that should determine whether the URL is
+    // displayed (including getting the default behavior if the DOMUI doesn't
+    // specify).
+    if (render_manager_.pending_dom_ui())
+      return !render_manager_.pending_dom_ui()->should_hide_url();
+    return true;
+  }
+
+  if (render_manager_.dom_ui())
+    return !render_manager_.dom_ui()->should_hide_url();
   return true;
 }
 
 bool WebContents::ShouldDisplayFavIcon() {
-  if (dom_ui_.get())
-    return !dom_ui_->hide_favicon();
+  if (controller()->GetPendingEntry()) {
+    // See ShouldDisplayURL.
+    if (render_manager_.pending_dom_ui())
+      return !render_manager_.pending_dom_ui()->hide_favicon();
+    return true;
+  }
+  
+  if (render_manager_.dom_ui())
+    return !render_manager_.dom_ui()->hide_favicon();
   return true;
 }
 
 std::wstring WebContents::GetStatusText() const {
   if (!is_loading() || load_state_ == net::LOAD_STATE_IDLE)
     return std::wstring();
 
   switch (load_state_) {
     case net::LOAD_STATE_WAITING_FOR_CACHE:
       return l10n_util::GetString(IDS_LOAD_STATE_WAITING_FOR_CACHE);
@@ skipping 13 matching lines @@
     case net::LOAD_STATE_READING_RESPONSE:
       break;
   }
 
   return std::wstring();
 }
 
 bool WebContents::NavigateToPendingEntry(bool reload) {
   const NavigationEntry& entry = *controller()->GetPendingEntry();
 
-  // This will possibly create (or NULL out) a DOM UI object for the page. We'll
-  // use this later when the page starts doing stuff to allow it to do so.
-  dom_ui_.reset(DOMUIFactory::CreateDOMUIForURL(this, entry.url()));
-
   RenderViewHost* dest_render_view_host = render_manager_.Navigate(entry);
   if (!dest_render_view_host)
     return false;  // Unable to create the desired render view host.
 
   // Used for page load time metrics.
   current_load_start_ = TimeTicks::Now();
 
   // Navigate in the desired RenderViewHost.
   dest_render_view_host->NavigateToEntry(entry, reload);
 
@@ skipping 92 matching lines @@
   // TODO(pkasting): http://b/1239839  Right now we purposefully don't call
   // our superclass HideContents(), because some callers want to be very picky
   // about the order in which these get called.  In addition to making the code
   // here practically impossible to understand, this also means we end up
   // calling TabContents::WasHidden() twice if callers call both versions of
   // HideContents() on a WebContents.
   WasHidden();
 }
 
 bool WebContents::IsBookmarkBarAlwaysVisible() {
-  if (dom_ui_.get())
-    return dom_ui_->force_bookmark_bar_visible();
+  // We want the bookmarks bar to go with the committed entry. This way, when
+  // you're on the new tab page and navigate, the bookmarks bar doesn't
+  // disappear until the next load commits (the same time the page changes).
+  if (!controller()->GetLastCommittedEntry()) {
+    // However, when there is no committed entry (the first load of the tab),
+    // then we fall back on the pending entry. This means that the bookmarks bar
+    // will be visible before the new tab page load commits.
+    if (render_manager_.pending_dom_ui())
+      return render_manager_.pending_dom_ui()->force_bookmark_bar_visible();
+    return false;
+  }
+
+  if (render_manager_.dom_ui())
+    return render_manager_.dom_ui()->force_bookmark_bar_visible();
   return false;
 }
 
 void WebContents::SetDownloadShelfVisible(bool visible) {
   TabContents::SetDownloadShelfVisible(visible);
   if (visible) {
     // Always set this value as it reflects the last time the download shelf
     // was made visible (even if it was already visible).
     last_download_shelf_show_ = TimeTicks::Now();
   }
 }
 
 void WebContents::PopupNotificationVisibilityChanged(bool visible) {
   render_view_host()->PopupNotificationVisibilityChanged(visible);
 }
 
 bool WebContents::FocusLocationBarByDefault() {
-  // Allow the DOM Ui to override the default.
-  if (dom_ui_.get())
-    return dom_ui_->focus_location_bar_by_default();
+  // Allow the DOM UI to override the default. We use the pending DOM UI since
+  // that's what the user "just did" so should control what happens after they
+  // did it. Using the committed one would mean when they navigate from a DOMUI
+  // to a regular page, the location bar would be focused.
+  if (render_manager_.pending_dom_ui())
+    return render_manager_.pending_dom_ui()->focus_location_bar_by_default();
   return false;
 }
 
 // Stupid view pass-throughs
 void WebContents::CreateView() {
   view_->CreateView();
 }
 
 gfx::NativeView WebContents::GetNativeView() const {
   return view_->GetNativeView();
@@ skipping 166 matching lines @@
   return profile();
 }
 
 void WebContents::RenderViewCreated(RenderViewHost* render_view_host) {
   if (!controller())
     return;
   NavigationEntry* entry = controller()->GetActiveEntry();
   if (!entry)
     return;
 
-  if (dom_ui_.get()) {
-    dom_ui_->RenderViewCreated(render_view_host);
+  // When we're creating views, we're still doing initial setup, so we always
+  // use the pending DOM UI rather than any possibly existing committed one.
+  if (render_manager_.pending_dom_ui()) {
+    render_manager_.pending_dom_ui()->RenderViewCreated(render_view_host);
   } else if (entry->IsViewSourceMode()) {
     // Put the renderer in view source mode.
     render_view_host->Send(
         new ViewMsg_EnableViewSourceMode(render_view_host->routing_id()));
   }
 }
 
 void WebContents::RenderViewReady(RenderViewHost* rvh) {
   if (rvh != render_view_host()) {
     // Don't notify the world, since this came from a renderer in the
@@ skipping 322 matching lines @@
   // request. If we end up with another place invoking DownloadImage, probably
   // best to refactor out into notification service, or something similar.
   if (errored)
     fav_icon_helper_.FavIconDownloadFailed(id);
   else
     fav_icon_helper_.SetFavIcon(id, image_url, image);
 }
 
 void WebContents::RequestOpenURL(const GURL& url, const GURL& referrer,
                                  WindowOpenDisposition disposition) {
-  if (dom_ui_.get()) {
+  if (render_manager_.dom_ui()) {
     // When we're a DOM UI, it will provide a page transition type for us (this
     // is so the new tab page can specify AUTO_BOOKMARK for automatically
     // generated suggestions).
     //
     // Note also that we hide the referrer for DOM UI pages. We don't really
     // want web sites to see a referrer of "chrome-ui://blah" (and some
     // chrome-ui URLs might have search terms or other stuff we don't want to
     // send to the site), so we send no referrer.
-    OpenURL(url, GURL(), disposition, dom_ui_->link_transition_type());
+    OpenURL(url, GURL(), disposition,
+            render_manager_.dom_ui()->link_transition_type());
   } else {
     OpenURL(url, referrer, disposition, PageTransition::LINK);
   }
 }
 
 void WebContents::DomOperationResponse(const std::string& json_string,
                                        int automation_id) {
   DomOperationNotificationDetails details(json_string, automation_id);
   NotificationService::current()->Notify(
       NotificationType::DOM_OPERATION_RESPONSE, Source<WebContents>(this),
       Details<DomOperationNotificationDetails>(&details));
 }
 
 void WebContents::ProcessDOMUIMessage(const std::string& message,
                                       const std::string& content) {
-  if (!dom_ui_.get()) {
+  if (!render_manager_.dom_ui()) {
     // We shouldn't get a DOM UI message when we haven't enabled the DOM UI.
     // Because the renderer might be owned and sending random messages, we need
     // to ignore these inproper ones.
     NOTREACHED();
     return;
   }
-  dom_ui_->ProcessDOMUIMessage(message, content);
+  render_manager_.dom_ui()->ProcessDOMUIMessage(message, content);
 }
 
 void WebContents::ProcessExternalHostMessage(const std::string& message,
                                              const std::string& origin,
                                              const std::string& target) {
   if (delegate())
     delegate()->ForwardMessageToExternalHost(message, origin, target);
 }
 
 void WebContents::GoToEntryAtOffset(int offset) {
@@ skipping 281 matching lines @@
   web_prefs.default_encoding =
       CharacterEncoding::GetCanonicalEncodingNameByAliasName(
           web_prefs.default_encoding);
   if (web_prefs.default_encoding.empty()) {
     prefs->ClearPref(prefs::kDefaultCharset);
     web_prefs.default_encoding = prefs->GetString(
         prefs::kDefaultCharset);
   }
   DCHECK(!web_prefs.default_encoding.empty());
 
-  // Override some prefs when we're a DOM UI, or the pages won't work.
-  if (dom_ui_.get()) {
+  // Override some prefs when we're a DOM UI, or the pages won't work. This is
+  // called during setup, so we will always use the pending one.
+  if (render_manager_.pending_dom_ui()) {
     web_prefs.loads_images_automatically = true;
     web_prefs.javascript_enabled = true;
   }
 
   return web_prefs;
 }
 
 void WebContents::OnMissingPluginStatus(int status) {
 #if defined(OS_WIN)
 // TODO(PORT): pull in when plug-ins work
@@ skipping 155 matching lines @@
     bool* proceed_to_fire_unload) {
   if (delegate())
     delegate()->BeforeUnloadFired(this, proceed, proceed_to_fire_unload);
 }
 
 void WebContents::UpdateRenderViewSizeForRenderManager() {
   // TODO(brettw) this is a hack. See WebContentsView::SizeContents.
   view_->SizeContents(view_->GetContainerSize());
 }
 
+DOMUI* WebContents::CreateDOMUIForRenderManager(const GURL& url) {
+  return DOMUIFactory::CreateDOMUIForURL(this, url);
+}
+
 NavigationEntry*
 WebContents::GetLastCommittedNavigationEntryForRenderManager() {
   if (!controller())
     return NULL;
   return controller()->GetLastCommittedEntry();
 }
 
 bool WebContents::CreateRenderViewForRenderManager(
     RenderViewHost* render_view_host) {
   // When we're running a DOM UI, the RenderViewHost needs to be put in DOM UI
-  // mode before CreateRenderView is called.
-  if (dom_ui_.get())
+  // mode before CreateRenderView is called. When we're asked to create a
+  // enderView, that means it's for the pending entry, so we have to use the

[jcampan, 2009/03/25 17:01:43]

Nit: typo enderView -> RenderView

+  // pending DOM UI.
+  if (render_manager_.pending_dom_ui())
     render_view_host->AllowDOMUIBindings();
 
   RenderWidgetHostView* rwh_view = view_->CreateViewForWidget(render_view_host);
   if (!render_view_host->CreateRenderView())
     return false;
 
   // Now that the RenderView has been created, we need to tell it its size.
   rwh_view->SetSize(view_->GetContainerSize());
 
   UpdateMaxPageIDIfNecessary(render_view_host->site_instance(),
@@ skipping 366 matching lines @@
     // The favicon url isn't valid. This means there really isn't a favicon,
     // or the favicon url wasn't obtained before the load started. This assumes
     // the later.
     // TODO(sky): Need a way to set the favicon that doesn't involve generating
     // its url.
     new_url->SetFavIconURL(TemplateURL::GenerateFaviconURL(params.referrer));
   }
   new_url->set_safe_for_autoreplace(true);
   url_model->Add(new_url);
 }