DidNavigate refactor of doom

chrome/browser/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/web_contents.h"
 
 #include "base/command_line.h"
 #include "base/file_version_info.h"
 #include "chrome/app/locales/locale_settings.h"
 #include "chrome/browser/bookmark_bar_model.h"
@@ skipping 86 matching lines @@
 const int kPrefsToObserveLength = arraysize(kPrefsToObserve);
 
 void InitWebContentsClass() {
   static bool web_contents_class_initialized = false;
   if (!web_contents_class_initialized) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     web_contents_class_initialized = true;
   }
 }
 
-GURL GURLWithoutRef(const GURL& url) {
-  url_canon::Replacements<char> replacements;
-  replacements.ClearRef();
-  return url.ReplaceComponents(replacements);
-}
-
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // WebContents
 
 class WebContents::GearsCreateShortcutCallbackFunctor {
  public:
   explicit GearsCreateShortcutCallbackFunctor(WebContents* contents)
      : contents_(contents) {}
 
@@ skipping 440 matching lines @@
 //   handler.  It does this by asynchronously calling the OnCrossSiteResponse
 //   method of WebContents on the UI thread, which sends a ClosePage message
 //   to the current RVH.
 // - Once the onunload handler is finished, a ClosePage_ACK message is sent to
 //   the ResourceDispatcherHost, who unpauses the response.  Data is then sent
 //   to the pending RVH.
 // - The pending renderer sends a FrameNavigate message that invokes the
 //   DidNavigate method.  This replaces the current RVH with the
 //   pending RVH and goes back to the NORMAL RendererState.
 
-bool WebContents::Navigate(const NavigationEntry& entry, bool reload) {
-  RenderViewHost* dest_render_view_host = render_manager_.Navigate(entry);
+bool WebContents::NavigateToPendingEntry(bool reload) {
+  NavigationEntry* entry = controller()->GetPendingEntry();
+  RenderViewHost* dest_render_view_host = render_manager_.Navigate(*entry);
 
   // Used for page load time metrics.
   current_load_start_ = TimeTicks::Now();
 
-  // Navigate in the desired RenderViewHost
-  dest_render_view_host->NavigateToEntry(entry, reload);
+  // Navigate in the desired RenderViewHost.
+  dest_render_view_host->NavigateToEntry(*entry, reload);
 
-  if (entry.page_id() == -1) {
+  if (entry->page_id() == -1) {
     // HACK!!  This code suppresses javascript: URLs from being added to
     // session history, which is what we want to do for javascript: URLs that
     // do not generate content.  What we really need is a message from the
     // renderer telling us that a new page was not created.  The same message
     // could be used for mailto: URLs and the like.
-    if (entry.url().SchemeIs("javascript"))
+    if (entry->url().SchemeIs("javascript"))
       return false;
   }
 
   if (reload && !profile()->IsOffTheRecord()) {
     HistoryService* history =
         profile()->GetHistoryService(Profile::IMPLICIT_ACCESS);
     if (history)
-      history->SetFavIconOutOfDateForPage(entry.url());
+      history->SetFavIconOutOfDateForPage(entry->url());
   }
 
   return true;
 }
 
 void WebContents::Stop() {
   render_manager_.Stop();
   printing_.Stop();
 }
 
@@ skipping 406 matching lines @@
 
 PluginInstaller* WebContents::GetPluginInstaller() {
   if (plugin_installer_.get() == NULL)
     plugin_installer_.reset(new PluginInstaller(this));
   return plugin_installer_.get();
 }
 
 bool WebContents::IsActiveEntry(int32 page_id) {
   NavigationEntry* active_entry = controller()->GetActiveEntry();
   return (active_entry != NULL &&
-          active_entry->site_instance() == site_instance() &&
+          active_entry->site_instance() == GetSiteInstance() &&
           active_entry->page_id() == page_id);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderViewHostDelegate implementation:
 
 RenderViewHostDelegate::FindInPage* WebContents::GetFindInPageDelegate() {
   // The find in page controller implements this interface for us. Our return
   // value can be NULL, so it's fine if the find in controller doesn't exist.
   return find_in_page_controller_.get();
 }
 
 Profile* WebContents::GetProfile() const {
   return profile();
 }
 
 void WebContents::CreateView(int route_id, HANDLE modal_dialog_event) {
   WebContents* new_view = new WebContents(profile(),
-                                          site_instance(),
+                                          GetSiteInstance(),
                                           render_view_factory_,
                                           route_id,
                                           modal_dialog_event);
   new_view->SetupController(profile());
   // TODO(beng)
   // The intention here is to create background tabs, which should ideally
   // be parented to NULL. However doing that causes the corresponding view
   // container windows to show up as overlapped windows, which causes
   // other issues. We should fix this.
   HWND new_view_parent_window = ::GetAncestor(GetHWND(), GA_ROOT);
@@ skipping 119 matching lines @@
   // Hide any visible hung renderer warning for this web contents' process.
   HungRendererWarning::HideForWebContents(this);
 }
 
 void WebContents::DidNavigate(RenderViewHost* rvh,
                               const ViewHostMsg_FrameNavigate_Params& params) {
   if (PageTransition::IsMainFrame(params.transition))
     render_manager_.DidNavigateMainFrame(rvh);
 
   // In the case of interstitial, we don't mess with the navigation entries.
+  // TODO(brettw) this seems like a bug. What happens if the page goes and
+  // does something on its own (or something that just got delayed), then
+  // we won't have a navigation entry for that stuff when the interstitial
+  // is hidden.
   if (render_manager_.showing_interstitial_page())
     return;
 
-  // Check for navigations we don't expect.
-  if (!controller() || !is_active_ || params.page_id == -1) {
-    if (params.page_id == -1) {
-      DCHECK(controller()->GetActiveEntry() == NULL)
-          << "The renderer is permitted to send a FrameNavigate event for an "
-             "invalid |page_id| if, and only if, this is the initial blank "
-             "page for a main frame.";
-    }
-    BroadcastProvisionalLoadCommit(rvh, params);
-    return;
-  }
-
-  // Generate the details for the notification.
-  // TODO(brettw) bug 1343146: Move into the NavigationController.
-  NavigationController::LoadCommittedDetails details;
-  // WebKit doesn't set the "auto" transition on meta refreshes properly (bug
-  // 1051891) so we manually set it for redirects which we normally treat as
-  // "non-user-gestures" where we want to update stuff after navigations.
-  //
-  // Note that the redirect check also checks for a pending entry to
-  // differentiate real redirects from browser initiated navigations to a
-  // redirected entry. This happens when you hit back to go to a page that was
-  // the destination of a redirect, we don't want to treat it as a redirect
-  // even though that's what its transition will be. See bug  1117048.
-  //
-  // TODO(brettw) write a test for this complicated logic.
-  details.is_auto = (PageTransition::IsRedirect(params.transition) &&
-                     !controller()->GetPendingEntry()) ||
-      params.gesture == NavigationGestureAuto;
-  details.is_in_page = IsInPageNavigation(params.url);
-  details.is_main_frame = PageTransition::IsMainFrame(params.transition);
-
-  // DO NOT ADD MORE STUFF TO THIS FUNCTION!  Don't make me come over there!
-  // =======================================================================
-  // Add your code to DidNavigateAnyFramePostCommit if you have a helper object
-  // that needs to know about all navigations. If it needs to do it only for
-  // main frame or sub-frame navigations, add your code to
-  // DidNavigate*PostCommit.
-
-  // Create the new navigation entry for this navigation and do work specific to
-  // this frame type. The main frame / sub frame functions will do additional
-  // updates to the NavigationEntry appropriate for the navigation type (in
-  // addition to a lot of other stuff).
-  scoped_ptr<NavigationEntry> entry(CreateNavigationEntryForCommit(params));
-
-  // Commit the entry to the navigation controller.
-  DidNavigateToEntry(entry.release(), &details);
-  // WARNING: NavigationController will have taken ownership of entry at this
-  // point, and may have deleted it. As such, do NOT use entry after this.
-
-  // Run post-commit tasks.
-  if (details.is_main_frame)
-    DidNavigateMainFramePostCommit(details, params);
-  DidNavigateAnyFramePostCommit(rvh, details, params);
-}
-
-// TODO(brettw) bug 1343146: This logic should be moved to NavigationController.
-NavigationEntry* WebContents::CreateNavigationEntryForCommit(
-    const ViewHostMsg_FrameNavigate_Params& params) {
-  // This new navigation entry will represent the navigation. Note that we
-  // don't set the URL. This will happen in the DidNavigateMainFrame/SubFrame
-  // because the entry's URL should represent the toplevel frame only.
-  NavigationEntry* entry = new NavigationEntry(type());
-  if (PageTransition::IsMainFrame(params.transition))
-    entry->set_url(params.url);
-  entry->set_page_id(params.page_id);
-  entry->set_transition_type(params.transition);
-  entry->set_site_instance(site_instance());
-
-  // Now that we've assigned a SiteInstance to this entry, we need to
-  // assign it to the NavigationController's pending entry as well.  This
-  // allows us to find it via GetEntryWithPageID, etc.
-  if (controller()->GetPendingEntry())
-    controller()->GetPendingEntry()->set_site_instance(entry->site_instance());
+  // We can't do anything about navigations when we're inactive.
+  if (!controller() || !is_active_)
+    return;  
 
   // Update the site of the SiteInstance if it doesn't have one yet, unless we
   // are showing an interstitial page.  If we are, we should wait until the
   // real page commits.
   //
   // TODO(brettw) the old code only checked for INTERSTIAL, this new code also
   // checks for LEAVING_INTERSTITIAL mode in the manager. Is this difference
   // important?
-  if (!site_instance()->has_site() &&
+  if (!GetSiteInstance()->has_site() &&
       !render_manager_.showing_interstitial_page())
-    site_instance()->SetSite(params.url);
+    GetSiteInstance()->SetSite(params.url);
 
-  // When the navigation is just a change in ref or a sub-frame navigation, the
-  // new page should inherit the existing entry's title and favicon, since it
-  // will be the same.  A change in ref also inherits the security style and SSL
-  // associated info.
-  bool in_page_nav;
-  if ((in_page_nav = IsInPageNavigation(params.url)) ||
-      !PageTransition::IsMainFrame(params.transition)) {
-    // In the case of a sub-frame navigation within a window that was created
-    // without an URL (via window.open), we may not have a committed entry yet!
-    NavigationEntry* old_entry = controller()->GetLastCommittedEntry();
-    if (old_entry) {
-      entry->set_title(old_entry->title());
-      entry->favicon() = old_entry->favicon();
-      if (in_page_nav)
-        entry->ssl() = old_entry->ssl();
-    }
-  }
+  NavigationController::LoadCommittedDetails details;
+  if (!controller()->RendererDidNavigate(
+      params,
+      render_manager_.IsRenderViewInterstitial(rvh),
+      &details))
+    return;  // No navigation happened.
 
-  if (PageTransition::IsMainFrame(params.transition)) {
-    NavigationEntry* pending = controller()->GetPendingEntry();
-    if (pending) {
-      // Copy fields from the pending NavigationEntry into the actual
-      // NavigationEntry that we're committing to.
-      entry->set_user_typed_url(pending->user_typed_url());
-      if (pending->has_display_url())
-        entry->set_display_url(pending->display_url());
-      if (pending->url().SchemeIsFile())
-        entry->set_title(pending->title());
-      entry->set_content_state(pending->content_state());
-    }
-    entry->set_has_post_data(params.is_post);
-  } else {
-    NavigationEntry* last_committed = controller()->GetLastCommittedEntry();
-    if (last_committed) {
-      // In the case of a sub-frame navigation within a window that was created
-      // without an URL (window.open), we may not have a committed entry yet!
+  // DO NOT ADD MORE STUFF TO THIS FUNCTION! Your component should either listen
+  // for the appropriate notification (best) or you can add it to
+  // DidNavigateMainFramePostCommit / DidNavigateAnyFramePostCommit (only if
+  // necessary, please).
 
-      // Reset entry state to match that of the pending entry.
-      entry->set_unique_id(last_committed->unique_id());
-      entry->set_url(last_committed->url());
-      entry->set_transition_type(last_committed->transition_type());
-      entry->set_user_typed_url(last_committed->user_typed_url());
-      entry->set_content_state(last_committed->content_state());
-
-      // TODO(jcampan): when navigating to an insecure/unsafe inner frame, the
-      // main entry is the one that gets notified of the mixed/unsafe contents
-      // (see SSLPolicy::OnRequestStarted()). Here we are just transferring
-      // that state. We should find a better way to do this. Note that it is OK
-      // that the mixed/unsafe contents is set on the wrong navigation entry, as
-      // that state is reset when navigating back to it.
-      DCHECK(entry->ssl().content_status() == 0) << "We should never "
-          "be setting the status bits from 1 to 0 on navigate.";
-      entry->ssl() = last_committed->ssl();
-    }
-  }
-
-  return entry;
+  // Run post-commit tasks.
+  if (details.is_main_frame)
+    DidNavigateMainFramePostCommit(details, params);
+  DidNavigateAnyFramePostCommit(rvh, details, params);
 }
 
 void WebContents::DidNavigateMainFramePostCommit(
     const NavigationController::LoadCommittedDetails& details,
     const ViewHostMsg_FrameNavigate_Params& params) {
   // Hide the download shelf if all the following conditions are true:
   // - there are no active downloads.
   // - this is a navigation to a different TLD.
   // - at least 5 seconds have elapsed since the download shelf was shown.
   // TODO(jcampan): bug 1156075 when user gestures are reliable, they should
@@ skipping 68 matching lines @@
   // Update history. Note that this needs to happen after the entry is complete,
   // which WillNavigate[Main,Sub]Frame will do before this function is called.
   if (params.should_update_history) {
     // Most of the time, the displayURL matches the loaded URL, but for about:
     // URLs, we use a data: URL as the real value.  We actually want to save
     // the about: URL to the history db and keep the data: URL hidden. This is
     // what the TabContents' URL getter does.
     UpdateHistoryForNavigation(GetURL(), params);
   }
 
-  // Have the controller save the current session.
-  controller()->NotifyEntryChangedByPageID(type(), site_instance(),
-                                           details.entry->page_id());
-
   // Notify the password manager of the navigation or form submit.
   // TODO(brettw) bug 1343111: Password manager stuff in here needs to be
   // cleaned up and covered by tests.
   if (params.password_form.origin.is_valid())
     GetPasswordManager()->ProvisionallySavePassword(params.password_form);
-
-  BroadcastProvisionalLoadCommit(render_view_host, params);
 }
 
 bool WebContents::IsWebApplicationActive() const {
   if (!web_app_.get())
     return false;
 
   // If we are inside an application, the application is always active. For
   // example, this allows us to display the GMail icon even when we are bounced
   // the login page.
   if (delegate() && delegate()->IsApplication())
     return true;
 
   return (GetURL() == web_app_->url());
 }
 
 void WebContents::WebAppImagesChanged(WebApp* web_app) {
   DCHECK(web_app == web_app_.get());
   if (delegate() && IsWebApplicationActive())
     delegate()->NavigationStateChanged(this, TabContents::INVALIDATE_FAVICON);
 }
 
-void WebContents::BroadcastProvisionalLoadCommit(
-    RenderViewHost* render_view_host,
-    const ViewHostMsg_FrameNavigate_Params& params) {
-  ProvisionalLoadDetails details(
-      PageTransition::IsMainFrame(params.transition),
-      render_manager_.IsRenderViewInterstitial(render_view_host),
-      IsInPageNavigation(params.url),
-      params.url, params.security_info);
-  NotificationService::current()->
-      Notify(NOTIFY_FRAME_PROVISIONAL_LOAD_COMMITTED,
-             Source<NavigationController>(controller()),
-             Details<ProvisionalLoadDetails>(&details));
-}
-
 void WebContents::UpdateStarredStateForCurrentURL() {
   BookmarkBarModel* model = profile()->GetBookmarkBarModel();
   const bool old_state = is_starred_;
   is_starred_ = (model && model->GetNodeByURL(GetURL()));
 
   if (is_starred_ != old_state && delegate())
     delegate()->URLStarredChanged(this, is_starred_);
 }
 
 void WebContents::UpdateAlternateErrorPageURL() {
@@ skipping 32 matching lines @@
 
   if (!controller())
     return;
 
   // We must be prepared to handle state updates for any page, these occur
   // when the user is scrolling and entering form data, as well as when we're
   // leaving a page, in which case our state may have already been moved to
   // the next page. The navigation controller will look up the appropriate
   // NavigationEntry and update it when it is notified via the delegate.
 
-  NavigationEntry* entry = controller()->GetEntryWithPageID(
-      type(), site_instance(), page_id);
-  if (!entry)
+  int entry_index = controller()->GetEntryIndexWithPageID(
+      type(), GetSiteInstance(), page_id);
+  if (entry_index < 0)
     return;
-
+  NavigationEntry* entry = controller()->GetEntryAtIndex(entry_index);
   unsigned changed_flags = 0;
 
   // Update the URL.
   if (url != entry->url()) {
     changed_flags |= INVALIDATE_URL;
     if (entry == controller()->GetActiveEntry())
       fav_icon_helper_.FetchFavIcon(url);
     entry->set_url(url);
   }
 
@@ skipping 22 matching lines @@
     ::SetWindowText(view()->GetPluginHWND(), title.c_str());
   }
 
   // Update the state (forms, etc.).
   if (state != entry->content_state())
     entry->set_content_state(state);
 
   // Notify everybody of the changes (only when the current page changed).
   if (changed_flags && entry == controller()->GetActiveEntry())
     NotifyNavigationStateChanged(changed_flags);
-  controller()->NotifyEntryChangedByPageID(type(), site_instance(), page_id);
+  controller()->NotifyEntryChanged(entry, entry_index);
 }
 
 void WebContents::UpdateTitle(RenderViewHost* rvh,
                               int32 page_id, const std::wstring& title) {
   if (!controller())
     return;
 
   // If we have a title, that's a pretty good indication that we've started
   // getting useful data.
   response_started_ = false;
 
   NavigationEntry* entry;
   if (render_manager_.showing_interstitial_page() &&
       (rvh == render_view_host())) {
     // We are showing an interstitial page in a different RenderViewHost, so
     // the page_id is not sufficient to find the entry from the controller.
     // (both RenderViewHost page_ids overlap).  We know it is the last entry,
     // so just use that.
     entry = controller()->GetLastCommittedEntry();
   } else {
-    entry = controller()->GetEntryWithPageID(type(), site_instance(), page_id);
+    entry = controller()->GetEntryWithPageID(type(), GetSiteInstance(),
+                                             page_id);
   }
 
   if (!entry)
     return;
 
   std::wstring trimmed_title;
   TrimWhitespace(title, TRIM_ALL, &trimmed_title);
   if (title == entry->title())
     return;  // Title did not change, do nothing.
 
@@ skipping 94 matching lines @@
   SetIsLoading(false, details.get());
 }
 
 void WebContents::DidStartProvisionalLoadForFrame(
     RenderViewHost* render_view_host,
     bool is_main_frame,
     const GURL& url) {
   ProvisionalLoadDetails details(
       is_main_frame,
       render_manager_.IsRenderViewInterstitial(render_view_host),
-      IsInPageNavigation(url),
+      controller()->IsURLInPageNavigation(url),
       url, std::string());
   NotificationService::current()->
       Notify(NOTIFY_FRAME_PROVISIONAL_LOAD_START,
              Source<NavigationController>(controller()),
              Details<ProvisionalLoadDetails>(&details));
 }
 
 void WebContents::DidRedirectProvisionalLoad(int32 page_id,
                                              const GURL& source_url,
                                              const GURL& target_url) {
   NavigationEntry* entry;
-  if (page_id == -1)
+  if (page_id == -1) {
     entry = controller()->GetPendingEntry();
-  else
-    entry = controller()->GetEntryWithPageID(type(), site_instance(), page_id);
+  } else {
+    entry = controller()->GetEntryWithPageID(type(), GetSiteInstance(),
+                                             page_id);
+  }
   if (!entry || entry->tab_type() != type() || entry->url() != source_url)
-      return;
+    return;
   entry->set_url(target_url);
 }
 
 void WebContents::DidLoadResourceFromMemoryCache(
     const GURL& url,
     const std::string& security_info) {
   if (!controller())
     return;
 
   // Send out a notification that we loaded a resource from our memory cache.
@@ skipping 27 matching lines @@
     if (pending_entry && pending_entry->url() == url)
       controller()->DiscardPendingEntry();
 
     render_manager_.RendererAbortedProvisionalLoad(render_view_host);
   }
 
   // Send out a notification that we failed a provisional load with an error.
   ProvisionalLoadDetails details(
       is_main_frame,
       render_manager_.IsRenderViewInterstitial(render_view_host),
-      IsInPageNavigation(url),
+      controller()->IsURLInPageNavigation(url),
       url, std::string());
   details.set_error_code(error_code);
 
   render_manager_.set_showing_repost_interstitial(showing_repost_interstitial);
 
   NotificationService::current()->
       Notify(NOTIFY_FAIL_PROVISIONAL_LOAD_WITH_ERROR,
              Source<NavigationController>(controller()),
              Details<ProvisionalLoadDetails>(&details));
 }
@@ skipping 687 matching lines @@
 }
 
 void WebContents::FileSelectionCanceled(void* params) {
   // If the user cancels choosing a file to upload we need to pass back the
   // empty string.
    render_view_host()->FileSelected(std::wstring());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-bool WebContents::IsInPageNavigation(const GURL& url) const {
-  // We compare to the last committed entry and not the active entry as the
-  // active entry is the current pending entry (if any).
-  // When this method is called when a navigation initiated from the browser
-  // (ex: when typing the URL in the location bar) is committed, the pending
-  // entry URL is the same as |url|.
-  NavigationEntry* entry = controller()->GetLastCommittedEntry();
-  return (entry && url.has_ref() &&
-         (url != entry->url()) &&  // Test for reload of a URL with a ref.
-          GURLWithoutRef(entry->url()) == GURLWithoutRef(url));
-}
-
 SkBitmap WebContents::GetFavIcon() {
   if (web_app_.get() && IsWebApplicationActive()) {
     SkBitmap app_icon = web_app_->GetFavIcon();
     if (!app_icon.isNull())
       return app_icon;
   }
   return TabContents::GetFavIcon();
 }
 
 std::wstring WebContents::GetStatusText() const {
@@ skipping 91 matching lines @@
 
 BOOL WebContents::EnumPluginWindowsCallback(HWND window, LPARAM) {
   if (WebPluginDelegateImpl::IsPluginDelegateWindow(window)) {
     ::ShowWindow(window, SW_HIDE);
     SetParent(window, NULL);
   }
 
   return TRUE;
 }