blob: 31f27b8e7f466b5e41e36f41e0fea52bcac1e0bb [file] [log] [blame]
// Copyright (c) 2012 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 <stdint.h>
#include <memory>
#include <string>
#include "base/memory/ref_counted_memory.h"
#include "base/optional.h"
#include "base/strings/string16.h"
#include "base/time/time.h"
#include "build/build_config.h"
#include "content/common/content_export.h"
#include "content/public/common/page_type.h"
#include "content/public/common/referrer.h"
#include "services/network/public/cpp/resource_request_body.h"
#include "ui/base/page_transition_types.h"
class GURL;
namespace content {
class PageState;
struct FaviconStatus;
struct ReplacedNavigationEntryData;
struct SSLStatus;
// A NavigationEntry is a data structure that captures all the information
// required to recreate a browsing state. This includes some opaque binary
// state as provided by the WebContents as well as some clear text title and
// URL which is used for our user interface.
class NavigationEntry {
virtual ~NavigationEntry() {}
CONTENT_EXPORT static std::unique_ptr<NavigationEntry> Create();
// Page-related stuff --------------------------------------------------------
// A unique ID is preserved across commits and redirects, which means that
// sometimes a NavigationEntry's unique ID needs to be set (e.g. when
// creating a committed entry to correspond to a to-be-deleted pending entry,
// the pending entry's ID must be copied).
virtual int GetUniqueID() = 0;
// The page type tells us if this entry is for an interstitial or error page.
virtual content::PageType GetPageType() = 0;
// The actual URL of the page. For some about pages, this may be a scary
// data: URL or something like that. Use GetVirtualURL() below for showing to
// the user.
virtual void SetURL(const GURL& url) = 0;
virtual const GURL& GetURL() = 0;
// Used for specifying a base URL for pages loaded via data URLs.
virtual void SetBaseURLForDataURL(const GURL& url) = 0;
virtual const GURL& GetBaseURLForDataURL() = 0;
#if defined(OS_ANDROID)
// The real data: URL when it is received via WebView.loadDataWithBaseUrl
// method. Represented as a string to circumvent the size restriction
// of GURLs for compatibility with legacy Android WebView apps.
virtual void SetDataURLAsString(
scoped_refptr<base::RefCountedString> data_url) = 0;
virtual const scoped_refptr<const base::RefCountedString>&
GetDataURLAsString() = 0;
// The referring URL. Can be empty.
virtual void SetReferrer(const content::Referrer& referrer) = 0;
virtual const content::Referrer& GetReferrer() = 0;
// The virtual URL, when nonempty, will override the actual URL of the page
// when we display it to the user. This allows us to have nice and friendly
// URLs that the user sees for things like about: URLs, but actually feed
// the renderer a data URL that results in the content loading.
// GetVirtualURL() will return the URL to display to the user in all cases, so
// if there is no overridden display URL, it will return the actual one.
virtual void SetVirtualURL(const GURL& url) = 0;
virtual const GURL& GetVirtualURL() = 0;
// The title as set by the page. This will be empty if there is no title set.
// The caller is responsible for detecting when there is no title and
// displaying the appropriate "Untitled" label if this is being displayed to
// the user.
// Use WebContents::UpdateTitleForEntry() in most cases, since that notifies
// observers when the visible title changes. Only call
// NavigationEntry::SetTitle() below directly when this entry is known not to
// be visible.
virtual void SetTitle(const base::string16& title) = 0;
virtual const base::string16& GetTitle() = 0;
// Page state is an opaque blob created by Blink that represents the state of
// the page. This includes form entries and scroll position for each frame.
// We store it so that we can supply it back to Blink to restore form state
// properly when the user goes back and forward.
// NOTE: This state is saved to disk and used to restore previous states. If
// the format is modified in the future, we should still be able to deal with
// older versions.
virtual void SetPageState(const PageState& state) = 0;
virtual PageState GetPageState() = 0;
// Page-related helpers ------------------------------------------------------
// Returns the title to be displayed on the tab. This could be the title of
// the page if it is available or the URL.
virtual const base::string16& GetTitleForDisplay() = 0;
// Returns true if the current tab is in view source mode. This will be false
// if there is no navigation.
virtual bool IsViewSourceMode() = 0;
// Tracking stuff ------------------------------------------------------------
// The transition type indicates what the user did to move to this page from
// the previous page.
virtual void SetTransitionType(ui::PageTransition transition_type) = 0;
virtual ui::PageTransition GetTransitionType() = 0;
// The user typed URL was the URL that the user initiated the navigation
// with, regardless of any redirects. This is used to generate keywords, for
// example, based on "what the user thinks the site is called" rather than
// what it's actually called. For example, if the user types "", that
// may redirect somewhere arbitrary like "", and we want to use
// the name that the user things of the site as having.
// This URL will be is_empty() if the URL was navigated to some other way.
// Callers should fall back on using the regular or display URL in this case.
virtual const GURL& GetUserTypedURL() = 0;
// Post data is form data that was posted to get to this page. The data will
// have to be reposted to reload the page properly. This flag indicates
// whether the page had post data.
// The actual post data is stored either in
// 1) post_data when a new post data request is started.
// 2) PageState when a post request has started and is extracted by
// WebKit to actually make the request.
virtual void SetHasPostData(bool has_post_data) = 0;
virtual bool GetHasPostData() = 0;
// The Post identifier associated with the page.
virtual void SetPostID(int64_t post_id) = 0;
virtual int64_t GetPostID() = 0;
// Holds the raw post data of a post request.
// For efficiency, this should be cleared when PageState is populated
// since the data is duplicated.
// Note, this field:
// 1) is not persisted in session restore.
// 2) is shallow copied with the static copy Create method above.
// 3) may be nullptr so check before use.
virtual void SetPostData(
const scoped_refptr<network::ResourceRequestBody>& data) = 0;
virtual scoped_refptr<network::ResourceRequestBody> GetPostData() = 0;
// The favicon data and tracking information. See content::FaviconStatus.
virtual FaviconStatus& GetFavicon() = 0;
// All the SSL flags and state. See content::SSLStatus.
virtual SSLStatus& GetSSL() = 0;
// Store the URL that caused this NavigationEntry to be created.
virtual void SetOriginalRequestURL(const GURL& original_url) = 0;
virtual const GURL& GetOriginalRequestURL() = 0;
// Store whether or not we're overriding the user agent.
virtual void SetIsOverridingUserAgent(bool override) = 0;
virtual bool GetIsOverridingUserAgent() = 0;
// The time at which the last known local navigation has
// completed. (A navigation can be completed more than once if the
// page is reloaded.)
// If GetTimestamp() returns a null time, that means that either:
// - this navigation hasn't completed yet;
// - this navigation was restored and for some reason the
// timestamp wasn't available;
// - or this navigation was copied from a foreign session.
virtual void SetTimestamp(base::Time timestamp) = 0;
virtual base::Time GetTimestamp() = 0;
// Used to specify if this entry should be able to access local file://
// resources.
virtual void SetCanLoadLocalResources(bool allow) = 0;
virtual bool GetCanLoadLocalResources() = 0;
// Set extra data on this NavigationEntry according to the specified |key|.
// This data is not persisted by default.
virtual void SetExtraData(const std::string& key,
const base::string16& data) = 0;
// If present, fills the |data| present at the specified |key|.
virtual bool GetExtraData(const std::string& key, base::string16* data) = 0;
// Removes the data at the specified |key|.
virtual void ClearExtraData(const std::string& key) = 0;
// The status code of the last known successful navigation. If
// GetHttpStatusCode() returns 0 that means that either:
// - this navigation hasn't completed yet;
// - a response wasn't received;
// - or this navigation was restored and for some reason the
// status code wasn't available.
virtual void SetHttpStatusCode(int http_status_code) = 0;
virtual int GetHttpStatusCode() = 0;
// The redirect chain traversed during this navigation, from the initial
// redirecting URL to the final non-redirecting current URL.
virtual void SetRedirectChain(const std::vector<GURL>& redirects) = 0;
virtual const std::vector<GURL>& GetRedirectChain() = 0;
// When a history entry is replaced (e.g. history.replaceState()), this
// contains some information about the entry prior to being replaced. Even if
// an entry is replaced multiple times, it represents data prior to the
// *first* replace.
virtual const base::Optional<ReplacedNavigationEntryData>&
GetReplacedEntryData() = 0;
// True if this entry is restored and hasn't been loaded.
virtual bool IsRestored() = 0;
// Returns the extra headers (separated by \r\n) to send during the request.
virtual std::string GetExtraHeaders() = 0;
// Adds more extra headers (separated by \r\n) to send during the request.
virtual void AddExtraHeaders(const std::string& extra_headers) = 0;
} // namespace content