| // 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/navigation_controller.h" |
| |
| #include "base/command_line.h" |
| #include "base/file_util.h" |
| #include "base/logging.h" |
| #include "base/string_util.h" |
| #include "chrome/browser/browser_process.h" |
| #include "chrome/browser/dom_ui/dom_ui_host.h" |
| #include "chrome/browser/profile.h" |
| #include "chrome/browser/repost_form_warning_dialog.h" |
| #include "chrome/browser/sessions/session_types.h" |
| #include "chrome/browser/tab_contents/navigation_entry.h" |
| #include "chrome/browser/tab_contents/site_instance.h" |
| #include "chrome/browser/tab_contents/tab_contents.h" |
| #include "chrome/browser/tab_contents/tab_contents_delegate.h" |
| #include "chrome/common/chrome_switches.h" |
| #include "chrome/common/navigation_types.h" |
| #include "chrome/common/resource_bundle.h" |
| #include "chrome/common/scoped_vector.h" |
| #include "net/base/net_util.h" |
| #include "webkit/glue/webkit_glue.h" |
| |
| namespace { |
| |
| // Invoked when entries have been pruned, or removed. For example, if the |
| // current entries are [google, digg, yahoo], with the current entry google, |
| // and the user types in cnet, then digg and yahoo are pruned. |
| void NotifyPrunedEntries(NavigationController* nav_controller, |
| bool from_front, |
| int count) { |
| NavigationController::PrunedDetails details; |
| details.from_front = from_front; |
| details.count = count; |
| NotificationService::current()->Notify( |
| NOTIFY_NAV_LIST_PRUNED, |
| Source<NavigationController>(nav_controller), |
| Details<NavigationController::PrunedDetails>(&details)); |
| } |
| |
| // Ensure the given NavigationEntry has a valid state, so that WebKit does not |
| // get confused if we navigate back to it. |
| // |
| // An empty state is treated as a new navigation by WebKit, which would mean |
| // losing the navigation entries and generating a new navigation entry after |
| // this one. We don't want that. To avoid this we create a valid state which |
| // WebKit will not treat as a new navigation. |
| void SetContentStateIfEmpty(NavigationEntry* entry) { |
| if (entry->content_state().empty() && |
| (entry->tab_type() == TAB_CONTENTS_WEB || |
| entry->tab_type() == TAB_CONTENTS_NEW_TAB_UI || |
| entry->tab_type() == TAB_CONTENTS_ABOUT_UI || |
| entry->tab_type() == TAB_CONTENTS_HTML_DIALOG || |
| entry->tab_type() == TAB_CONTENTS_VIEW_SOURCE)) { |
| entry->set_content_state( |
| webkit_glue::CreateHistoryStateForURL(entry->url())); |
| } |
| } |
| |
| // Configure all the NavigationEntries in entries for restore. This resets |
| // the transition type to reload and makes sure the content state isn't empty. |
| void ConfigureEntriesForRestore( |
| std::vector<linked_ptr<NavigationEntry> >* entries) { |
| for (size_t i = 0; i < entries->size(); ++i) { |
| // Use a transition type of reload so that we don't incorrectly increase |
| // the typed count. |
| (*entries)[i]->set_transition_type(PageTransition::RELOAD); |
| (*entries)[i]->set_restored(true); |
| // NOTE(darin): This code is only needed for backwards compat. |
| SetContentStateIfEmpty((*entries)[i].get()); |
| } |
| } |
| |
| // See NavigationController::IsURLInPageNavigation for how this works and why. |
| bool AreURLsInPageNavigation(const GURL& existing_url, const GURL& new_url) { |
| if (existing_url == new_url || !new_url.has_ref()) |
| return false; |
| |
| url_canon::Replacements<char> replacements; |
| replacements.ClearRef(); |
| return existing_url.ReplaceComponents(replacements) == |
| new_url.ReplaceComponents(replacements); |
| } |
| |
| } // namespace |
| |
| // TabContentsCollector --------------------------------------------------- |
| |
| // We never destroy a TabContents synchronously because there are some |
| // complex code path that cause the current TabContents to be in the call |
| // stack. So instead, we use a TabContentsCollector which either destroys |
| // the TabContents or does nothing if it has been cancelled. |
| class TabContentsCollector : public Task { |
| public: |
| TabContentsCollector(NavigationController* target, |
| TabContentsType target_type) |
| : target_(target), |
| target_type_(target_type) { |
| } |
| |
| void Cancel() { |
| target_ = NULL; |
| } |
| |
| virtual void Run() { |
| if (target_) { |
| // Note: this will cancel this task as a side effect so target_ is |
| // now null. |
| TabContents* tc = target_->GetTabContents(target_type_); |
| tc->Destroy(); |
| } |
| } |
| |
| private: |
| // The NavigationController we are acting on. |
| NavigationController* target_; |
| |
| // The TabContentsType that needs to be collected. |
| TabContentsType target_type_; |
| |
| DISALLOW_EVIL_CONSTRUCTORS(TabContentsCollector); |
| }; |
| |
| // NavigationController --------------------------------------------------- |
| |
| // static |
| size_t NavigationController::max_entry_count_ = 50; |
| |
| // static |
| bool NavigationController::check_for_repost_ = true; |
| |
| // Creates a new NavigationEntry for each TabNavigation in navigations, adding |
| // the NavigationEntry to entries. This is used during session restore. |
| static void CreateNavigationEntriesFromTabNavigations( |
| const std::vector<TabNavigation>& navigations, |
| std::vector<linked_ptr<NavigationEntry> >* entries) { |
| // Create a NavigationEntry for each of the navigations. |
| int page_id = 0; |
| for (std::vector<TabNavigation>::const_iterator i = |
| navigations.begin(); i != navigations.end(); ++i, ++page_id) { |
| entries->push_back( |
| linked_ptr<NavigationEntry>(i->ToNavigationEntry(page_id))); |
| } |
| } |
| |
| NavigationController::NavigationController(TabContents* contents, |
| Profile* profile) |
| : profile_(profile), |
| pending_entry_(NULL), |
| last_committed_entry_index_(-1), |
| pending_entry_index_(-1), |
| transient_entry_index_(-1), |
| active_contents_(contents), |
| max_restored_page_id_(-1), |
| ssl_manager_(this, NULL), |
| needs_reload_(false), |
| load_pending_entry_when_active_(false) { |
| if (contents) |
| RegisterTabContents(contents); |
| DCHECK(profile_); |
| } |
| |
| NavigationController::NavigationController( |
| Profile* profile, |
| const std::vector<TabNavigation>& navigations, |
| int selected_navigation) |
| : profile_(profile), |
| pending_entry_(NULL), |
| last_committed_entry_index_(-1), |
| pending_entry_index_(-1), |
| transient_entry_index_(-1), |
| active_contents_(NULL), |
| max_restored_page_id_(-1), |
| ssl_manager_(this, NULL), |
| needs_reload_(true), |
| load_pending_entry_when_active_(false) { |
| DCHECK(profile_); |
| DCHECK(selected_navigation >= 0 && |
| selected_navigation < static_cast<int>(navigations.size())); |
| |
| // Populate entries_ from the supplied TabNavigations. |
| CreateNavigationEntriesFromTabNavigations(navigations, &entries_); |
| |
| // And finish the restore. |
| FinishRestore(selected_navigation); |
| } |
| |
| NavigationController::~NavigationController() { |
| DCHECK(tab_contents_map_.empty()); |
| DCHECK(tab_contents_collector_map_.empty()); |
| |
| DiscardNonCommittedEntriesInternal(); |
| |
| NotificationService::current()->Notify(NOTIFY_TAB_CLOSED, |
| Source<NavigationController>(this), |
| NotificationService::NoDetails()); |
| } |
| |
| TabContents* NavigationController::GetTabContents(TabContentsType t) { |
| // Make sure the TabContents is no longer scheduled for collection. |
| CancelTabContentsCollection(t); |
| return tab_contents_map_[t]; |
| } |
| |
| void NavigationController::Reload(bool check_for_repost) { |
| // Reloading a transient entry does nothing. |
| if (transient_entry_index_ != -1) |
| return; |
| |
| DiscardNonCommittedEntriesInternal(); |
| int current_index = GetCurrentEntryIndex(); |
| if (check_for_repost_ && check_for_repost && current_index != -1 && |
| GetEntryAtIndex(current_index)->has_post_data()) { |
| // The user is asking to reload a page with POST data. Prompt to make sure |
| // they really want to do this. If they do, RepostFormWarningDialog calls us |
| // back with ReloadDontCheckForRepost. |
| active_contents_->Activate(); |
| RepostFormWarningDialog::RunRepostFormWarningDialog(this); |
| } else { |
| // Base the navigation on where we are now... |
| int current_index = GetCurrentEntryIndex(); |
| |
| // If we are no where, then we can't reload. TODO(darin): We should add a |
| // CanReload method. |
| if (current_index == -1) |
| return; |
| |
| DiscardNonCommittedEntriesInternal(); |
| |
| pending_entry_index_ = current_index; |
| entries_[pending_entry_index_]->set_transition_type(PageTransition::RELOAD); |
| NavigateToPendingEntry(true); |
| } |
| } |
| |
| NavigationEntry* NavigationController::GetEntryWithPageID( |
| TabContentsType type, SiteInstance* instance, int32 page_id) const { |
| int index = GetEntryIndexWithPageID(type, instance, page_id); |
| return (index != -1) ? entries_[index].get() : NULL; |
| } |
| |
| void NavigationController::LoadEntry(NavigationEntry* entry) { |
| // When navigating to a new page, we don't know for sure if we will actually |
| // end up leaving the current page. The new page load could for example |
| // result in a download or a 'no content' response (e.g., a mailto: URL). |
| DiscardNonCommittedEntriesInternal(); |
| pending_entry_ = entry; |
| NotificationService::current()->Notify( |
| NOTIFY_NAV_ENTRY_PENDING, |
| Source<NavigationController>(this), |
| NotificationService::NoDetails()); |
| NavigateToPendingEntry(false); |
| } |
| |
| NavigationEntry* NavigationController::GetActiveEntry() const { |
| if (transient_entry_index_ != -1) |
| return entries_[transient_entry_index_].get(); |
| if (pending_entry_) |
| return pending_entry_; |
| return GetLastCommittedEntry(); |
| } |
| |
| int NavigationController::GetCurrentEntryIndex() const { |
| if (transient_entry_index_ != -1) |
| return transient_entry_index_; |
| if (pending_entry_index_ != -1) |
| return pending_entry_index_; |
| return last_committed_entry_index_; |
| } |
| |
| NavigationEntry* NavigationController::GetLastCommittedEntry() const { |
| if (last_committed_entry_index_ == -1) |
| return NULL; |
| return entries_[last_committed_entry_index_].get(); |
| } |
| |
| NavigationEntry* NavigationController::GetEntryAtOffset(int offset) const { |
| int index = (transient_entry_index_ != -1) ? |
| transient_entry_index_ + offset : |
| last_committed_entry_index_ + offset; |
| if (index < 0 || index >= GetEntryCount()) |
| return NULL; |
| |
| return entries_[index].get(); |
| } |
| |
| bool NavigationController::CanGoBack() const { |
| return entries_.size() > 1 && GetCurrentEntryIndex() > 0; |
| } |
| |
| bool NavigationController::CanGoForward() const { |
| int index = GetCurrentEntryIndex(); |
| return index >= 0 && index < (static_cast<int>(entries_.size()) - 1); |
| } |
| |
| void NavigationController::GoBack() { |
| if (!CanGoBack()) { |
| NOTREACHED(); |
| return; |
| } |
| |
| // Base the navigation on where we are now... |
| int current_index = GetCurrentEntryIndex(); |
| |
| DiscardNonCommittedEntries(); |
| |
| pending_entry_index_ = current_index - 1; |
| NavigateToPendingEntry(false); |
| } |
| |
| void NavigationController::GoForward() { |
| if (!CanGoForward()) { |
| NOTREACHED(); |
| return; |
| } |
| |
| bool transient = (transient_entry_index_ != -1); |
| |
| // Base the navigation on where we are now... |
| int current_index = GetCurrentEntryIndex(); |
| |
| DiscardNonCommittedEntries(); |
| |
| pending_entry_index_ = current_index; |
| // If there was a transient entry, we removed it making the current index |
| // the next page. |
| if (!transient) |
| pending_entry_index_++; |
| |
| NavigateToPendingEntry(false); |
| } |
| |
| void NavigationController::GoToIndex(int index) { |
| if (index < 0 || index >= static_cast<int>(entries_.size())) { |
| NOTREACHED(); |
| return; |
| } |
| |
| if (transient_entry_index_ != -1) { |
| if (index == transient_entry_index_) { |
| // Nothing to do when navigating to the transient. |
| return; |
| } |
| if (index > transient_entry_index_) { |
| // Removing the transient is goint to shift all entries by 1. |
| index--; |
| } |
| } |
| |
| DiscardNonCommittedEntries(); |
| |
| pending_entry_index_ = index; |
| NavigateToPendingEntry(false); |
| } |
| |
| void NavigationController::GoToOffset(int offset) { |
| int index = (transient_entry_index_ != -1) ? |
| transient_entry_index_ + offset : |
| last_committed_entry_index_ + offset; |
| if (index < 0 || index >= GetEntryCount()) |
| return; |
| |
| GoToIndex(index); |
| } |
| |
| void NavigationController::RemoveEntryAtIndex(int index, |
| const GURL& default_url) { |
| int size = static_cast<int>(entries_.size()); |
| DCHECK(index < size); |
| |
| DiscardNonCommittedEntries(); |
| |
| entries_.erase(entries_.begin() + index); |
| |
| if (last_committed_entry_index_ == index) { |
| last_committed_entry_index_--; |
| // We removed the currently shown entry, so we have to load something else. |
| if (last_committed_entry_index_ != -1) { |
| pending_entry_index_ = last_committed_entry_index_; |
| NavigateToPendingEntry(false); |
| } else { |
| // If there is nothing to show, show a default page. |
| LoadURL(default_url.is_empty() ? GURL("about:blank") : default_url, |
| GURL(), PageTransition::START_PAGE); |
| } |
| } else if (last_committed_entry_index_ > index) { |
| last_committed_entry_index_--; |
| } |
| } |
| |
| void NavigationController::Destroy() { |
| // Close all tab contents owned by this controller. We make a list on the |
| // stack because they are removed from the map as they are Destroyed |
| // (invalidating the iterators), which may or may not occur synchronously. |
| // We also keep track of any NULL entries in the map so that we can clean |
| // them out. |
| std::list<TabContents*> tabs_to_destroy; |
| std::list<TabContentsType> tab_types_to_erase; |
| for (TabContentsMap::iterator i = tab_contents_map_.begin(); |
| i != tab_contents_map_.end(); ++i) { |
| if (i->second) |
| tabs_to_destroy.push_back(i->second); |
| else |
| tab_types_to_erase.push_back(i->first); |
| } |
| |
| // Clean out all NULL entries in the map so that we know empty map means all |
| // tabs destroyed. This is needed since TabContentsWasDestroyed() won't get |
| // called for types that are in our map with a NULL contents. (We don't do |
| // this by iterating over TAB_CONTENTS_NUM_TYPES because some tests create |
| // additional types.) |
| for (std::list<TabContentsType>::iterator i = tab_types_to_erase.begin(); |
| i != tab_types_to_erase.end(); ++i) { |
| TabContentsMap::iterator map_iterator = tab_contents_map_.find(*i); |
| if (map_iterator != tab_contents_map_.end()) { |
| DCHECK(!map_iterator->second); |
| tab_contents_map_.erase(map_iterator); |
| } |
| } |
| |
| // Cancel all the TabContentsCollectors. |
| for (TabContentsCollectorMap::iterator i = |
| tab_contents_collector_map_.begin(); |
| i != tab_contents_collector_map_.end(); ++i) { |
| DCHECK(i->second); |
| i->second->Cancel(); |
| } |
| tab_contents_collector_map_.clear(); |
| |
| |
| // Finally destroy all the tab contents. |
| for (std::list<TabContents*>::iterator i = tabs_to_destroy.begin(); |
| i != tabs_to_destroy.end(); ++i) { |
| (*i)->Destroy(); |
| } |
| // We are deleted at this point. |
| } |
| |
| void NavigationController::TabContentsWasDestroyed(TabContentsType type) { |
| TabContentsMap::iterator i = tab_contents_map_.find(type); |
| DCHECK(i != tab_contents_map_.end()); |
| tab_contents_map_.erase(i); |
| |
| // Make sure we cancel any collector for that TabContents. |
| CancelTabContentsCollection(type); |
| |
| // If that was the last tab to be destroyed, delete ourselves. |
| if (tab_contents_map_.empty()) |
| delete this; |
| } |
| |
| NavigationEntry* NavigationController::CreateNavigationEntry( |
| const GURL& url, const GURL& referrer, PageTransition::Type transition) { |
| GURL real_url = url; |
| TabContentsType type; |
| |
| // If the active contents supports |url|, use it. |
| // Note: in both cases, we give TabContents a chance to rewrite the URL. |
| TabContents* active = active_contents(); |
| if (active && active->SupportsURL(&real_url)) |
| type = active->type(); |
| else |
| type = TabContents::TypeForURL(&real_url); |
| |
| NavigationEntry* entry = new NavigationEntry(type, NULL, -1, real_url, |
| referrer, |
| std::wstring(), transition); |
| entry->set_display_url(url); |
| entry->set_user_typed_url(url); |
| if (url.SchemeIsFile()) { |
| entry->set_title(file_util::GetFilenameFromPath(UTF8ToWide(url.host() + |
| url.path()))); |
| } |
| return entry; |
| } |
| |
| void NavigationController::AddTransientEntry(NavigationEntry* entry) { |
| // Discard any current transient entry, we can only have one at a time. |
| int index = 0; |
| if (last_committed_entry_index_ != -1) |
| index = last_committed_entry_index_ + 1; |
| DiscardTransientEntry(); |
| entries_.insert(entries_.begin() + index, linked_ptr<NavigationEntry>(entry)); |
| transient_entry_index_ = index; |
| active_contents_->NotifyNavigationStateChanged( |
| TabContents::INVALIDATE_EVERYTHING); |
| } |
| |
| void NavigationController::LoadURL(const GURL& url, const GURL& referrer, |
| PageTransition::Type transition) { |
| // The user initiated a load, we don't need to reload anymore. |
| needs_reload_ = false; |
| |
| NavigationEntry* entry = CreateNavigationEntry(url, referrer, transition); |
| |
| LoadEntry(entry); |
| } |
| |
| void NavigationController::LoadURLLazily(const GURL& url, |
| const GURL& referrer, |
| PageTransition::Type type, |
| const std::wstring& title, |
| SkBitmap* icon) { |
| NavigationEntry* entry = CreateNavigationEntry(url, referrer, type); |
| entry->set_title(title); |
| if (icon) |
| entry->favicon().set_bitmap(*icon); |
| |
| DiscardNonCommittedEntriesInternal(); |
| pending_entry_ = entry; |
| load_pending_entry_when_active_ = true; |
| } |
| |
| bool NavigationController::LoadingURLLazily() { |
| return load_pending_entry_when_active_; |
| } |
| |
| const std::wstring& NavigationController::GetLazyTitle() const { |
| if (pending_entry_) |
| return pending_entry_->GetTitleForDisplay(); |
| else |
| return EmptyWString(); |
| } |
| |
| const SkBitmap& NavigationController::GetLazyFavIcon() const { |
| if (pending_entry_) { |
| return pending_entry_->favicon().bitmap(); |
| } else { |
| ResourceBundle &rb = ResourceBundle::GetSharedInstance(); |
| return *rb.GetBitmapNamed(IDR_DEFAULT_FAVICON); |
| } |
| } |
| |
| bool NavigationController::RendererDidNavigate( |
| const ViewHostMsg_FrameNavigate_Params& params, |
| LoadCommittedDetails* details) { |
| // Save the previous state before we clobber it. |
| if (GetLastCommittedEntry()) { |
| details->previous_url = GetLastCommittedEntry()->url(); |
| details->previous_entry_index = GetLastCommittedEntryIndex(); |
| } else { |
| details->previous_url = GURL(); |
| details->previous_entry_index = -1; |
| } |
| |
| // Assign the current site instance to any pending entry, so we can find it |
| // later by calling GetEntryIndexWithPageID. We only care about this if the |
| // pending entry is an existing navigation and not a new one (or else we |
| // wouldn't care about finding it with GetEntryIndexWithPageID). |
| // |
| // TODO(brettw) this seems slightly bogus as we don't really know if the |
| // pending entry is what this navigation is for. There is a similar TODO |
| // w.r.t. the pending entry in RendererDidNavigateToNewPage. |
| if (pending_entry_index_ >= 0) |
| pending_entry_->set_site_instance(active_contents_->GetSiteInstance()); |
| |
| // Do navigation-type specific actions. These will make and commit an entry. |
| details->type = ClassifyNavigation(params); |
| switch (details->type) { |
| case NavigationType::NEW_PAGE: |
| RendererDidNavigateToNewPage(params); |
| break; |
| case NavigationType::EXISTING_PAGE: |
| RendererDidNavigateToExistingPage(params); |
| break; |
| case NavigationType::SAME_PAGE: |
| RendererDidNavigateToSamePage(params); |
| break; |
| case NavigationType::IN_PAGE: |
| RendererDidNavigateInPage(params); |
| break; |
| case NavigationType::NEW_SUBFRAME: |
| RendererDidNavigateNewSubframe(params); |
| break; |
| case NavigationType::AUTO_SUBFRAME: |
| if (!RendererDidNavigateAutoSubframe(params)) |
| return false; |
| break; |
| case NavigationType::NAV_IGNORE: |
| // There is nothing we can do with this navigation, so we just return to |
| // the caller that nothing has happened. |
| return false; |
| default: |
| NOTREACHED(); |
| } |
| |
| // All committed entries should have nonempty content state so WebKit doesn't |
| // get confused when we go back to them (see the function for details). |
| SetContentStateIfEmpty(GetActiveEntry()); |
| |
| // 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) && |
| !GetPendingEntry()) || |
| params.gesture == NavigationGestureAuto; |
| |
| // Now prep the rest of the details for the notification and broadcast. |
| details->entry = GetActiveEntry(); |
| details->is_in_page = IsURLInPageNavigation(params.url); |
| details->is_main_frame = PageTransition::IsMainFrame(params.transition); |
| details->serialized_security_info = params.security_info; |
| details->is_content_filtered = params.is_content_filtered; |
| NotifyNavigationEntryCommitted(details); |
| |
| // It is now a safe time to schedule collection for any tab contents of a |
| // different type, because a navigation is necessary to get back to them. |
| ScheduleTabContentsCollectionForInactiveTabs(); |
| return true; |
| } |
| |
| NavigationType::Type NavigationController::ClassifyNavigation( |
| const ViewHostMsg_FrameNavigate_Params& params) const { |
| // If a page makes a popup navigated to about blank, and then writes stuff |
| // like a subframe navigated to a real site, we'll get a notification with an |
| // invalid page ID. There's nothing we can do with these, so just ignore them. |
| if (params.page_id == -1) { |
| DCHECK(!GetActiveEntry()) << "Got an invalid page ID but we seem to be " |
| " navigated to a valid page. This should be impossible."; |
| return NavigationType::NAV_IGNORE; |
| } |
| |
| if (params.page_id > active_contents_->GetMaxPageID()) { |
| // Greater page IDs than we've ever seen before are new pages. We may or may |
| // not have a pending entry for the page, and this may or may not be the |
| // main frame. |
| if (PageTransition::IsMainFrame(params.transition)) |
| return NavigationType::NEW_PAGE; |
| |
| // When this is a new subframe navigation, we should have a committed page |
| // for which it's a suframe in. This may not be the case when an iframe is |
| // navigated on a popup navigated to about:blank (the iframe would be |
| // written into the popup by script on the main page). For these cases, |
| // there isn't any navigation stuff we can do, so just ignore it. |
| if (!GetLastCommittedEntry()) |
| return NavigationType::NAV_IGNORE; |
| |
| // Valid subframe navigation. |
| return NavigationType::NEW_SUBFRAME; |
| } |
| |
| // Now we know that the notification is for an existing page. Find that entry. |
| int existing_entry_index = GetEntryIndexWithPageID( |
| active_contents_->type(), |
| active_contents_->GetSiteInstance(), |
| params.page_id); |
| if (existing_entry_index == -1) { |
| // The page was not found. It could have been pruned because of the limit on |
| // back/forward entries (not likely since we'll usually tell it to navigate |
| // to such entries). It could also mean that the renderer is smoking crack. |
| NOTREACHED(); |
| return NavigationType::NAV_IGNORE; |
| } |
| NavigationEntry* existing_entry = entries_[existing_entry_index].get(); |
| |
| if (pending_entry_ && |
| pending_entry_->url() == params.url && |
| existing_entry != pending_entry_ && |
| pending_entry_->page_id() == -1 && |
| pending_entry_->url() == existing_entry->url()) { |
| // In this case, we have a pending entry for a URL but WebCore didn't do a |
| // new navigation. This happens when you press enter in the URL bar to |
| // reload. We will create a pending entry, but WebKit will convert it to |
| // a reload since it's the same page and not create a new entry for it |
| // (the user doesn't want to have a new back/forward entry when they do |
| // this). In this case, we want to just ignore the pending entry and go |
| // back to where we were (the "existing entry"). |
| return NavigationType::SAME_PAGE; |
| } |
| |
| if (!PageTransition::IsMainFrame(params.transition)) { |
| // All manual subframes would get new IDs and were handled above, so we |
| // know this is auto. Since the current page was found in the navigation |
| // entry list, we're guaranteed to have a last committed entry. |
| DCHECK(GetLastCommittedEntry()); |
| return NavigationType::AUTO_SUBFRAME; |
| } |
| |
| // Any toplevel navigations with the same base (minus the reference fragment) |
| // are in-page navigations. We weeded out subframe navigations above. Most of |
| // the time this doesn't matter since WebKit doesn't tell us about subframe |
| // navigations that don't actually navigate, but it can happen when there is |
| // an encoding override (it always sends a navigation request). |
| if (AreURLsInPageNavigation(existing_entry->url(), params.url)) |
| return NavigationType::IN_PAGE; |
| |
| // Since we weeded out "new" navigations above, we know this is an existing |
| // (back/forward) navigation. |
| return NavigationType::EXISTING_PAGE; |
| } |
| |
| void NavigationController::RendererDidNavigateToNewPage( |
| const ViewHostMsg_FrameNavigate_Params& params) { |
| NavigationEntry* new_entry; |
| if (pending_entry_) { |
| // TODO(brettw) this assumes that the pending entry is appropriate for the |
| // new page that was just loaded. I don't think this is necessarily the |
| // case! We should have some more tracking to know for sure. This goes along |
| // with a similar TODO at the top of RendererDidNavigate where we blindly |
| // set the site instance on the pending entry. |
| new_entry = new NavigationEntry(*pending_entry_); |
| |
| // Don't use the page type from the pending entry. Some interstitial page |
| // may have set the type to interstitial. Once we commit, however, the page |
| // type must always be normal. |
| new_entry->set_page_type(NavigationEntry::NORMAL_PAGE); |
| } else { |
| new_entry = new NavigationEntry(active_contents_->type()); |
| } |
| |
| new_entry->set_url(params.url); |
| new_entry->set_page_id(params.page_id); |
| new_entry->set_transition_type(params.transition); |
| new_entry->set_site_instance(active_contents_->GetSiteInstance()); |
| new_entry->set_has_post_data(params.is_post); |
| |
| InsertEntry(new_entry); |
| } |
| |
| void NavigationController::RendererDidNavigateToExistingPage( |
| const ViewHostMsg_FrameNavigate_Params& params) { |
| // We should only get here for main frame navigations. |
| DCHECK(PageTransition::IsMainFrame(params.transition)); |
| |
| // This is a back/forward navigation. The existing page for the ID is |
| // guaranteed to exist by ClassifyNavigation, and we just need to update it |
| // with new information from the renderer. |
| int entry_index = GetEntryIndexWithPageID( |
| active_contents_->type(), |
| active_contents_->GetSiteInstance(), |
| params.page_id); |
| DCHECK(entry_index >= 0 && |
| entry_index < static_cast<int>(entries_.size())); |
| NavigationEntry* entry = entries_[entry_index].get(); |
| |
| // The URL may have changed due to redirects. The site instance will normally |
| // be the same except during session restore, when no site instance will be |
| // assigned. |
| entry->set_url(params.url); |
| DCHECK(entry->site_instance() == NULL || |
| entry->site_instance() == active_contents_->GetSiteInstance()); |
| entry->set_site_instance(active_contents_->GetSiteInstance()); |
| |
| // The entry we found in the list might be pending if the user hit |
| // back/forward/reload. This load should commit it (since it's already in the |
| // list, we can just discard the pending pointer). |
| // |
| // Note that we need to use the "internal" version since we don't want to |
| // actually change any other state, just kill the pointer. |
| if (entry == pending_entry_) |
| DiscardNonCommittedEntriesInternal(); |
| |
| last_committed_entry_index_ = entry_index; |
| } |
| |
| void NavigationController::RendererDidNavigateToSamePage( |
| const ViewHostMsg_FrameNavigate_Params& params) { |
| // This mode implies we have a pending entry that's the same as an existing |
| // entry for this page ID. This entry is guaranteed to exist by |
| // ClassifyNavigation. All we need to do is update the existing entry. |
| NavigationEntry* existing_entry = GetEntryWithPageID( |
| active_contents_->type(), |
| active_contents_->GetSiteInstance(), |
| params.page_id); |
| |
| // We assign the entry's unique ID to be that of the new one. Since this is |
| // always the result of a user action, we want to dismiss infobars, etc. like |
| // a regular user-initiated navigation. |
| existing_entry->set_unique_id(pending_entry_->unique_id()); |
| |
| DiscardNonCommittedEntries(); |
| } |
| |
| void NavigationController::RendererDidNavigateInPage( |
| const ViewHostMsg_FrameNavigate_Params& params) { |
| DCHECK(PageTransition::IsMainFrame(params.transition)) << |
| "WebKit should only tell us about in-page navs for the main frame."; |
| // We're guaranteed to have an entry for this one. |
| NavigationEntry* existing_entry = GetEntryWithPageID( |
| active_contents_->type(), |
| active_contents_->GetSiteInstance(), |
| params.page_id); |
| |
| // Reference fragment navigation. We're guaranteed to have the last_committed |
| // entry and it will be the same page as the new navigation (minus the |
| // reference fragments, of course). |
| NavigationEntry* new_entry = new NavigationEntry(*existing_entry); |
| new_entry->set_page_id(params.page_id); |
| new_entry->set_url(params.url); |
| InsertEntry(new_entry); |
| } |
| |
| void NavigationController::RendererDidNavigateNewSubframe( |
| const ViewHostMsg_FrameNavigate_Params& params) { |
| // Manual subframe navigations just get the current entry cloned so the user |
| // can go back or forward to it. The actual subframe information will be |
| // stored in the page state for each of those entries. This happens out of |
| // band with the actual navigations. |
| DCHECK(GetLastCommittedEntry()) << "ClassifyNavigation should guarantee " |
| << "that a last committed entry exists."; |
| NavigationEntry* new_entry = new NavigationEntry(*GetLastCommittedEntry()); |
| new_entry->set_page_id(params.page_id); |
| InsertEntry(new_entry); |
| } |
| |
| bool NavigationController::RendererDidNavigateAutoSubframe( |
| const ViewHostMsg_FrameNavigate_Params& params) { |
| // We're guaranteed to have a previously committed entry, and we now need to |
| // handle navigation inside of a subframe in it without creating a new entry. |
| DCHECK(GetLastCommittedEntry()); |
| |
| // Handle the case where we're navigating back/forward to a previous subframe |
| // navigation entry. This is case "2." in NAV_AUTO_SUBFRAME comment in the |
| // header file. In case "1." this will be a NOP. |
| int entry_index = GetEntryIndexWithPageID( |
| active_contents_->type(), |
| active_contents_->GetSiteInstance(), |
| params.page_id); |
| if (entry_index < 0 || |
| entry_index >= static_cast<int>(entries_.size())) { |
| NOTREACHED(); |
| return false; |
| } |
| |
| // Update the current navigation entry in case we're going back/forward. |
| if (entry_index != last_committed_entry_index_) { |
| last_committed_entry_index_ = entry_index; |
| return true; |
| } |
| return false; |
| } |
| |
| void NavigationController::CommitPendingEntry() { |
| DiscardTransientEntry(); |
| |
| if (!GetPendingEntry()) |
| return; // Nothing to do. |
| |
| // Need to save the previous URL for the notification. |
| LoadCommittedDetails details; |
| if (GetLastCommittedEntry()) { |
| details.previous_url = GetLastCommittedEntry()->url(); |
| details.previous_entry_index = GetLastCommittedEntryIndex(); |
| } else { |
| details.previous_entry_index = -1; |
| } |
| |
| if (pending_entry_index_ >= 0) { |
| // This is a previous navigation (back/forward) that we're just now |
| // committing. Just mark it as committed. |
| details.type = NavigationType::EXISTING_PAGE; |
| int new_entry_index = pending_entry_index_; |
| DiscardNonCommittedEntriesInternal(); |
| |
| // Mark that entry as committed. |
| last_committed_entry_index_ = new_entry_index; |
| } else { |
| // This is a new navigation. It's easiest to just copy the entry and insert |
| // it new again, since InsertEntry expects to take ownership and also |
| // discard the pending entry. We also need to synthesize a page ID. We can |
| // only do this because this function will only be called by our custom |
| // TabContents types. For WebContents, the IDs are generated by the |
| // renderer, so we can't do this. |
| details.type = NavigationType::NEW_PAGE; |
| pending_entry_->set_page_id(active_contents_->GetMaxPageID() + 1); |
| active_contents_->UpdateMaxPageID(pending_entry_->page_id()); |
| InsertEntry(new NavigationEntry(*pending_entry_)); |
| } |
| |
| // Broadcast the notification of the navigation. |
| details.entry = GetActiveEntry(); |
| details.is_auto = false; |
| details.is_in_page = AreURLsInPageNavigation(details.previous_url, |
| details.entry->url()); |
| details.is_main_frame = true; |
| NotifyNavigationEntryCommitted(&details); |
| } |
| |
| int NavigationController::GetIndexOfEntry( |
| const NavigationEntry* entry) const { |
| const NavigationEntries::const_iterator i(std::find( |
| entries_.begin(), |
| entries_.end(), |
| entry)); |
| return (i == entries_.end()) ? -1 : static_cast<int>(i - entries_.begin()); |
| } |
| |
| bool NavigationController::IsURLInPageNavigation(const GURL& url) const { |
| NavigationEntry* last_committed = GetLastCommittedEntry(); |
| if (!last_committed) |
| return false; |
| return AreURLsInPageNavigation(last_committed->url(), url); |
| } |
| |
| void NavigationController::DiscardNonCommittedEntries() { |
| bool transient = transient_entry_index_ != -1; |
| DiscardNonCommittedEntriesInternal(); |
| |
| // Synchronize the active_contents_ to the last committed entry. |
| NavigationEntry* last_entry = GetLastCommittedEntry(); |
| if (last_entry && last_entry->tab_type() != active_contents_->type()) { |
| TabContents* from_contents = active_contents_; |
| from_contents->set_is_active(false); |
| |
| // Switch back to the previous tab contents. |
| active_contents_ = GetTabContents(last_entry->tab_type()); |
| DCHECK(active_contents_); |
| |
| active_contents_->set_is_active(true); |
| |
| // If we are transitioning from two types of WebContents, we need to migrate |
| // the download shelf if it is visible. The download shelf may have been |
| // created before the error that caused us to discard the entry. |
| WebContents::MigrateShelfView(from_contents, active_contents_); |
| |
| if (from_contents->delegate()) { |
| from_contents->delegate()->ReplaceContents(from_contents, |
| active_contents_); |
| } |
| |
| // The entry we just discarded needed a different TabContents type. We no |
| // longer need it but we can't destroy it just yet because the TabContents |
| // is very likely involved in the current stack. |
| DCHECK(from_contents != active_contents_); |
| ScheduleTabContentsCollection(from_contents->type()); |
| } |
| |
| // If there was a transient entry, invalidate everything so the new active |
| // entry state is shown. |
| if (transient) { |
| active_contents_->NotifyNavigationStateChanged( |
| TabContents::INVALIDATE_EVERYTHING); |
| } |
| } |
| |
| void NavigationController::InsertEntry(NavigationEntry* entry) { |
| DCHECK(entry->transition_type() != PageTransition::AUTO_SUBFRAME); |
| |
| // Copy the pending entry's unique ID to the committed entry. |
| // I don't know if pending_entry_index_ can be other than -1 here. |
| const NavigationEntry* const pending_entry = (pending_entry_index_ == -1) ? |
| pending_entry_ : entries_[pending_entry_index_].get(); |
| if (pending_entry) |
| entry->set_unique_id(pending_entry->unique_id()); |
| |
| DiscardNonCommittedEntriesInternal(); |
| |
| int current_size = static_cast<int>(entries_.size()); |
| |
| // Prune any entries which are in front of the current entry. |
| if (current_size > 0) { |
| int num_pruned = 0; |
| while (last_committed_entry_index_ < (current_size - 1)) { |
| num_pruned++; |
| entries_.pop_back(); |
| current_size--; |
| } |
| if (num_pruned > 0) // Only notify if we did prune something. |
| NotifyPrunedEntries(this, false, num_pruned); |
| } |
| |
| if (entries_.size() >= max_entry_count_) { |
| RemoveEntryAtIndex(0, GURL()); |
| NotifyPrunedEntries(this, true, 1); |
| } |
| |
| entries_.push_back(linked_ptr<NavigationEntry>(entry)); |
| last_committed_entry_index_ = static_cast<int>(entries_.size()) - 1; |
| |
| // This is a new page ID, so we need everybody to know about it. |
| active_contents_->UpdateMaxPageID(entry->page_id()); |
| } |
| |
| void NavigationController::SetWindowID(const SessionID& id) { |
| window_id_ = id; |
| NotificationService::current()->Notify(NOTIFY_TAB_PARENTED, |
| Source<NavigationController>(this), |
| NotificationService::NoDetails()); |
| } |
| |
| void NavigationController::NavigateToPendingEntry(bool reload) { |
| TabContents* from_contents = active_contents_; |
| |
| // For session history navigations only the pending_entry_index_ is set. |
| if (!pending_entry_) { |
| DCHECK(pending_entry_index_ != -1); |
| pending_entry_ = entries_[pending_entry_index_].get(); |
| } |
| |
| // Reset the security states as any SSL error may have been resolved since we |
| // last visited that page. |
| pending_entry_->ssl() = NavigationEntry::SSLStatus(); |
| |
| if (from_contents && from_contents->type() != pending_entry_->tab_type()) |
| from_contents->set_is_active(false); |
| |
| TabContents* contents = GetTabContentsCreateIfNecessary(*pending_entry_); |
| |
| contents->set_is_active(true); |
| active_contents_ = contents; |
| |
| if (from_contents && from_contents != contents) { |
| if (from_contents->delegate()) |
| from_contents->delegate()->ReplaceContents(from_contents, contents); |
| |
| if (from_contents->type() != contents->type()) { |
| // The entry we just discarded needed a different TabContents type. We no |
| // longer need it but we can't destroy it just yet because the TabContents |
| // is very likely involved in the current stack. |
| ScheduleTabContentsCollection(from_contents->type()); |
| } |
| } |
| |
| NavigationEntry temp_entry(*pending_entry_); |
| if (!contents->NavigateToPendingEntry(reload)) |
| DiscardNonCommittedEntries(); |
| } |
| |
| void NavigationController::NotifyNavigationEntryCommitted( |
| LoadCommittedDetails* details) { |
| // TODO(pkasting): http://b/1113079 Probably these explicit notification paths |
| // should be removed, and interested parties should just listen for the |
| // notification below instead. |
| ssl_manager_.NavigationStateChanged(); |
| active_contents_->NotifyNavigationStateChanged( |
| TabContents::INVALIDATE_EVERYTHING); |
| |
| details->entry = GetActiveEntry(); |
| NotificationService::current()->Notify( |
| NOTIFY_NAV_ENTRY_COMMITTED, |
| Source<NavigationController>(this), |
| Details<LoadCommittedDetails>(details)); |
| } |
| |
| TabContents* NavigationController::GetTabContentsCreateIfNecessary( |
| const NavigationEntry& entry) { |
| TabContents* contents = GetTabContents(entry.tab_type()); |
| if (!contents) { |
| contents = TabContents::CreateWithType(entry.tab_type(), profile_, |
| entry.site_instance()); |
| if (!contents->AsWebContents()) { |
| // Update the max page id, otherwise the newly created TabContents may |
| // have reset its max page id resulting in all new navigations. We only |
| // do this for non-WebContents as WebContents takes care of this via its |
| // SiteInstance. If this creation is the result of a restore, WebContents |
| // handles invoking ReservePageIDRange to make sure the renderer's |
| // max_page_id is updated to reflect the restored range of page ids. |
| int32 max_page_id = contents->GetMaxPageID(); |
| for (size_t i = 0; i < entries_.size(); ++i) { |
| if (entries_[i]->tab_type() == entry.tab_type()) |
| max_page_id = std::max(max_page_id, entries_[i]->page_id()); |
| } |
| contents->UpdateMaxPageID(max_page_id); |
| } |
| RegisterTabContents(contents); |
| } |
| |
| // We should not be trying to collect this tab contents. |
| DCHECK(tab_contents_collector_map_.find(contents->type()) == |
| tab_contents_collector_map_.end()); |
| |
| return contents; |
| } |
| |
| void NavigationController::RegisterTabContents(TabContents* some_contents) { |
| DCHECK(some_contents); |
| TabContentsType t = some_contents->type(); |
| TabContents* tc; |
| if ((tc = tab_contents_map_[t]) != some_contents) { |
| if (tc) { |
| NOTREACHED() << "Should not happen. Multiple contents for one type"; |
| } else { |
| tab_contents_map_[t] = some_contents; |
| some_contents->set_controller(this); |
| } |
| } |
| if (some_contents->AsDOMUIHost()) |
| some_contents->AsDOMUIHost()->AttachMessageHandlers(); |
| } |
| |
| // static |
| void NavigationController::DisablePromptOnRepost() { |
| check_for_repost_ = false; |
| } |
| |
| void NavigationController::SetActive(bool is_active) { |
| if (is_active) { |
| if (needs_reload_) { |
| LoadIfNecessary(); |
| } else if (load_pending_entry_when_active_) { |
| NavigateToPendingEntry(false); |
| load_pending_entry_when_active_ = false; |
| } |
| } |
| } |
| |
| void NavigationController::LoadIfNecessary() { |
| if (!needs_reload_) |
| return; |
| |
| needs_reload_ = false; |
| // Calling Reload() results in ignoring state, and not loading. |
| // Explicitly use NavigateToPendingEntry so that the renderer uses the |
| // cached state. |
| pending_entry_index_ = last_committed_entry_index_; |
| NavigateToPendingEntry(false); |
| } |
| |
| void NavigationController::NotifyEntryChanged(const NavigationEntry* entry, |
| int index) { |
| EntryChangedDetails det; |
| det.changed_entry = entry; |
| det.index = index; |
| NotificationService::current()->Notify(NOTIFY_NAV_ENTRY_CHANGED, |
| Source<NavigationController>(this), |
| Details<EntryChangedDetails>(&det)); |
| } |
| |
| NavigationController* NavigationController::Clone() { |
| NavigationController* nc = new NavigationController(NULL, profile_); |
| |
| if (GetEntryCount() == 0) |
| return nc; |
| |
| nc->needs_reload_ = true; |
| |
| nc->entries_.reserve(entries_.size()); |
| for (int i = 0, c = GetEntryCount(); i < c; ++i) { |
| nc->entries_.push_back(linked_ptr<NavigationEntry>( |
| new NavigationEntry(*GetEntryAtIndex(i)))); |
| } |
| |
| nc->FinishRestore(last_committed_entry_index_); |
| |
| return nc; |
| } |
| |
| void NavigationController::ScheduleTabContentsCollectionForInactiveTabs() { |
| int index = GetCurrentEntryIndex(); |
| if (index < 0 || GetPendingEntryIndex() != -1) |
| return; |
| |
| TabContentsType active_type = GetEntryAtIndex(index)->tab_type(); |
| for (TabContentsMap::iterator i = tab_contents_map_.begin(); |
| i != tab_contents_map_.end(); ++i) { |
| if (i->first != active_type) |
| ScheduleTabContentsCollection(i->first); |
| } |
| } |
| |
| void NavigationController::ScheduleTabContentsCollection(TabContentsType t) { |
| TabContentsCollectorMap::const_iterator i = |
| tab_contents_collector_map_.find(t); |
| |
| // The tab contents is already scheduled for collection. |
| if (i != tab_contents_collector_map_.end()) |
| return; |
| |
| // If we currently don't have a TabContents for t, skip. |
| if (tab_contents_map_.find(t) == tab_contents_map_.end()) |
| return; |
| |
| // Create a collector and schedule it. |
| TabContentsCollector* tcc = new TabContentsCollector(this, t); |
| tab_contents_collector_map_[t] = tcc; |
| MessageLoop::current()->PostTask(FROM_HERE, tcc); |
| } |
| |
| void NavigationController::CancelTabContentsCollection(TabContentsType t) { |
| TabContentsCollectorMap::iterator i = tab_contents_collector_map_.find(t); |
| |
| if (i != tab_contents_collector_map_.end()) { |
| DCHECK(i->second); |
| i->second->Cancel(); |
| tab_contents_collector_map_.erase(i); |
| } |
| } |
| |
| void NavigationController::FinishRestore(int selected_index) { |
| DCHECK(selected_index >= 0 && selected_index < GetEntryCount()); |
| ConfigureEntriesForRestore(&entries_); |
| |
| set_max_restored_page_id(GetEntryCount()); |
| |
| last_committed_entry_index_ = selected_index; |
| |
| // Callers assume we have an active_contents after restoring, so set it now. |
| active_contents_ = GetTabContentsCreateIfNecessary(*entries_[selected_index]); |
| } |
| |
| void NavigationController::DiscardNonCommittedEntriesInternal() { |
| if (pending_entry_index_ == -1) |
| delete pending_entry_; |
| pending_entry_ = NULL; |
| pending_entry_index_ = -1; |
| |
| DiscardTransientEntry(); |
| } |
| |
| void NavigationController::DiscardTransientEntry() { |
| if (transient_entry_index_ == -1) |
| return; |
| entries_.erase(entries_.begin() + transient_entry_index_ ); |
| transient_entry_index_ = -1; |
| } |
| |
| int NavigationController::GetEntryIndexWithPageID( |
| TabContentsType type, SiteInstance* instance, int32 page_id) const { |
| for (int i = static_cast<int>(entries_.size()) - 1; i >= 0; --i) { |
| if ((entries_[i]->tab_type() == type) && |
| (entries_[i]->site_instance() == instance) && |
| (entries_[i]->page_id() == page_id)) |
| return i; |
| } |
| return -1; |
| } |
| |
| NavigationEntry* NavigationController::GetTransientEntry() const { |
| if (transient_entry_index_ == -1) |
| return NULL; |
| return entries_[transient_entry_index_].get(); |
| } |