navigation_controller_impl.cc revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7
1// Copyright 2013 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "content/browser/frame_host/navigation_controller_impl.h" 6 7#include "base/bind.h" 8#include "base/debug/trace_event.h" 9#include "base/logging.h" 10#include "base/strings/string_number_conversions.h" // Temporary 11#include "base/strings/string_util.h" 12#include "base/strings/utf_string_conversions.h" 13#include "base/time/time.h" 14#include "content/browser/browser_url_handler_impl.h" 15#include "content/browser/dom_storage/dom_storage_context_wrapper.h" 16#include "content/browser/dom_storage/session_storage_namespace_impl.h" 17#include "content/browser/frame_host/debug_urls.h" 18#include "content/browser/frame_host/interstitial_page_impl.h" 19#include "content/browser/frame_host/navigation_entry_impl.h" 20#include "content/browser/frame_host/navigation_entry_screenshot_manager.h" 21#include "content/browser/renderer_host/render_view_host_impl.h" // Temporary 22#include "content/browser/site_instance_impl.h" 23#include "content/common/frame_messages.h" 24#include "content/common/view_messages.h" 25#include "content/public/browser/browser_context.h" 26#include "content/public/browser/content_browser_client.h" 27#include "content/public/browser/invalidate_type.h" 28#include "content/public/browser/navigation_details.h" 29#include "content/public/browser/notification_service.h" 30#include "content/public/browser/notification_types.h" 31#include "content/public/browser/render_widget_host.h" 32#include "content/public/browser/render_widget_host_view.h" 33#include "content/public/browser/storage_partition.h" 34#include "content/public/browser/user_metrics.h" 35#include "content/public/common/content_client.h" 36#include "content/public/common/content_constants.h" 37#include "content/public/common/url_constants.h" 38#include "net/base/escape.h" 39#include "net/base/mime_util.h" 40#include "net/base/net_util.h" 41#include "skia/ext/platform_canvas.h" 42 43namespace content { 44namespace { 45 46const int kInvalidateAll = 0xFFFFFFFF; 47 48// Invoked when entries have been pruned, or removed. For example, if the 49// current entries are [google, digg, yahoo], with the current entry google, 50// and the user types in cnet, then digg and yahoo are pruned. 51void NotifyPrunedEntries(NavigationControllerImpl* nav_controller, 52 bool from_front, 53 int count) { 54 PrunedDetails details; 55 details.from_front = from_front; 56 details.count = count; 57 NotificationService::current()->Notify( 58 NOTIFICATION_NAV_LIST_PRUNED, 59 Source<NavigationController>(nav_controller), 60 Details<PrunedDetails>(&details)); 61} 62 63// Ensure the given NavigationEntry has a valid state, so that WebKit does not 64// get confused if we navigate back to it. 65// 66// An empty state is treated as a new navigation by WebKit, which would mean 67// losing the navigation entries and generating a new navigation entry after 68// this one. We don't want that. To avoid this we create a valid state which 69// WebKit will not treat as a new navigation. 70void SetPageStateIfEmpty(NavigationEntryImpl* entry) { 71 if (!entry->GetPageState().IsValid()) 72 entry->SetPageState(PageState::CreateFromURL(entry->GetURL())); 73} 74 75NavigationEntryImpl::RestoreType ControllerRestoreTypeToEntryType( 76 NavigationController::RestoreType type) { 77 switch (type) { 78 case NavigationController::RESTORE_CURRENT_SESSION: 79 return NavigationEntryImpl::RESTORE_CURRENT_SESSION; 80 case NavigationController::RESTORE_LAST_SESSION_EXITED_CLEANLY: 81 return NavigationEntryImpl::RESTORE_LAST_SESSION_EXITED_CLEANLY; 82 case NavigationController::RESTORE_LAST_SESSION_CRASHED: 83 return NavigationEntryImpl::RESTORE_LAST_SESSION_CRASHED; 84 } 85 NOTREACHED(); 86 return NavigationEntryImpl::RESTORE_CURRENT_SESSION; 87} 88 89// Configure all the NavigationEntries in entries for restore. This resets 90// the transition type to reload and makes sure the content state isn't empty. 91void ConfigureEntriesForRestore( 92 std::vector<linked_ptr<NavigationEntryImpl> >* entries, 93 NavigationController::RestoreType type) { 94 for (size_t i = 0; i < entries->size(); ++i) { 95 // Use a transition type of reload so that we don't incorrectly increase 96 // the typed count. 97 (*entries)[i]->SetTransitionType(PAGE_TRANSITION_RELOAD); 98 (*entries)[i]->set_restore_type(ControllerRestoreTypeToEntryType(type)); 99 // NOTE(darin): This code is only needed for backwards compat. 100 SetPageStateIfEmpty((*entries)[i].get()); 101 } 102} 103 104// See NavigationController::IsURLInPageNavigation for how this works and why. 105bool AreURLsInPageNavigation(const GURL& existing_url, 106 const GURL& new_url, 107 bool renderer_says_in_page, 108 NavigationType navigation_type) { 109 if (existing_url == new_url) 110 return renderer_says_in_page; 111 112 if (!new_url.has_ref()) { 113 // When going back from the ref URL to the non ref one the navigation type 114 // is IN_PAGE. 115 return navigation_type == NAVIGATION_TYPE_IN_PAGE; 116 } 117 118 url_canon::Replacements<char> replacements; 119 replacements.ClearRef(); 120 return existing_url.ReplaceComponents(replacements) == 121 new_url.ReplaceComponents(replacements); 122} 123 124// Determines whether or not we should be carrying over a user agent override 125// between two NavigationEntries. 126bool ShouldKeepOverride(const NavigationEntry* last_entry) { 127 return last_entry && last_entry->GetIsOverridingUserAgent(); 128} 129 130} // namespace 131 132// NavigationControllerImpl ---------------------------------------------------- 133 134const size_t kMaxEntryCountForTestingNotSet = -1; 135 136// static 137size_t NavigationControllerImpl::max_entry_count_for_testing_ = 138 kMaxEntryCountForTestingNotSet; 139 140// Should Reload check for post data? The default is true, but is set to false 141// when testing. 142static bool g_check_for_repost = true; 143 144// static 145NavigationEntry* NavigationController::CreateNavigationEntry( 146 const GURL& url, 147 const Referrer& referrer, 148 PageTransition transition, 149 bool is_renderer_initiated, 150 const std::string& extra_headers, 151 BrowserContext* browser_context) { 152 // Allow the browser URL handler to rewrite the URL. This will, for example, 153 // remove "view-source:" from the beginning of the URL to get the URL that 154 // will actually be loaded. This real URL won't be shown to the user, just 155 // used internally. 156 GURL loaded_url(url); 157 bool reverse_on_redirect = false; 158 BrowserURLHandlerImpl::GetInstance()->RewriteURLIfNecessary( 159 &loaded_url, browser_context, &reverse_on_redirect); 160 161 NavigationEntryImpl* entry = new NavigationEntryImpl( 162 NULL, // The site instance for tabs is sent on navigation 163 // (WebContents::GetSiteInstance). 164 -1, 165 loaded_url, 166 referrer, 167 base::string16(), 168 transition, 169 is_renderer_initiated); 170 entry->SetVirtualURL(url); 171 entry->set_user_typed_url(url); 172 entry->set_update_virtual_url_with_url(reverse_on_redirect); 173 entry->set_extra_headers(extra_headers); 174 return entry; 175} 176 177// static 178void NavigationController::DisablePromptOnRepost() { 179 g_check_for_repost = false; 180} 181 182base::Time NavigationControllerImpl::TimeSmoother::GetSmoothedTime( 183 base::Time t) { 184 // If |t| is between the water marks, we're in a run of duplicates 185 // or just getting out of it, so increase the high-water mark to get 186 // a time that probably hasn't been used before and return it. 187 if (low_water_mark_ <= t && t <= high_water_mark_) { 188 high_water_mark_ += base::TimeDelta::FromMicroseconds(1); 189 return high_water_mark_; 190 } 191 192 // Otherwise, we're clear of the last duplicate run, so reset the 193 // water marks. 194 low_water_mark_ = high_water_mark_ = t; 195 return t; 196} 197 198NavigationControllerImpl::NavigationControllerImpl( 199 NavigationControllerDelegate* delegate, 200 BrowserContext* browser_context) 201 : browser_context_(browser_context), 202 pending_entry_(NULL), 203 last_committed_entry_index_(-1), 204 pending_entry_index_(-1), 205 transient_entry_index_(-1), 206 delegate_(delegate), 207 max_restored_page_id_(-1), 208 ssl_manager_(this), 209 needs_reload_(false), 210 is_initial_navigation_(true), 211 pending_reload_(NO_RELOAD), 212 get_timestamp_callback_(base::Bind(&base::Time::Now)), 213 screenshot_manager_(new NavigationEntryScreenshotManager(this)) { 214 DCHECK(browser_context_); 215} 216 217NavigationControllerImpl::~NavigationControllerImpl() { 218 DiscardNonCommittedEntriesInternal(); 219} 220 221WebContents* NavigationControllerImpl::GetWebContents() const { 222 return delegate_->GetWebContents(); 223} 224 225BrowserContext* NavigationControllerImpl::GetBrowserContext() const { 226 return browser_context_; 227} 228 229void NavigationControllerImpl::SetBrowserContext( 230 BrowserContext* browser_context) { 231 browser_context_ = browser_context; 232} 233 234void NavigationControllerImpl::Restore( 235 int selected_navigation, 236 RestoreType type, 237 std::vector<NavigationEntry*>* entries) { 238 // Verify that this controller is unused and that the input is valid. 239 DCHECK(GetEntryCount() == 0 && !GetPendingEntry()); 240 DCHECK(selected_navigation >= 0 && 241 selected_navigation < static_cast<int>(entries->size())); 242 243 needs_reload_ = true; 244 for (size_t i = 0; i < entries->size(); ++i) { 245 NavigationEntryImpl* entry = 246 NavigationEntryImpl::FromNavigationEntry((*entries)[i]); 247 entries_.push_back(linked_ptr<NavigationEntryImpl>(entry)); 248 } 249 entries->clear(); 250 251 // And finish the restore. 252 FinishRestore(selected_navigation, type); 253} 254 255void NavigationControllerImpl::Reload(bool check_for_repost) { 256 ReloadInternal(check_for_repost, RELOAD); 257} 258void NavigationControllerImpl::ReloadIgnoringCache(bool check_for_repost) { 259 ReloadInternal(check_for_repost, RELOAD_IGNORING_CACHE); 260} 261void NavigationControllerImpl::ReloadOriginalRequestURL(bool check_for_repost) { 262 ReloadInternal(check_for_repost, RELOAD_ORIGINAL_REQUEST_URL); 263} 264 265void NavigationControllerImpl::ReloadInternal(bool check_for_repost, 266 ReloadType reload_type) { 267 if (transient_entry_index_ != -1) { 268 // If an interstitial is showing, treat a reload as a navigation to the 269 // transient entry's URL. 270 NavigationEntryImpl* transient_entry = 271 NavigationEntryImpl::FromNavigationEntry(GetTransientEntry()); 272 if (!transient_entry) 273 return; 274 LoadURL(transient_entry->GetURL(), 275 Referrer(), 276 PAGE_TRANSITION_RELOAD, 277 transient_entry->extra_headers()); 278 return; 279 } 280 281 NavigationEntryImpl* entry = NULL; 282 int current_index = -1; 283 284 // If we are reloading the initial navigation, just use the current 285 // pending entry. Otherwise look up the current entry. 286 if (IsInitialNavigation() && pending_entry_) { 287 entry = pending_entry_; 288 // The pending entry might be in entries_ (e.g., after a Clone), so we 289 // should also update the current_index. 290 current_index = pending_entry_index_; 291 } else { 292 DiscardNonCommittedEntriesInternal(); 293 current_index = GetCurrentEntryIndex(); 294 if (current_index != -1) { 295 entry = NavigationEntryImpl::FromNavigationEntry( 296 GetEntryAtIndex(current_index)); 297 } 298 } 299 300 // If we are no where, then we can't reload. TODO(darin): We should add a 301 // CanReload method. 302 if (!entry) 303 return; 304 305 if (reload_type == NavigationControllerImpl::RELOAD_ORIGINAL_REQUEST_URL && 306 entry->GetOriginalRequestURL().is_valid() && !entry->GetHasPostData()) { 307 // We may have been redirected when navigating to the current URL. 308 // Use the URL the user originally intended to visit, if it's valid and if a 309 // POST wasn't involved; the latter case avoids issues with sending data to 310 // the wrong page. 311 entry->SetURL(entry->GetOriginalRequestURL()); 312 entry->SetReferrer(Referrer()); 313 } 314 315 if (g_check_for_repost && check_for_repost && 316 entry->GetHasPostData()) { 317 // The user is asking to reload a page with POST data. Prompt to make sure 318 // they really want to do this. If they do, the dialog will call us back 319 // with check_for_repost = false. 320 delegate_->NotifyBeforeFormRepostWarningShow(); 321 322 pending_reload_ = reload_type; 323 delegate_->ActivateAndShowRepostFormWarningDialog(); 324 } else { 325 if (!IsInitialNavigation()) 326 DiscardNonCommittedEntriesInternal(); 327 328 // If we are reloading an entry that no longer belongs to the current 329 // site instance (for example, refreshing a page for just installed app), 330 // the reload must happen in a new process. 331 // The new entry must have a new page_id and site instance, so it behaves 332 // as new navigation (which happens to clear forward history). 333 // Tabs that are discarded due to low memory conditions may not have a site 334 // instance, and should not be treated as a cross-site reload. 335 SiteInstanceImpl* site_instance = entry->site_instance(); 336 // Permit reloading guests without further checks. 337 bool is_guest = site_instance && site_instance->HasProcess() && 338 site_instance->GetProcess()->IsGuest(); 339 if (!is_guest && site_instance && 340 site_instance->HasWrongProcessForURL(entry->GetURL())) { 341 // Create a navigation entry that resembles the current one, but do not 342 // copy page id, site instance, content state, or timestamp. 343 NavigationEntryImpl* nav_entry = NavigationEntryImpl::FromNavigationEntry( 344 CreateNavigationEntry( 345 entry->GetURL(), entry->GetReferrer(), entry->GetTransitionType(), 346 false, entry->extra_headers(), browser_context_)); 347 348 // Mark the reload type as NO_RELOAD, so navigation will not be considered 349 // a reload in the renderer. 350 reload_type = NavigationController::NO_RELOAD; 351 352 nav_entry->set_should_replace_entry(true); 353 pending_entry_ = nav_entry; 354 } else { 355 pending_entry_ = entry; 356 pending_entry_index_ = current_index; 357 358 // The title of the page being reloaded might have been removed in the 359 // meanwhile, so we need to revert to the default title upon reload and 360 // invalidate the previously cached title (SetTitle will do both). 361 // See Chromium issue 96041. 362 pending_entry_->SetTitle(base::string16()); 363 364 pending_entry_->SetTransitionType(PAGE_TRANSITION_RELOAD); 365 } 366 367 NavigateToPendingEntry(reload_type); 368 } 369} 370 371void NavigationControllerImpl::CancelPendingReload() { 372 DCHECK(pending_reload_ != NO_RELOAD); 373 pending_reload_ = NO_RELOAD; 374} 375 376void NavigationControllerImpl::ContinuePendingReload() { 377 if (pending_reload_ == NO_RELOAD) { 378 NOTREACHED(); 379 } else { 380 ReloadInternal(false, pending_reload_); 381 pending_reload_ = NO_RELOAD; 382 } 383} 384 385bool NavigationControllerImpl::IsInitialNavigation() const { 386 return is_initial_navigation_; 387} 388 389NavigationEntryImpl* NavigationControllerImpl::GetEntryWithPageID( 390 SiteInstance* instance, int32 page_id) const { 391 int index = GetEntryIndexWithPageID(instance, page_id); 392 return (index != -1) ? entries_[index].get() : NULL; 393} 394 395void NavigationControllerImpl::LoadEntry(NavigationEntryImpl* entry) { 396 // When navigating to a new page, we don't know for sure if we will actually 397 // end up leaving the current page. The new page load could for example 398 // result in a download or a 'no content' response (e.g., a mailto: URL). 399 SetPendingEntry(entry); 400 NavigateToPendingEntry(NO_RELOAD); 401} 402 403void NavigationControllerImpl::SetPendingEntry(NavigationEntryImpl* entry) { 404 DiscardNonCommittedEntriesInternal(); 405 pending_entry_ = entry; 406 NotificationService::current()->Notify( 407 NOTIFICATION_NAV_ENTRY_PENDING, 408 Source<NavigationController>(this), 409 Details<NavigationEntry>(entry)); 410} 411 412NavigationEntry* NavigationControllerImpl::GetActiveEntry() const { 413 if (transient_entry_index_ != -1) 414 return entries_[transient_entry_index_].get(); 415 if (pending_entry_) 416 return pending_entry_; 417 return GetLastCommittedEntry(); 418} 419 420NavigationEntry* NavigationControllerImpl::GetVisibleEntry() const { 421 if (transient_entry_index_ != -1) 422 return entries_[transient_entry_index_].get(); 423 // The pending entry is safe to return for new (non-history), browser- 424 // initiated navigations. Most renderer-initiated navigations should not 425 // show the pending entry, to prevent URL spoof attacks. 426 // 427 // We make an exception for renderer-initiated navigations in new tabs, as 428 // long as no other page has tried to access the initial empty document in 429 // the new tab. If another page modifies this blank page, a URL spoof is 430 // possible, so we must stop showing the pending entry. 431 RenderViewHostImpl* rvh = static_cast<RenderViewHostImpl*>( 432 delegate_->GetRenderViewHost()); 433 bool safe_to_show_pending = 434 pending_entry_ && 435 // Require a new navigation. 436 pending_entry_->GetPageID() == -1 && 437 // Require either browser-initiated or an unmodified new tab. 438 (!pending_entry_->is_renderer_initiated() || 439 (IsInitialNavigation() && 440 !GetLastCommittedEntry() && 441 !rvh->has_accessed_initial_document())); 442 443 // Also allow showing the pending entry for history navigations in a new tab, 444 // such as Ctrl+Back. In this case, no existing page is visible and no one 445 // can script the new tab before it commits. 446 if (!safe_to_show_pending && 447 pending_entry_ && 448 pending_entry_->GetPageID() != -1 && 449 IsInitialNavigation() && 450 !pending_entry_->is_renderer_initiated()) 451 safe_to_show_pending = true; 452 453 if (safe_to_show_pending) 454 return pending_entry_; 455 return GetLastCommittedEntry(); 456} 457 458int NavigationControllerImpl::GetCurrentEntryIndex() const { 459 if (transient_entry_index_ != -1) 460 return transient_entry_index_; 461 if (pending_entry_index_ != -1) 462 return pending_entry_index_; 463 return last_committed_entry_index_; 464} 465 466NavigationEntry* NavigationControllerImpl::GetLastCommittedEntry() const { 467 if (last_committed_entry_index_ == -1) 468 return NULL; 469 return entries_[last_committed_entry_index_].get(); 470} 471 472bool NavigationControllerImpl::CanViewSource() const { 473 const std::string& mime_type = delegate_->GetContentsMimeType(); 474 bool is_viewable_mime_type = net::IsSupportedNonImageMimeType(mime_type) && 475 !net::IsSupportedMediaMimeType(mime_type); 476 NavigationEntry* visible_entry = GetVisibleEntry(); 477 return visible_entry && !visible_entry->IsViewSourceMode() && 478 is_viewable_mime_type && !delegate_->GetInterstitialPage(); 479} 480 481int NavigationControllerImpl::GetLastCommittedEntryIndex() const { 482 return last_committed_entry_index_; 483} 484 485int NavigationControllerImpl::GetEntryCount() const { 486 DCHECK(entries_.size() <= max_entry_count()); 487 return static_cast<int>(entries_.size()); 488} 489 490NavigationEntry* NavigationControllerImpl::GetEntryAtIndex( 491 int index) const { 492 return entries_.at(index).get(); 493} 494 495NavigationEntry* NavigationControllerImpl::GetEntryAtOffset( 496 int offset) const { 497 int index = GetIndexForOffset(offset); 498 if (index < 0 || index >= GetEntryCount()) 499 return NULL; 500 501 return entries_[index].get(); 502} 503 504int NavigationControllerImpl::GetIndexForOffset(int offset) const { 505 return GetCurrentEntryIndex() + offset; 506} 507 508void NavigationControllerImpl::TakeScreenshot() { 509 screenshot_manager_->TakeScreenshot(); 510} 511 512void NavigationControllerImpl::SetScreenshotManager( 513 NavigationEntryScreenshotManager* manager) { 514 screenshot_manager_.reset(manager ? manager : 515 new NavigationEntryScreenshotManager(this)); 516} 517 518bool NavigationControllerImpl::CanGoBack() const { 519 return entries_.size() > 1 && GetCurrentEntryIndex() > 0; 520} 521 522bool NavigationControllerImpl::CanGoForward() const { 523 int index = GetCurrentEntryIndex(); 524 return index >= 0 && index < (static_cast<int>(entries_.size()) - 1); 525} 526 527bool NavigationControllerImpl::CanGoToOffset(int offset) const { 528 int index = GetIndexForOffset(offset); 529 return index >= 0 && index < GetEntryCount(); 530} 531 532void NavigationControllerImpl::GoBack() { 533 if (!CanGoBack()) { 534 NOTREACHED(); 535 return; 536 } 537 538 // Base the navigation on where we are now... 539 int current_index = GetCurrentEntryIndex(); 540 541 DiscardNonCommittedEntries(); 542 543 pending_entry_index_ = current_index - 1; 544 entries_[pending_entry_index_]->SetTransitionType( 545 PageTransitionFromInt( 546 entries_[pending_entry_index_]->GetTransitionType() | 547 PAGE_TRANSITION_FORWARD_BACK)); 548 NavigateToPendingEntry(NO_RELOAD); 549} 550 551void NavigationControllerImpl::GoForward() { 552 if (!CanGoForward()) { 553 NOTREACHED(); 554 return; 555 } 556 557 bool transient = (transient_entry_index_ != -1); 558 559 // Base the navigation on where we are now... 560 int current_index = GetCurrentEntryIndex(); 561 562 DiscardNonCommittedEntries(); 563 564 pending_entry_index_ = current_index; 565 // If there was a transient entry, we removed it making the current index 566 // the next page. 567 if (!transient) 568 pending_entry_index_++; 569 570 entries_[pending_entry_index_]->SetTransitionType( 571 PageTransitionFromInt( 572 entries_[pending_entry_index_]->GetTransitionType() | 573 PAGE_TRANSITION_FORWARD_BACK)); 574 NavigateToPendingEntry(NO_RELOAD); 575} 576 577void NavigationControllerImpl::GoToIndex(int index) { 578 if (index < 0 || index >= static_cast<int>(entries_.size())) { 579 NOTREACHED(); 580 return; 581 } 582 583 if (transient_entry_index_ != -1) { 584 if (index == transient_entry_index_) { 585 // Nothing to do when navigating to the transient. 586 return; 587 } 588 if (index > transient_entry_index_) { 589 // Removing the transient is goint to shift all entries by 1. 590 index--; 591 } 592 } 593 594 DiscardNonCommittedEntries(); 595 596 pending_entry_index_ = index; 597 entries_[pending_entry_index_]->SetTransitionType( 598 PageTransitionFromInt( 599 entries_[pending_entry_index_]->GetTransitionType() | 600 PAGE_TRANSITION_FORWARD_BACK)); 601 NavigateToPendingEntry(NO_RELOAD); 602} 603 604void NavigationControllerImpl::GoToOffset(int offset) { 605 if (!CanGoToOffset(offset)) 606 return; 607 608 GoToIndex(GetIndexForOffset(offset)); 609} 610 611bool NavigationControllerImpl::RemoveEntryAtIndex(int index) { 612 if (index == last_committed_entry_index_ || 613 index == pending_entry_index_) 614 return false; 615 616 RemoveEntryAtIndexInternal(index); 617 return true; 618} 619 620void NavigationControllerImpl::UpdateVirtualURLToURL( 621 NavigationEntryImpl* entry, const GURL& new_url) { 622 GURL new_virtual_url(new_url); 623 if (BrowserURLHandlerImpl::GetInstance()->ReverseURLRewrite( 624 &new_virtual_url, entry->GetVirtualURL(), browser_context_)) { 625 entry->SetVirtualURL(new_virtual_url); 626 } 627} 628 629void NavigationControllerImpl::LoadURL( 630 const GURL& url, 631 const Referrer& referrer, 632 PageTransition transition, 633 const std::string& extra_headers) { 634 LoadURLParams params(url); 635 params.referrer = referrer; 636 params.transition_type = transition; 637 params.extra_headers = extra_headers; 638 LoadURLWithParams(params); 639} 640 641void NavigationControllerImpl::LoadURLWithParams(const LoadURLParams& params) { 642 TRACE_EVENT0("browser", "NavigationControllerImpl::LoadURLWithParams"); 643 if (HandleDebugURL(params.url, params.transition_type)) 644 return; 645 646 // Any renderer-side debug URLs or javascript: URLs should be ignored if the 647 // renderer process is not live, unless it is the initial navigation of the 648 // tab. 649 if (IsRendererDebugURL(params.url)) { 650 // TODO(creis): Find the RVH for the correct frame. 651 if (!delegate_->GetRenderViewHost()->IsRenderViewLive() && 652 !IsInitialNavigation()) 653 return; 654 } 655 656 // Checks based on params.load_type. 657 switch (params.load_type) { 658 case LOAD_TYPE_DEFAULT: 659 break; 660 case LOAD_TYPE_BROWSER_INITIATED_HTTP_POST: 661 if (!params.url.SchemeIs(kHttpScheme) && 662 !params.url.SchemeIs(kHttpsScheme)) { 663 NOTREACHED() << "Http post load must use http(s) scheme."; 664 return; 665 } 666 break; 667 case LOAD_TYPE_DATA: 668 if (!params.url.SchemeIs(kDataScheme)) { 669 NOTREACHED() << "Data load must use data scheme."; 670 return; 671 } 672 break; 673 default: 674 NOTREACHED(); 675 break; 676 }; 677 678 // The user initiated a load, we don't need to reload anymore. 679 needs_reload_ = false; 680 681 bool override = false; 682 switch (params.override_user_agent) { 683 case UA_OVERRIDE_INHERIT: 684 override = ShouldKeepOverride(GetLastCommittedEntry()); 685 break; 686 case UA_OVERRIDE_TRUE: 687 override = true; 688 break; 689 case UA_OVERRIDE_FALSE: 690 override = false; 691 break; 692 default: 693 NOTREACHED(); 694 break; 695 } 696 697 NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry( 698 CreateNavigationEntry( 699 params.url, 700 params.referrer, 701 params.transition_type, 702 params.is_renderer_initiated, 703 params.extra_headers, 704 browser_context_)); 705 if (params.frame_tree_node_id != -1) 706 entry->set_frame_tree_node_id(params.frame_tree_node_id); 707 if (params.redirect_chain.size() > 0) 708 entry->set_redirect_chain(params.redirect_chain); 709 if (params.should_replace_current_entry) 710 entry->set_should_replace_entry(true); 711 entry->set_should_clear_history_list(params.should_clear_history_list); 712 entry->SetIsOverridingUserAgent(override); 713 entry->set_transferred_global_request_id( 714 params.transferred_global_request_id); 715 entry->SetFrameToNavigate(params.frame_name); 716 717 switch (params.load_type) { 718 case LOAD_TYPE_DEFAULT: 719 break; 720 case LOAD_TYPE_BROWSER_INITIATED_HTTP_POST: 721 entry->SetHasPostData(true); 722 entry->SetBrowserInitiatedPostData( 723 params.browser_initiated_post_data.get()); 724 break; 725 case LOAD_TYPE_DATA: 726 entry->SetBaseURLForDataURL(params.base_url_for_data_url); 727 entry->SetVirtualURL(params.virtual_url_for_data_url); 728 entry->SetCanLoadLocalResources(params.can_load_local_resources); 729 break; 730 default: 731 NOTREACHED(); 732 break; 733 }; 734 735 LoadEntry(entry); 736} 737 738bool NavigationControllerImpl::RendererDidNavigate( 739 RenderViewHost* rvh, 740 const FrameHostMsg_DidCommitProvisionalLoad_Params& params, 741 LoadCommittedDetails* details) { 742 is_initial_navigation_ = false; 743 744 // Save the previous state before we clobber it. 745 if (GetLastCommittedEntry()) { 746 details->previous_url = GetLastCommittedEntry()->GetURL(); 747 details->previous_entry_index = GetLastCommittedEntryIndex(); 748 } else { 749 details->previous_url = GURL(); 750 details->previous_entry_index = -1; 751 } 752 753 // If we have a pending entry at this point, it should have a SiteInstance. 754 // Restored entries start out with a null SiteInstance, but we should have 755 // assigned one in NavigateToPendingEntry. 756 DCHECK(pending_entry_index_ == -1 || pending_entry_->site_instance()); 757 758 // If we are doing a cross-site reload, we need to replace the existing 759 // navigation entry, not add another entry to the history. This has the side 760 // effect of removing forward browsing history, if such existed. 761 // Or if we are doing a cross-site redirect navigation, 762 // we will do a similar thing. 763 details->did_replace_entry = 764 pending_entry_ && pending_entry_->should_replace_entry(); 765 766 // Do navigation-type specific actions. These will make and commit an entry. 767 details->type = ClassifyNavigation(rvh, params); 768 769 // is_in_page must be computed before the entry gets committed. 770 details->is_in_page = IsURLInPageNavigation( 771 params.url, params.was_within_same_page, details->type); 772 773 switch (details->type) { 774 case NAVIGATION_TYPE_NEW_PAGE: 775 RendererDidNavigateToNewPage(rvh, params, details->did_replace_entry); 776 break; 777 case NAVIGATION_TYPE_EXISTING_PAGE: 778 RendererDidNavigateToExistingPage(rvh, params); 779 break; 780 case NAVIGATION_TYPE_SAME_PAGE: 781 RendererDidNavigateToSamePage(rvh, params); 782 break; 783 case NAVIGATION_TYPE_IN_PAGE: 784 RendererDidNavigateInPage(rvh, params, &details->did_replace_entry); 785 break; 786 case NAVIGATION_TYPE_NEW_SUBFRAME: 787 RendererDidNavigateNewSubframe(rvh, params); 788 break; 789 case NAVIGATION_TYPE_AUTO_SUBFRAME: 790 if (!RendererDidNavigateAutoSubframe(rvh, params)) 791 return false; 792 break; 793 case NAVIGATION_TYPE_NAV_IGNORE: 794 // If a pending navigation was in progress, this canceled it. We should 795 // discard it and make sure it is removed from the URL bar. After that, 796 // there is nothing we can do with this navigation, so we just return to 797 // the caller that nothing has happened. 798 if (pending_entry_) { 799 DiscardNonCommittedEntries(); 800 delegate_->NotifyNavigationStateChanged(INVALIDATE_TYPE_URL); 801 } 802 return false; 803 default: 804 NOTREACHED(); 805 } 806 807 // At this point, we know that the navigation has just completed, so 808 // record the time. 809 // 810 // TODO(akalin): Use "sane time" as described in 811 // http://www.chromium.org/developers/design-documents/sane-time . 812 base::Time timestamp = 813 time_smoother_.GetSmoothedTime(get_timestamp_callback_.Run()); 814 DVLOG(1) << "Navigation finished at (smoothed) timestamp " 815 << timestamp.ToInternalValue(); 816 817 // We should not have a pending entry anymore. Clear it again in case any 818 // error cases above forgot to do so. 819 DiscardNonCommittedEntriesInternal(); 820 821 // All committed entries should have nonempty content state so WebKit doesn't 822 // get confused when we go back to them (see the function for details). 823 DCHECK(params.page_state.IsValid()); 824 NavigationEntryImpl* active_entry = 825 NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry()); 826 active_entry->SetTimestamp(timestamp); 827 active_entry->SetHttpStatusCode(params.http_status_code); 828 active_entry->SetPageState(params.page_state); 829 830 // Once it is committed, we no longer need to track several pieces of state on 831 // the entry. 832 active_entry->ResetForCommit(); 833 834 // The active entry's SiteInstance should match our SiteInstance. 835 // TODO(creis): This check won't pass for subframes until we create entries 836 // for subframe navigations. 837 if (PageTransitionIsMainFrame(params.transition)) 838 CHECK(active_entry->site_instance() == rvh->GetSiteInstance()); 839 840 // Remember the bindings the renderer process has at this point, so that 841 // we do not grant this entry additional bindings if we come back to it. 842 active_entry->SetBindings(rvh->GetEnabledBindings()); 843 844 // Now prep the rest of the details for the notification and broadcast. 845 details->entry = active_entry; 846 details->is_main_frame = 847 PageTransitionIsMainFrame(params.transition); 848 details->serialized_security_info = params.security_info; 849 details->http_status_code = params.http_status_code; 850 NotifyNavigationEntryCommitted(details); 851 852 return true; 853} 854 855NavigationType NavigationControllerImpl::ClassifyNavigation( 856 RenderViewHost* rvh, 857 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) const { 858 if (params.page_id == -1) { 859 // The renderer generates the page IDs, and so if it gives us the invalid 860 // page ID (-1) we know it didn't actually navigate. This happens in a few 861 // cases: 862 // 863 // - If a page makes a popup navigated to about blank, and then writes 864 // stuff like a subframe navigated to a real page. We'll get the commit 865 // for the subframe, but there won't be any commit for the outer page. 866 // 867 // - We were also getting these for failed loads (for example, bug 21849). 868 // The guess is that we get a "load commit" for the alternate error page, 869 // but that doesn't affect the page ID, so we get the "old" one, which 870 // could be invalid. This can also happen for a cross-site transition 871 // that causes us to swap processes. Then the error page load will be in 872 // a new process with no page IDs ever assigned (and hence a -1 value), 873 // yet the navigation controller still might have previous pages in its 874 // list. 875 // 876 // In these cases, there's nothing we can do with them, so ignore. 877 return NAVIGATION_TYPE_NAV_IGNORE; 878 } 879 880 if (params.page_id > delegate_->GetMaxPageIDForSiteInstance( 881 rvh->GetSiteInstance())) { 882 // Greater page IDs than we've ever seen before are new pages. We may or may 883 // not have a pending entry for the page, and this may or may not be the 884 // main frame. 885 if (PageTransitionIsMainFrame(params.transition)) 886 return NAVIGATION_TYPE_NEW_PAGE; 887 888 // When this is a new subframe navigation, we should have a committed page 889 // for which it's a suframe in. This may not be the case when an iframe is 890 // navigated on a popup navigated to about:blank (the iframe would be 891 // written into the popup by script on the main page). For these cases, 892 // there isn't any navigation stuff we can do, so just ignore it. 893 if (!GetLastCommittedEntry()) 894 return NAVIGATION_TYPE_NAV_IGNORE; 895 896 // Valid subframe navigation. 897 return NAVIGATION_TYPE_NEW_SUBFRAME; 898 } 899 900 // We only clear the session history when navigating to a new page. 901 DCHECK(!params.history_list_was_cleared); 902 903 // Now we know that the notification is for an existing page. Find that entry. 904 int existing_entry_index = GetEntryIndexWithPageID( 905 rvh->GetSiteInstance(), 906 params.page_id); 907 if (existing_entry_index == -1) { 908 // The page was not found. It could have been pruned because of the limit on 909 // back/forward entries (not likely since we'll usually tell it to navigate 910 // to such entries). It could also mean that the renderer is smoking crack. 911 NOTREACHED(); 912 913 // Because the unknown entry has committed, we risk showing the wrong URL in 914 // release builds. Instead, we'll kill the renderer process to be safe. 915 LOG(ERROR) << "terminating renderer for bad navigation: " << params.url; 916 RecordAction(base::UserMetricsAction("BadMessageTerminate_NC")); 917 918 // Temporary code so we can get more information. Format: 919 // http://url/foo.html#page1#max3#frame1#ids:2_Nx,1_1x,3_2 920 std::string temp = params.url.spec(); 921 temp.append("#page"); 922 temp.append(base::IntToString(params.page_id)); 923 temp.append("#max"); 924 temp.append(base::IntToString(delegate_->GetMaxPageID())); 925 temp.append("#frame"); 926 temp.append(base::IntToString(params.frame_id)); 927 temp.append("#ids"); 928 for (int i = 0; i < static_cast<int>(entries_.size()); ++i) { 929 // Append entry metadata (e.g., 3_7x): 930 // 3: page_id 931 // 7: SiteInstance ID, or N for null 932 // x: appended if not from the current SiteInstance 933 temp.append(base::IntToString(entries_[i]->GetPageID())); 934 temp.append("_"); 935 if (entries_[i]->site_instance()) 936 temp.append(base::IntToString(entries_[i]->site_instance()->GetId())); 937 else 938 temp.append("N"); 939 if (entries_[i]->site_instance() != rvh->GetSiteInstance()) 940 temp.append("x"); 941 temp.append(","); 942 } 943 GURL url(temp); 944 static_cast<RenderViewHostImpl*>(rvh)->Send( 945 new ViewMsg_TempCrashWithData(url)); 946 return NAVIGATION_TYPE_NAV_IGNORE; 947 } 948 NavigationEntryImpl* existing_entry = entries_[existing_entry_index].get(); 949 950 if (!PageTransitionIsMainFrame(params.transition)) { 951 // All manual subframes would get new IDs and were handled above, so we 952 // know this is auto. Since the current page was found in the navigation 953 // entry list, we're guaranteed to have a last committed entry. 954 DCHECK(GetLastCommittedEntry()); 955 return NAVIGATION_TYPE_AUTO_SUBFRAME; 956 } 957 958 // Anything below here we know is a main frame navigation. 959 if (pending_entry_ && 960 !pending_entry_->is_renderer_initiated() && 961 existing_entry != pending_entry_ && 962 pending_entry_->GetPageID() == -1 && 963 existing_entry == GetLastCommittedEntry()) { 964 // In this case, we have a pending entry for a URL but WebCore didn't do a 965 // new navigation. This happens when you press enter in the URL bar to 966 // reload. We will create a pending entry, but WebKit will convert it to 967 // a reload since it's the same page and not create a new entry for it 968 // (the user doesn't want to have a new back/forward entry when they do 969 // this). If this matches the last committed entry, we want to just ignore 970 // the pending entry and go back to where we were (the "existing entry"). 971 return NAVIGATION_TYPE_SAME_PAGE; 972 } 973 974 // Any toplevel navigations with the same base (minus the reference fragment) 975 // are in-page navigations. We weeded out subframe navigations above. Most of 976 // the time this doesn't matter since WebKit doesn't tell us about subframe 977 // navigations that don't actually navigate, but it can happen when there is 978 // an encoding override (it always sends a navigation request). 979 if (AreURLsInPageNavigation(existing_entry->GetURL(), params.url, 980 params.was_within_same_page, 981 NAVIGATION_TYPE_UNKNOWN)) { 982 return NAVIGATION_TYPE_IN_PAGE; 983 } 984 985 // Since we weeded out "new" navigations above, we know this is an existing 986 // (back/forward) navigation. 987 return NAVIGATION_TYPE_EXISTING_PAGE; 988} 989 990void NavigationControllerImpl::RendererDidNavigateToNewPage( 991 RenderViewHost* rvh, 992 const FrameHostMsg_DidCommitProvisionalLoad_Params& params, 993 bool replace_entry) { 994 NavigationEntryImpl* new_entry; 995 bool update_virtual_url; 996 // Only make a copy of the pending entry if it is appropriate for the new page 997 // that was just loaded. We verify this at a coarse grain by checking that 998 // the SiteInstance hasn't been assigned to something else. 999 if (pending_entry_ && 1000 (!pending_entry_->site_instance() || 1001 pending_entry_->site_instance() == rvh->GetSiteInstance())) { 1002 new_entry = new NavigationEntryImpl(*pending_entry_); 1003 1004 // Don't use the page type from the pending entry. Some interstitial page 1005 // may have set the type to interstitial. Once we commit, however, the page 1006 // type must always be normal. 1007 new_entry->set_page_type(PAGE_TYPE_NORMAL); 1008 update_virtual_url = new_entry->update_virtual_url_with_url(); 1009 } else { 1010 new_entry = new NavigationEntryImpl; 1011 1012 // Find out whether the new entry needs to update its virtual URL on URL 1013 // change and set up the entry accordingly. This is needed to correctly 1014 // update the virtual URL when replaceState is called after a pushState. 1015 GURL url = params.url; 1016 bool needs_update = false; 1017 BrowserURLHandlerImpl::GetInstance()->RewriteURLIfNecessary( 1018 &url, browser_context_, &needs_update); 1019 new_entry->set_update_virtual_url_with_url(needs_update); 1020 1021 // When navigating to a new page, give the browser URL handler a chance to 1022 // update the virtual URL based on the new URL. For example, this is needed 1023 // to show chrome://bookmarks/#1 when the bookmarks webui extension changes 1024 // the URL. 1025 update_virtual_url = needs_update; 1026 } 1027 1028 new_entry->SetURL(params.url); 1029 if (update_virtual_url) 1030 UpdateVirtualURLToURL(new_entry, params.url); 1031 new_entry->SetReferrer(params.referrer); 1032 new_entry->SetPageID(params.page_id); 1033 new_entry->SetTransitionType(params.transition); 1034 new_entry->set_site_instance( 1035 static_cast<SiteInstanceImpl*>(rvh->GetSiteInstance())); 1036 new_entry->SetHasPostData(params.is_post); 1037 new_entry->SetPostID(params.post_id); 1038 new_entry->SetOriginalRequestURL(params.original_request_url); 1039 new_entry->SetIsOverridingUserAgent(params.is_overriding_user_agent); 1040 1041 DCHECK(!params.history_list_was_cleared || !replace_entry); 1042 // The browser requested to clear the session history when it initiated the 1043 // navigation. Now we know that the renderer has updated its state accordingly 1044 // and it is safe to also clear the browser side history. 1045 if (params.history_list_was_cleared) { 1046 DiscardNonCommittedEntriesInternal(); 1047 entries_.clear(); 1048 last_committed_entry_index_ = -1; 1049 } 1050 1051 InsertOrReplaceEntry(new_entry, replace_entry); 1052} 1053 1054void NavigationControllerImpl::RendererDidNavigateToExistingPage( 1055 RenderViewHost* rvh, 1056 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) { 1057 // We should only get here for main frame navigations. 1058 DCHECK(PageTransitionIsMainFrame(params.transition)); 1059 1060 // This is a back/forward navigation. The existing page for the ID is 1061 // guaranteed to exist by ClassifyNavigation, and we just need to update it 1062 // with new information from the renderer. 1063 int entry_index = GetEntryIndexWithPageID(rvh->GetSiteInstance(), 1064 params.page_id); 1065 DCHECK(entry_index >= 0 && 1066 entry_index < static_cast<int>(entries_.size())); 1067 NavigationEntryImpl* entry = entries_[entry_index].get(); 1068 1069 // The URL may have changed due to redirects. 1070 entry->SetURL(params.url); 1071 entry->SetReferrer(params.referrer); 1072 if (entry->update_virtual_url_with_url()) 1073 UpdateVirtualURLToURL(entry, params.url); 1074 1075 // The redirected to page should not inherit the favicon from the previous 1076 // page. 1077 if (PageTransitionIsRedirect(params.transition)) 1078 entry->GetFavicon() = FaviconStatus(); 1079 1080 // The site instance will normally be the same except during session restore, 1081 // when no site instance will be assigned. 1082 DCHECK(entry->site_instance() == NULL || 1083 entry->site_instance() == rvh->GetSiteInstance()); 1084 entry->set_site_instance( 1085 static_cast<SiteInstanceImpl*>(rvh->GetSiteInstance())); 1086 1087 entry->SetHasPostData(params.is_post); 1088 entry->SetPostID(params.post_id); 1089 1090 // The entry we found in the list might be pending if the user hit 1091 // back/forward/reload. This load should commit it (since it's already in the 1092 // list, we can just discard the pending pointer). We should also discard the 1093 // pending entry if it corresponds to a different navigation, since that one 1094 // is now likely canceled. If it is not canceled, we will treat it as a new 1095 // navigation when it arrives, which is also ok. 1096 // 1097 // Note that we need to use the "internal" version since we don't want to 1098 // actually change any other state, just kill the pointer. 1099 DiscardNonCommittedEntriesInternal(); 1100 1101 // If a transient entry was removed, the indices might have changed, so we 1102 // have to query the entry index again. 1103 last_committed_entry_index_ = 1104 GetEntryIndexWithPageID(rvh->GetSiteInstance(), params.page_id); 1105} 1106 1107void NavigationControllerImpl::RendererDidNavigateToSamePage( 1108 RenderViewHost* rvh, 1109 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) { 1110 // This mode implies we have a pending entry that's the same as an existing 1111 // entry for this page ID. This entry is guaranteed to exist by 1112 // ClassifyNavigation. All we need to do is update the existing entry. 1113 NavigationEntryImpl* existing_entry = GetEntryWithPageID( 1114 rvh->GetSiteInstance(), params.page_id); 1115 1116 // We assign the entry's unique ID to be that of the new one. Since this is 1117 // always the result of a user action, we want to dismiss infobars, etc. like 1118 // a regular user-initiated navigation. 1119 existing_entry->set_unique_id(pending_entry_->GetUniqueID()); 1120 1121 // The URL may have changed due to redirects. 1122 if (existing_entry->update_virtual_url_with_url()) 1123 UpdateVirtualURLToURL(existing_entry, params.url); 1124 existing_entry->SetURL(params.url); 1125 existing_entry->SetReferrer(params.referrer); 1126 1127 // The page may have been requested with a different HTTP method. 1128 existing_entry->SetHasPostData(params.is_post); 1129 existing_entry->SetPostID(params.post_id); 1130 1131 DiscardNonCommittedEntries(); 1132} 1133 1134void NavigationControllerImpl::RendererDidNavigateInPage( 1135 RenderViewHost* rvh, 1136 const FrameHostMsg_DidCommitProvisionalLoad_Params& params, 1137 bool* did_replace_entry) { 1138 DCHECK(PageTransitionIsMainFrame(params.transition)) << 1139 "WebKit should only tell us about in-page navs for the main frame."; 1140 // We're guaranteed to have an entry for this one. 1141 NavigationEntryImpl* existing_entry = GetEntryWithPageID( 1142 rvh->GetSiteInstance(), params.page_id); 1143 1144 // Reference fragment navigation. We're guaranteed to have the last_committed 1145 // entry and it will be the same page as the new navigation (minus the 1146 // reference fragments, of course). We'll update the URL of the existing 1147 // entry without pruning the forward history. 1148 existing_entry->SetURL(params.url); 1149 if (existing_entry->update_virtual_url_with_url()) 1150 UpdateVirtualURLToURL(existing_entry, params.url); 1151 1152 // This replaces the existing entry since the page ID didn't change. 1153 *did_replace_entry = true; 1154 1155 DiscardNonCommittedEntriesInternal(); 1156 1157 // If a transient entry was removed, the indices might have changed, so we 1158 // have to query the entry index again. 1159 last_committed_entry_index_ = 1160 GetEntryIndexWithPageID(rvh->GetSiteInstance(), params.page_id); 1161} 1162 1163void NavigationControllerImpl::RendererDidNavigateNewSubframe( 1164 RenderViewHost* rvh, 1165 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) { 1166 if (PageTransitionCoreTypeIs(params.transition, 1167 PAGE_TRANSITION_AUTO_SUBFRAME)) { 1168 // This is not user-initiated. Ignore. 1169 DiscardNonCommittedEntriesInternal(); 1170 return; 1171 } 1172 1173 // Manual subframe navigations just get the current entry cloned so the user 1174 // can go back or forward to it. The actual subframe information will be 1175 // stored in the page state for each of those entries. This happens out of 1176 // band with the actual navigations. 1177 DCHECK(GetLastCommittedEntry()) << "ClassifyNavigation should guarantee " 1178 << "that a last committed entry exists."; 1179 NavigationEntryImpl* new_entry = new NavigationEntryImpl( 1180 *NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry())); 1181 new_entry->SetPageID(params.page_id); 1182 InsertOrReplaceEntry(new_entry, false); 1183} 1184 1185bool NavigationControllerImpl::RendererDidNavigateAutoSubframe( 1186 RenderViewHost* rvh, 1187 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) { 1188 // We're guaranteed to have a previously committed entry, and we now need to 1189 // handle navigation inside of a subframe in it without creating a new entry. 1190 DCHECK(GetLastCommittedEntry()); 1191 1192 // Handle the case where we're navigating back/forward to a previous subframe 1193 // navigation entry. This is case "2." in NAV_AUTO_SUBFRAME comment in the 1194 // header file. In case "1." this will be a NOP. 1195 int entry_index = GetEntryIndexWithPageID( 1196 rvh->GetSiteInstance(), 1197 params.page_id); 1198 if (entry_index < 0 || 1199 entry_index >= static_cast<int>(entries_.size())) { 1200 NOTREACHED(); 1201 return false; 1202 } 1203 1204 // Update the current navigation entry in case we're going back/forward. 1205 if (entry_index != last_committed_entry_index_) { 1206 last_committed_entry_index_ = entry_index; 1207 DiscardNonCommittedEntriesInternal(); 1208 return true; 1209 } 1210 1211 // We do not need to discard the pending entry in this case, since we will 1212 // not generate commit notifications for this auto-subframe navigation. 1213 return false; 1214} 1215 1216int NavigationControllerImpl::GetIndexOfEntry( 1217 const NavigationEntryImpl* entry) const { 1218 const NavigationEntries::const_iterator i(std::find( 1219 entries_.begin(), 1220 entries_.end(), 1221 entry)); 1222 return (i == entries_.end()) ? -1 : static_cast<int>(i - entries_.begin()); 1223} 1224 1225bool NavigationControllerImpl::IsURLInPageNavigation( 1226 const GURL& url, 1227 bool renderer_says_in_page, 1228 NavigationType navigation_type) const { 1229 NavigationEntry* last_committed = GetLastCommittedEntry(); 1230 return last_committed && AreURLsInPageNavigation( 1231 last_committed->GetURL(), url, renderer_says_in_page, navigation_type); 1232} 1233 1234void NavigationControllerImpl::CopyStateFrom( 1235 const NavigationController& temp) { 1236 const NavigationControllerImpl& source = 1237 static_cast<const NavigationControllerImpl&>(temp); 1238 // Verify that we look new. 1239 DCHECK(GetEntryCount() == 0 && !GetPendingEntry()); 1240 1241 if (source.GetEntryCount() == 0) 1242 return; // Nothing new to do. 1243 1244 needs_reload_ = true; 1245 InsertEntriesFrom(source, source.GetEntryCount()); 1246 1247 for (SessionStorageNamespaceMap::const_iterator it = 1248 source.session_storage_namespace_map_.begin(); 1249 it != source.session_storage_namespace_map_.end(); 1250 ++it) { 1251 SessionStorageNamespaceImpl* source_namespace = 1252 static_cast<SessionStorageNamespaceImpl*>(it->second.get()); 1253 session_storage_namespace_map_[it->first] = source_namespace->Clone(); 1254 } 1255 1256 FinishRestore(source.last_committed_entry_index_, RESTORE_CURRENT_SESSION); 1257 1258 // Copy the max page id map from the old tab to the new tab. This ensures 1259 // that new and existing navigations in the tab's current SiteInstances 1260 // are identified properly. 1261 delegate_->CopyMaxPageIDsFrom(source.delegate()->GetWebContents()); 1262} 1263 1264void NavigationControllerImpl::CopyStateFromAndPrune( 1265 NavigationController* temp, 1266 bool replace_entry) { 1267 // It is up to callers to check the invariants before calling this. 1268 CHECK(CanPruneAllButLastCommitted()); 1269 1270 NavigationControllerImpl* source = 1271 static_cast<NavigationControllerImpl*>(temp); 1272 // The SiteInstance and page_id of the last committed entry needs to be 1273 // remembered at this point, in case there is only one committed entry 1274 // and it is pruned. We use a scoped_refptr to ensure the SiteInstance 1275 // can't be freed during this time period. 1276 NavigationEntryImpl* last_committed = 1277 NavigationEntryImpl::FromNavigationEntry(GetLastCommittedEntry()); 1278 scoped_refptr<SiteInstance> site_instance( 1279 last_committed->site_instance()); 1280 int32 minimum_page_id = last_committed->GetPageID(); 1281 int32 max_page_id = 1282 delegate_->GetMaxPageIDForSiteInstance(site_instance.get()); 1283 1284 // Remove all the entries leaving the active entry. 1285 PruneAllButLastCommittedInternal(); 1286 1287 // We now have one entry, possibly with a new pending entry. Ensure that 1288 // adding the entries from source won't put us over the limit. 1289 DCHECK_EQ(1, GetEntryCount()); 1290 if (!replace_entry) 1291 source->PruneOldestEntryIfFull(); 1292 1293 // Insert the entries from source. Don't use source->GetCurrentEntryIndex as 1294 // we don't want to copy over the transient entry. Ignore any pending entry, 1295 // since it has not committed in source. 1296 int max_source_index = source->last_committed_entry_index_; 1297 if (max_source_index == -1) 1298 max_source_index = source->GetEntryCount(); 1299 else 1300 max_source_index++; 1301 1302 // Ignore the source's current entry if merging with replacement. 1303 // TODO(davidben): This should preserve entries forward of the current 1304 // too. http://crbug.com/317872 1305 if (replace_entry && max_source_index > 0) 1306 max_source_index--; 1307 1308 InsertEntriesFrom(*source, max_source_index); 1309 1310 // Adjust indices such that the last entry and pending are at the end now. 1311 last_committed_entry_index_ = GetEntryCount() - 1; 1312 1313 delegate_->SetHistoryLengthAndPrune(site_instance.get(), 1314 max_source_index, 1315 minimum_page_id); 1316 1317 // Copy the max page id map from the old tab to the new tab. This ensures 1318 // that new and existing navigations in the tab's current SiteInstances 1319 // are identified properly. 1320 delegate_->CopyMaxPageIDsFrom(source->delegate()->GetWebContents()); 1321 1322 // If there is a last committed entry, be sure to include it in the new 1323 // max page ID map. 1324 if (max_page_id > -1) { 1325 delegate_->UpdateMaxPageIDForSiteInstance(site_instance.get(), 1326 max_page_id); 1327 } 1328} 1329 1330bool NavigationControllerImpl::CanPruneAllButLastCommitted() { 1331 // If there is no last committed entry, we cannot prune. Even if there is a 1332 // pending entry, it may not commit, leaving this WebContents blank, despite 1333 // possibly giving it new entries via CopyStateFromAndPrune. 1334 if (last_committed_entry_index_ == -1) 1335 return false; 1336 1337 // We cannot prune if there is a pending entry at an existing entry index. 1338 // It may not commit, so we have to keep the last committed entry, and thus 1339 // there is no sensible place to keep the pending entry. It is ok to have 1340 // a new pending entry, which can optionally commit as a new navigation. 1341 if (pending_entry_index_ != -1) 1342 return false; 1343 1344 // We should not prune if we are currently showing a transient entry. 1345 if (transient_entry_index_ != -1) 1346 return false; 1347 1348 return true; 1349} 1350 1351void NavigationControllerImpl::PruneAllButLastCommitted() { 1352 PruneAllButLastCommittedInternal(); 1353 1354 // We should still have a last committed entry. 1355 DCHECK_NE(-1, last_committed_entry_index_); 1356 1357 // We pass 0 instead of GetEntryCount() for the history_length parameter of 1358 // SetHistoryLengthAndPrune, because it will create history_length additional 1359 // history entries. 1360 // TODO(jochen): This API is confusing and we should clean it up. 1361 // http://crbug.com/178491 1362 NavigationEntryImpl* entry = 1363 NavigationEntryImpl::FromNavigationEntry(GetVisibleEntry()); 1364 delegate_->SetHistoryLengthAndPrune( 1365 entry->site_instance(), 0, entry->GetPageID()); 1366} 1367 1368void NavigationControllerImpl::PruneAllButLastCommittedInternal() { 1369 // It is up to callers to check the invariants before calling this. 1370 CHECK(CanPruneAllButLastCommitted()); 1371 1372 // Erase all entries but the last committed entry. There may still be a 1373 // new pending entry after this. 1374 entries_.erase(entries_.begin(), 1375 entries_.begin() + last_committed_entry_index_); 1376 entries_.erase(entries_.begin() + 1, entries_.end()); 1377 last_committed_entry_index_ = 0; 1378} 1379 1380void NavigationControllerImpl::ClearAllScreenshots() { 1381 screenshot_manager_->ClearAllScreenshots(); 1382} 1383 1384void NavigationControllerImpl::SetSessionStorageNamespace( 1385 const std::string& partition_id, 1386 SessionStorageNamespace* session_storage_namespace) { 1387 if (!session_storage_namespace) 1388 return; 1389 1390 // We can't overwrite an existing SessionStorage without violating spec. 1391 // Attempts to do so may give a tab access to another tab's session storage 1392 // so die hard on an error. 1393 bool successful_insert = session_storage_namespace_map_.insert( 1394 make_pair(partition_id, 1395 static_cast<SessionStorageNamespaceImpl*>( 1396 session_storage_namespace))) 1397 .second; 1398 CHECK(successful_insert) << "Cannot replace existing SessionStorageNamespace"; 1399} 1400 1401void NavigationControllerImpl::SetMaxRestoredPageID(int32 max_id) { 1402 max_restored_page_id_ = max_id; 1403} 1404 1405int32 NavigationControllerImpl::GetMaxRestoredPageID() const { 1406 return max_restored_page_id_; 1407} 1408 1409SessionStorageNamespace* 1410NavigationControllerImpl::GetSessionStorageNamespace(SiteInstance* instance) { 1411 std::string partition_id; 1412 if (instance) { 1413 // TODO(ajwong): When GetDefaultSessionStorageNamespace() goes away, remove 1414 // this if statement so |instance| must not be NULL. 1415 partition_id = 1416 GetContentClient()->browser()->GetStoragePartitionIdForSite( 1417 browser_context_, instance->GetSiteURL()); 1418 } 1419 1420 SessionStorageNamespaceMap::const_iterator it = 1421 session_storage_namespace_map_.find(partition_id); 1422 if (it != session_storage_namespace_map_.end()) 1423 return it->second.get(); 1424 1425 // Create one if no one has accessed session storage for this partition yet. 1426 // 1427 // TODO(ajwong): Should this use the |partition_id| directly rather than 1428 // re-lookup via |instance|? http://crbug.com/142685 1429 StoragePartition* partition = 1430 BrowserContext::GetStoragePartition(browser_context_, instance); 1431 SessionStorageNamespaceImpl* session_storage_namespace = 1432 new SessionStorageNamespaceImpl( 1433 static_cast<DOMStorageContextWrapper*>( 1434 partition->GetDOMStorageContext())); 1435 session_storage_namespace_map_[partition_id] = session_storage_namespace; 1436 1437 return session_storage_namespace; 1438} 1439 1440SessionStorageNamespace* 1441NavigationControllerImpl::GetDefaultSessionStorageNamespace() { 1442 // TODO(ajwong): Remove if statement in GetSessionStorageNamespace(). 1443 return GetSessionStorageNamespace(NULL); 1444} 1445 1446const SessionStorageNamespaceMap& 1447NavigationControllerImpl::GetSessionStorageNamespaceMap() const { 1448 return session_storage_namespace_map_; 1449} 1450 1451bool NavigationControllerImpl::NeedsReload() const { 1452 return needs_reload_; 1453} 1454 1455void NavigationControllerImpl::SetNeedsReload() { 1456 needs_reload_ = true; 1457} 1458 1459void NavigationControllerImpl::RemoveEntryAtIndexInternal(int index) { 1460 DCHECK(index < GetEntryCount()); 1461 DCHECK(index != last_committed_entry_index_); 1462 1463 DiscardNonCommittedEntries(); 1464 1465 entries_.erase(entries_.begin() + index); 1466 if (last_committed_entry_index_ > index) 1467 last_committed_entry_index_--; 1468} 1469 1470void NavigationControllerImpl::DiscardNonCommittedEntries() { 1471 bool transient = transient_entry_index_ != -1; 1472 DiscardNonCommittedEntriesInternal(); 1473 1474 // If there was a transient entry, invalidate everything so the new active 1475 // entry state is shown. 1476 if (transient) { 1477 delegate_->NotifyNavigationStateChanged(kInvalidateAll); 1478 } 1479} 1480 1481NavigationEntry* NavigationControllerImpl::GetPendingEntry() const { 1482 return pending_entry_; 1483} 1484 1485int NavigationControllerImpl::GetPendingEntryIndex() const { 1486 return pending_entry_index_; 1487} 1488 1489void NavigationControllerImpl::InsertOrReplaceEntry(NavigationEntryImpl* entry, 1490 bool replace) { 1491 DCHECK(entry->GetTransitionType() != PAGE_TRANSITION_AUTO_SUBFRAME); 1492 1493 // Copy the pending entry's unique ID to the committed entry. 1494 // I don't know if pending_entry_index_ can be other than -1 here. 1495 const NavigationEntryImpl* const pending_entry = 1496 (pending_entry_index_ == -1) ? 1497 pending_entry_ : entries_[pending_entry_index_].get(); 1498 if (pending_entry) 1499 entry->set_unique_id(pending_entry->GetUniqueID()); 1500 1501 DiscardNonCommittedEntriesInternal(); 1502 1503 int current_size = static_cast<int>(entries_.size()); 1504 1505 if (current_size > 0) { 1506 // Prune any entries which are in front of the current entry. 1507 // Also prune the current entry if we are to replace the current entry. 1508 // last_committed_entry_index_ must be updated here since calls to 1509 // NotifyPrunedEntries() below may re-enter and we must make sure 1510 // last_committed_entry_index_ is not left in an invalid state. 1511 if (replace) 1512 --last_committed_entry_index_; 1513 1514 int num_pruned = 0; 1515 while (last_committed_entry_index_ < (current_size - 1)) { 1516 num_pruned++; 1517 entries_.pop_back(); 1518 current_size--; 1519 } 1520 if (num_pruned > 0) // Only notify if we did prune something. 1521 NotifyPrunedEntries(this, false, num_pruned); 1522 } 1523 1524 PruneOldestEntryIfFull(); 1525 1526 entries_.push_back(linked_ptr<NavigationEntryImpl>(entry)); 1527 last_committed_entry_index_ = static_cast<int>(entries_.size()) - 1; 1528 1529 // This is a new page ID, so we need everybody to know about it. 1530 delegate_->UpdateMaxPageID(entry->GetPageID()); 1531} 1532 1533void NavigationControllerImpl::PruneOldestEntryIfFull() { 1534 if (entries_.size() >= max_entry_count()) { 1535 DCHECK_EQ(max_entry_count(), entries_.size()); 1536 DCHECK_GT(last_committed_entry_index_, 0); 1537 RemoveEntryAtIndex(0); 1538 NotifyPrunedEntries(this, true, 1); 1539 } 1540} 1541 1542void NavigationControllerImpl::NavigateToPendingEntry(ReloadType reload_type) { 1543 needs_reload_ = false; 1544 1545 // If we were navigating to a slow-to-commit page, and the user performs 1546 // a session history navigation to the last committed page, RenderViewHost 1547 // will force the throbber to start, but WebKit will essentially ignore the 1548 // navigation, and won't send a message to stop the throbber. To prevent this 1549 // from happening, we drop the navigation here and stop the slow-to-commit 1550 // page from loading (which would normally happen during the navigation). 1551 if (pending_entry_index_ != -1 && 1552 pending_entry_index_ == last_committed_entry_index_ && 1553 (entries_[pending_entry_index_]->restore_type() == 1554 NavigationEntryImpl::RESTORE_NONE) && 1555 (entries_[pending_entry_index_]->GetTransitionType() & 1556 PAGE_TRANSITION_FORWARD_BACK)) { 1557 delegate_->Stop(); 1558 1559 // If an interstitial page is showing, we want to close it to get back 1560 // to what was showing before. 1561 if (delegate_->GetInterstitialPage()) 1562 delegate_->GetInterstitialPage()->DontProceed(); 1563 1564 DiscardNonCommittedEntries(); 1565 return; 1566 } 1567 1568 // If an interstitial page is showing, the previous renderer is blocked and 1569 // cannot make new requests. Unblock (and disable) it to allow this 1570 // navigation to succeed. The interstitial will stay visible until the 1571 // resulting DidNavigate. 1572 if (delegate_->GetInterstitialPage()) { 1573 static_cast<InterstitialPageImpl*>(delegate_->GetInterstitialPage())-> 1574 CancelForNavigation(); 1575 } 1576 1577 // For session history navigations only the pending_entry_index_ is set. 1578 if (!pending_entry_) { 1579 DCHECK_NE(pending_entry_index_, -1); 1580 pending_entry_ = entries_[pending_entry_index_].get(); 1581 } 1582 1583 if (!delegate_->NavigateToPendingEntry(reload_type)) 1584 DiscardNonCommittedEntries(); 1585 1586 // If the entry is being restored and doesn't have a SiteInstance yet, fill 1587 // it in now that we know. This allows us to find the entry when it commits. 1588 // This works for browser-initiated navigations. We handle renderer-initiated 1589 // navigations to restored entries in WebContentsImpl::OnGoToEntryAtOffset. 1590 if (pending_entry_ && !pending_entry_->site_instance() && 1591 pending_entry_->restore_type() != NavigationEntryImpl::RESTORE_NONE) { 1592 pending_entry_->set_site_instance(static_cast<SiteInstanceImpl*>( 1593 delegate_->GetPendingSiteInstance())); 1594 pending_entry_->set_restore_type(NavigationEntryImpl::RESTORE_NONE); 1595 } 1596} 1597 1598void NavigationControllerImpl::NotifyNavigationEntryCommitted( 1599 LoadCommittedDetails* details) { 1600 details->entry = GetLastCommittedEntry(); 1601 1602 // We need to notify the ssl_manager_ before the web_contents_ so the 1603 // location bar will have up-to-date information about the security style 1604 // when it wants to draw. See http://crbug.com/11157 1605 ssl_manager_.DidCommitProvisionalLoad(*details); 1606 1607 delegate_->NotifyNavigationStateChanged(kInvalidateAll); 1608 delegate_->NotifyNavigationEntryCommitted(*details); 1609 1610 // TODO(avi): Remove. http://crbug.com/170921 1611 NotificationDetails notification_details = 1612 Details<LoadCommittedDetails>(details); 1613 NotificationService::current()->Notify( 1614 NOTIFICATION_NAV_ENTRY_COMMITTED, 1615 Source<NavigationController>(this), 1616 notification_details); 1617} 1618 1619// static 1620size_t NavigationControllerImpl::max_entry_count() { 1621 if (max_entry_count_for_testing_ != kMaxEntryCountForTestingNotSet) 1622 return max_entry_count_for_testing_; 1623 return kMaxSessionHistoryEntries; 1624} 1625 1626void NavigationControllerImpl::SetActive(bool is_active) { 1627 if (is_active && needs_reload_) 1628 LoadIfNecessary(); 1629} 1630 1631void NavigationControllerImpl::LoadIfNecessary() { 1632 if (!needs_reload_) 1633 return; 1634 1635 // Calling Reload() results in ignoring state, and not loading. 1636 // Explicitly use NavigateToPendingEntry so that the renderer uses the 1637 // cached state. 1638 pending_entry_index_ = last_committed_entry_index_; 1639 NavigateToPendingEntry(NO_RELOAD); 1640} 1641 1642void NavigationControllerImpl::NotifyEntryChanged(const NavigationEntry* entry, 1643 int index) { 1644 EntryChangedDetails det; 1645 det.changed_entry = entry; 1646 det.index = index; 1647 NotificationService::current()->Notify( 1648 NOTIFICATION_NAV_ENTRY_CHANGED, 1649 Source<NavigationController>(this), 1650 Details<EntryChangedDetails>(&det)); 1651} 1652 1653void NavigationControllerImpl::FinishRestore(int selected_index, 1654 RestoreType type) { 1655 DCHECK(selected_index >= 0 && selected_index < GetEntryCount()); 1656 ConfigureEntriesForRestore(&entries_, type); 1657 1658 SetMaxRestoredPageID(static_cast<int32>(GetEntryCount())); 1659 1660 last_committed_entry_index_ = selected_index; 1661} 1662 1663void NavigationControllerImpl::DiscardNonCommittedEntriesInternal() { 1664 DiscardPendingEntry(); 1665 DiscardTransientEntry(); 1666} 1667 1668void NavigationControllerImpl::DiscardPendingEntry() { 1669 if (pending_entry_index_ == -1) 1670 delete pending_entry_; 1671 pending_entry_ = NULL; 1672 pending_entry_index_ = -1; 1673} 1674 1675void NavigationControllerImpl::DiscardTransientEntry() { 1676 if (transient_entry_index_ == -1) 1677 return; 1678 entries_.erase(entries_.begin() + transient_entry_index_); 1679 if (last_committed_entry_index_ > transient_entry_index_) 1680 last_committed_entry_index_--; 1681 transient_entry_index_ = -1; 1682} 1683 1684int NavigationControllerImpl::GetEntryIndexWithPageID( 1685 SiteInstance* instance, int32 page_id) const { 1686 for (int i = static_cast<int>(entries_.size()) - 1; i >= 0; --i) { 1687 if ((entries_[i]->site_instance() == instance) && 1688 (entries_[i]->GetPageID() == page_id)) 1689 return i; 1690 } 1691 return -1; 1692} 1693 1694NavigationEntry* NavigationControllerImpl::GetTransientEntry() const { 1695 if (transient_entry_index_ == -1) 1696 return NULL; 1697 return entries_[transient_entry_index_].get(); 1698} 1699 1700void NavigationControllerImpl::SetTransientEntry(NavigationEntry* entry) { 1701 // Discard any current transient entry, we can only have one at a time. 1702 int index = 0; 1703 if (last_committed_entry_index_ != -1) 1704 index = last_committed_entry_index_ + 1; 1705 DiscardTransientEntry(); 1706 entries_.insert( 1707 entries_.begin() + index, linked_ptr<NavigationEntryImpl>( 1708 NavigationEntryImpl::FromNavigationEntry(entry))); 1709 transient_entry_index_ = index; 1710 delegate_->NotifyNavigationStateChanged(kInvalidateAll); 1711} 1712 1713void NavigationControllerImpl::InsertEntriesFrom( 1714 const NavigationControllerImpl& source, 1715 int max_index) { 1716 DCHECK_LE(max_index, source.GetEntryCount()); 1717 size_t insert_index = 0; 1718 for (int i = 0; i < max_index; i++) { 1719 // When cloning a tab, copy all entries except interstitial pages 1720 if (source.entries_[i].get()->GetPageType() != 1721 PAGE_TYPE_INTERSTITIAL) { 1722 entries_.insert(entries_.begin() + insert_index++, 1723 linked_ptr<NavigationEntryImpl>( 1724 new NavigationEntryImpl(*source.entries_[i]))); 1725 } 1726 } 1727} 1728 1729void NavigationControllerImpl::SetGetTimestampCallbackForTest( 1730 const base::Callback<base::Time()>& get_timestamp_callback) { 1731 get_timestamp_callback_ = get_timestamp_callback; 1732} 1733 1734} // namespace content 1735