navigation_controller_impl.h revision 0529e5d033099cbfc42635f6f6183833b09dff6e
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#ifndef CONTENT_BROWSER_FRAME_HOST_NAVIGATION_CONTROLLER_IMPL_H_ 6#define CONTENT_BROWSER_FRAME_HOST_NAVIGATION_CONTROLLER_IMPL_H_ 7 8#include "base/callback.h" 9#include "base/compiler_specific.h" 10#include "base/gtest_prod_util.h" 11#include "base/memory/linked_ptr.h" 12#include "base/time/time.h" 13#include "build/build_config.h" 14#include "content/browser/frame_host/navigation_controller_delegate.h" 15#include "content/browser/ssl/ssl_manager.h" 16#include "content/public/browser/navigation_controller.h" 17#include "content/public/browser/navigation_type.h" 18 19struct FrameHostMsg_DidCommitProvisionalLoad_Params; 20 21namespace content { 22class NavigationEntryImpl; 23class RenderViewHost; 24class NavigationEntryScreenshotManager; 25class SiteInstance; 26struct LoadCommittedDetails; 27 28class CONTENT_EXPORT NavigationControllerImpl 29 : public NON_EXPORTED_BASE(NavigationController) { 30 public: 31 NavigationControllerImpl( 32 NavigationControllerDelegate* delegate, 33 BrowserContext* browser_context); 34 virtual ~NavigationControllerImpl(); 35 36 // NavigationController implementation: 37 virtual WebContents* GetWebContents() const OVERRIDE; 38 virtual BrowserContext* GetBrowserContext() const OVERRIDE; 39 virtual void SetBrowserContext( 40 BrowserContext* browser_context) OVERRIDE; 41 virtual void Restore( 42 int selected_navigation, 43 RestoreType type, 44 std::vector<NavigationEntry*>* entries) OVERRIDE; 45 virtual NavigationEntry* GetActiveEntry() const OVERRIDE; 46 virtual NavigationEntry* GetVisibleEntry() const OVERRIDE; 47 virtual int GetCurrentEntryIndex() const OVERRIDE; 48 virtual NavigationEntry* GetLastCommittedEntry() const OVERRIDE; 49 virtual int GetLastCommittedEntryIndex() const OVERRIDE; 50 virtual bool CanViewSource() const OVERRIDE; 51 virtual int GetEntryCount() const OVERRIDE; 52 virtual NavigationEntry* GetEntryAtIndex(int index) const OVERRIDE; 53 virtual NavigationEntry* GetEntryAtOffset(int offset) const OVERRIDE; 54 virtual void DiscardNonCommittedEntries() OVERRIDE; 55 virtual NavigationEntry* GetPendingEntry() const OVERRIDE; 56 virtual int GetPendingEntryIndex() const OVERRIDE; 57 virtual NavigationEntry* GetTransientEntry() const OVERRIDE; 58 virtual void SetTransientEntry(NavigationEntry* entry) OVERRIDE; 59 virtual void LoadURL(const GURL& url, 60 const Referrer& referrer, 61 PageTransition type, 62 const std::string& extra_headers) OVERRIDE; 63 virtual void LoadURLWithParams(const LoadURLParams& params) OVERRIDE; 64 virtual void LoadIfNecessary() OVERRIDE; 65 virtual bool CanGoBack() const OVERRIDE; 66 virtual bool CanGoForward() const OVERRIDE; 67 virtual bool CanGoToOffset(int offset) const OVERRIDE; 68 virtual void GoBack() OVERRIDE; 69 virtual void GoForward() OVERRIDE; 70 virtual void GoToIndex(int index) OVERRIDE; 71 virtual void GoToOffset(int offset) OVERRIDE; 72 virtual bool RemoveEntryAtIndex(int index) OVERRIDE; 73 virtual const SessionStorageNamespaceMap& 74 GetSessionStorageNamespaceMap() const OVERRIDE; 75 virtual SessionStorageNamespace* 76 GetDefaultSessionStorageNamespace() OVERRIDE; 77 virtual void SetMaxRestoredPageID(int32 max_id) OVERRIDE; 78 virtual int32 GetMaxRestoredPageID() const OVERRIDE; 79 virtual bool NeedsReload() const OVERRIDE; 80 virtual void SetNeedsReload() OVERRIDE; 81 virtual void CancelPendingReload() OVERRIDE; 82 virtual void ContinuePendingReload() OVERRIDE; 83 virtual bool IsInitialNavigation() const OVERRIDE; 84 virtual void Reload(bool check_for_repost) OVERRIDE; 85 virtual void ReloadIgnoringCache(bool check_for_repost) OVERRIDE; 86 virtual void ReloadOriginalRequestURL(bool check_for_repost) OVERRIDE; 87 virtual void NotifyEntryChanged(const NavigationEntry* entry, 88 int index) OVERRIDE; 89 virtual void CopyStateFrom( 90 const NavigationController& source) OVERRIDE; 91 virtual void CopyStateFromAndPrune(NavigationController* source, 92 bool replace_entry) OVERRIDE; 93 virtual bool CanPruneAllButLastCommitted() OVERRIDE; 94 virtual void PruneAllButLastCommitted() OVERRIDE; 95 virtual void ClearAllScreenshots() OVERRIDE; 96 97 // Whether this is the initial navigation in an unmodified new tab. In this 98 // case, we know there is no content displayed in the page. 99 bool IsUnmodifiedBlankTab() const; 100 101 // The session storage namespace that all child RenderViews belonging to 102 // |instance| should use. 103 SessionStorageNamespace* GetSessionStorageNamespace( 104 SiteInstance* instance); 105 106 // Returns the index of the specified entry, or -1 if entry is not contained 107 // in this NavigationController. 108 int GetIndexOfEntry(const NavigationEntryImpl* entry) const; 109 110 // Return the index of the entry with the corresponding instance and page_id, 111 // or -1 if not found. 112 int GetEntryIndexWithPageID(SiteInstance* instance, 113 int32 page_id) const; 114 115 // Return the entry with the corresponding instance and page_id, or NULL if 116 // not found. 117 NavigationEntryImpl* GetEntryWithPageID( 118 SiteInstance* instance, 119 int32 page_id) const; 120 121 NavigationControllerDelegate* delegate() const { 122 return delegate_; 123 } 124 125 // For use by WebContentsImpl ------------------------------------------------ 126 127 // Allow renderer-initiated navigations to create a pending entry when the 128 // provisional load starts. 129 void SetPendingEntry(content::NavigationEntryImpl* entry); 130 131 // Handles updating the navigation state after the renderer has navigated. 132 // This is used by the WebContentsImpl. 133 // 134 // If a new entry is created, it will return true and will have filled the 135 // given details structure and broadcast the NOTIFY_NAV_ENTRY_COMMITTED 136 // notification. The caller can then use the details without worrying about 137 // listening for the notification. 138 // 139 // In the case that nothing has changed, the details structure is undefined 140 // and it will return false. 141 bool RendererDidNavigate( 142 RenderFrameHost* rfh, 143 const FrameHostMsg_DidCommitProvisionalLoad_Params& params, 144 LoadCommittedDetails* details); 145 146 // Notifies us that we just became active. This is used by the WebContentsImpl 147 // so that we know to load URLs that were pending as "lazy" loads. 148 void SetActive(bool is_active); 149 150 // Returns true if the given URL would be an in-page navigation (i.e. only 151 // the reference fragment is different) from the "last committed entry". We do 152 // not compare it against the "active entry" since the active entry can be 153 // pending and in page navigations only happen on committed pages. If there 154 // is no last committed entry, then nothing will be in-page. 155 // 156 // Special note: if the URLs are the same, it does NOT automatically count as 157 // an in-page navigation. Neither does an input URL that has no ref, even if 158 // the rest is the same. This may seem weird, but when we're considering 159 // whether a navigation happened without loading anything, the same URL could 160 // be a reload, while only a different ref would be in-page (pages can't clear 161 // refs without reload, only change to "#" which we don't count as empty). 162 bool IsURLInPageNavigation(const GURL& url) const { 163 return IsURLInPageNavigation(url, false, NAVIGATION_TYPE_UNKNOWN); 164 } 165 166 // The situation is made murkier by history.replaceState(), which could 167 // provide the same URL as part of an in-page navigation, not a reload. So 168 // we need this form which lets the (untrustworthy) renderer resolve the 169 // ambiguity, but only when the URLs are equal. This should be safe since the 170 // origin isn't changing. 171 bool IsURLInPageNavigation( 172 const GURL& url, 173 bool renderer_says_in_page, 174 NavigationType navigation_type) const; 175 176 // Sets the SessionStorageNamespace for the given |partition_id|. This is 177 // used during initialization of a new NavigationController to allow 178 // pre-population of the SessionStorageNamespace objects. Session restore, 179 // prerendering, and the implementaion of window.open() are the primary users 180 // of this API. 181 // 182 // Calling this function when a SessionStorageNamespace has already been 183 // associated with a |partition_id| will CHECK() fail. 184 void SetSessionStorageNamespace( 185 const std::string& partition_id, 186 SessionStorageNamespace* session_storage_namespace); 187 188 // Random data --------------------------------------------------------------- 189 190 SSLManager* ssl_manager() { return &ssl_manager_; } 191 192 // Maximum number of entries before we start removing entries from the front. 193 static void set_max_entry_count_for_testing(size_t max_entry_count) { 194 max_entry_count_for_testing_ = max_entry_count; 195 } 196 static size_t max_entry_count(); 197 198 void SetGetTimestampCallbackForTest( 199 const base::Callback<base::Time()>& get_timestamp_callback); 200 201 // Takes a screenshot of the page at the current state. 202 void TakeScreenshot(); 203 204 // Sets the screenshot manager for this NavigationControllerImpl. The 205 // controller takes ownership of the screenshot manager and destroys it when 206 // a new screenshot-manager is set, or when the controller is destroyed. 207 // Setting a NULL manager recreates the default screenshot manager and uses 208 // that. 209 void SetScreenshotManager(NavigationEntryScreenshotManager* manager); 210 211 // Discards only the pending entry. 212 void DiscardPendingEntry(); 213 214 private: 215 friend class RestoreHelper; 216 217 FRIEND_TEST_ALL_PREFIXES(NavigationControllerTest, 218 PurgeScreenshot); 219 FRIEND_TEST_ALL_PREFIXES(TimeSmoother, Basic); 220 FRIEND_TEST_ALL_PREFIXES(TimeSmoother, SingleDuplicate); 221 FRIEND_TEST_ALL_PREFIXES(TimeSmoother, ManyDuplicates); 222 FRIEND_TEST_ALL_PREFIXES(TimeSmoother, ClockBackwardsJump); 223 224 // Helper class to smooth out runs of duplicate timestamps while still 225 // allowing time to jump backwards. 226 class CONTENT_EXPORT TimeSmoother { 227 public: 228 // Returns |t| with possibly some time added on. 229 base::Time GetSmoothedTime(base::Time t); 230 231 private: 232 // |low_water_mark_| is the first time in a sequence of adjusted 233 // times and |high_water_mark_| is the last. 234 base::Time low_water_mark_; 235 base::Time high_water_mark_; 236 }; 237 238 // Classifies the given renderer navigation (see the NavigationType enum). 239 NavigationType ClassifyNavigation( 240 RenderFrameHost* rfh, 241 const FrameHostMsg_DidCommitProvisionalLoad_Params& params) const; 242 243 // Causes the controller to load the specified entry. The function assumes 244 // ownership of the pointer since it is put in the navigation list. 245 // NOTE: Do not pass an entry that the controller already owns! 246 void LoadEntry(NavigationEntryImpl* entry); 247 248 // Handlers for the different types of navigation types. They will actually 249 // handle the navigations corresponding to the different NavClasses above. 250 // They will NOT broadcast the commit notification, that should be handled by 251 // the caller. 252 // 253 // RendererDidNavigateAutoSubframe is special, it may not actually change 254 // anything if some random subframe is loaded. It will return true if anything 255 // changed, or false if not. 256 // 257 // The functions taking |did_replace_entry| will fill into the given variable 258 // whether the last entry has been replaced or not. 259 // See LoadCommittedDetails.did_replace_entry. 260 void RendererDidNavigateToNewPage( 261 RenderFrameHost* rfh, 262 const FrameHostMsg_DidCommitProvisionalLoad_Params& params, 263 bool replace_entry); 264 void RendererDidNavigateToExistingPage( 265 RenderFrameHost* rfh, 266 const FrameHostMsg_DidCommitProvisionalLoad_Params& params); 267 void RendererDidNavigateToSamePage( 268 RenderFrameHost* rfh, 269 const FrameHostMsg_DidCommitProvisionalLoad_Params& params); 270 void RendererDidNavigateInPage( 271 RenderFrameHost* rfh, 272 const FrameHostMsg_DidCommitProvisionalLoad_Params& params, 273 bool* did_replace_entry); 274 void RendererDidNavigateNewSubframe( 275 RenderFrameHost* rfh, 276 const FrameHostMsg_DidCommitProvisionalLoad_Params& params); 277 bool RendererDidNavigateAutoSubframe( 278 RenderFrameHost* rfh, 279 const FrameHostMsg_DidCommitProvisionalLoad_Params& params); 280 281 // Helper function for code shared between Reload() and ReloadIgnoringCache(). 282 void ReloadInternal(bool check_for_repost, ReloadType reload_type); 283 284 // Actually issues the navigation held in pending_entry. 285 void NavigateToPendingEntry(ReloadType reload_type); 286 287 // Allows the derived class to issue notifications that a load has been 288 // committed. This will fill in the active entry to the details structure. 289 void NotifyNavigationEntryCommitted(LoadCommittedDetails* details); 290 291 // Updates the virtual URL of an entry to match a new URL, for cases where 292 // the real renderer URL is derived from the virtual URL, like view-source: 293 void UpdateVirtualURLToURL(NavigationEntryImpl* entry, 294 const GURL& new_url); 295 296 // Invoked after session/tab restore or cloning a tab. Resets the transition 297 // type of the entries, updates the max page id and creates the active 298 // contents. 299 void FinishRestore(int selected_index, RestoreType type); 300 301 // Inserts a new entry or replaces the current entry with a new one, removing 302 // all entries after it. The new entry will become the active one. 303 void InsertOrReplaceEntry(NavigationEntryImpl* entry, bool replace); 304 305 // Removes the entry at |index|, as long as it is not the current entry. 306 void RemoveEntryAtIndexInternal(int index); 307 308 // Discards both the pending and transient entries. 309 void DiscardNonCommittedEntriesInternal(); 310 311 // Discards only the transient entry. 312 void DiscardTransientEntry(); 313 314 // If we have the maximum number of entries, remove the oldest one in 315 // preparation to add another. 316 void PruneOldestEntryIfFull(); 317 318 // Removes all entries except the last committed entry. If there is a new 319 // pending navigation it is preserved. In contrast to 320 // PruneAllButLastCommitted() this does not update the session history of the 321 // RenderView. Callers must ensure that |CanPruneAllButLastCommitted| returns 322 // true before calling this. 323 void PruneAllButLastCommittedInternal(); 324 325 // Returns true if the navigation is likley to be automatic rather than 326 // user-initiated. 327 bool IsLikelyAutoNavigation(base::TimeTicks now); 328 329 // Inserts up to |max_index| entries from |source| into this. This does NOT 330 // adjust any of the members that reference entries_ 331 // (last_committed_entry_index_, pending_entry_index_ or 332 // transient_entry_index_). 333 void InsertEntriesFrom(const NavigationControllerImpl& source, int max_index); 334 335 // Returns the navigation index that differs from the current entry by the 336 // specified |offset|. The index returned is not guaranteed to be valid. 337 int GetIndexForOffset(int offset) const; 338 339 // --------------------------------------------------------------------------- 340 341 // The user browser context associated with this controller. 342 BrowserContext* browser_context_; 343 344 // List of NavigationEntry for this tab 345 typedef std::vector<linked_ptr<NavigationEntryImpl> > NavigationEntries; 346 NavigationEntries entries_; 347 348 // An entry we haven't gotten a response for yet. This will be discarded 349 // when we navigate again. It's used only so we know what the currently 350 // displayed tab is. 351 // 352 // This may refer to an item in the entries_ list if the pending_entry_index_ 353 // == -1, or it may be its own entry that should be deleted. Be careful with 354 // the memory management. 355 NavigationEntryImpl* pending_entry_; 356 357 // currently visible entry 358 int last_committed_entry_index_; 359 360 // index of pending entry if it is in entries_, or -1 if pending_entry_ is a 361 // new entry (created by LoadURL). 362 int pending_entry_index_; 363 364 // The index for the entry that is shown until a navigation occurs. This is 365 // used for interstitial pages. -1 if there are no such entry. 366 // Note that this entry really appears in the list of entries, but only 367 // temporarily (until the next navigation). Any index pointing to an entry 368 // after the transient entry will become invalid if you navigate forward. 369 int transient_entry_index_; 370 371 // The delegate associated with the controller. Possibly NULL during 372 // setup. 373 NavigationControllerDelegate* delegate_; 374 375 // The max restored page ID in this controller, if it was restored. We must 376 // store this so that WebContentsImpl can tell any renderer in charge of one 377 // of the restored entries to update its max page ID. 378 int32 max_restored_page_id_; 379 380 // Manages the SSL security UI. 381 SSLManager ssl_manager_; 382 383 // Whether we need to be reloaded when made active. 384 bool needs_reload_; 385 386 // Whether this is the initial navigation. 387 // Becomes false when initial navigation commits. 388 bool is_initial_navigation_; 389 390 // Prevent unsafe re-entrant calls to NavigateToPendingEntry. 391 bool in_navigate_to_pending_entry_; 392 393 // Used to find the appropriate SessionStorageNamespace for the storage 394 // partition of a NavigationEntry. 395 // 396 // A NavigationController may contain NavigationEntries that correspond to 397 // different StoragePartitions. Even though they are part of the same 398 // NavigationController, only entries in the same StoragePartition may 399 // share session storage state with one another. 400 SessionStorageNamespaceMap session_storage_namespace_map_; 401 402 // The maximum number of entries that a navigation controller can store. 403 static size_t max_entry_count_for_testing_; 404 405 // If a repost is pending, its type (RELOAD or RELOAD_IGNORING_CACHE), 406 // NO_RELOAD otherwise. 407 ReloadType pending_reload_; 408 409 // Used to get timestamps for newly-created navigation entries. 410 base::Callback<base::Time()> get_timestamp_callback_; 411 412 // Used to smooth out timestamps from |get_timestamp_callback_|. 413 // Without this, whenever there is a run of redirects or 414 // code-generated navigations, those navigations may occur within 415 // the timer resolution, leading to things sometimes showing up in 416 // the wrong order in the history view. 417 TimeSmoother time_smoother_; 418 419 scoped_ptr<NavigationEntryScreenshotManager> screenshot_manager_; 420 421 DISALLOW_COPY_AND_ASSIGN(NavigationControllerImpl); 422}; 423 424} // namespace content 425 426#endif // CONTENT_BROWSER_FRAME_HOST_NAVIGATION_CONTROLLER_IMPL_H_ 427