1// Copyright (c) 2012 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_PUBLIC_BROWSER_NAVIGATION_ENTRY_H_
6#define CONTENT_PUBLIC_BROWSER_NAVIGATION_ENTRY_H_
7
8#include <string>
9
10#include "base/memory/ref_counted_memory.h"
11#include "base/strings/string16.h"
12#include "base/time/time.h"
13#include "content/common/content_export.h"
14#include "content/public/common/page_transition_types.h"
15#include "content/public/common/page_type.h"
16#include "content/public/common/referrer.h"
17
18class GURL;
19
20namespace content {
21
22class PageState;
23struct FaviconStatus;
24struct SSLStatus;
25
26// A NavigationEntry is a data structure that captures all the information
27// required to recreate a browsing state. This includes some opaque binary
28// state as provided by the WebContents as well as some clear text title and
29// URL which is used for our user interface.
30class NavigationEntry {
31 public:
32  virtual ~NavigationEntry() {}
33
34  CONTENT_EXPORT static NavigationEntry* Create();
35  CONTENT_EXPORT static NavigationEntry* Create(const NavigationEntry& copy);
36
37  // Page-related stuff --------------------------------------------------------
38
39  // A unique ID is preserved across commits and redirects, which means that
40  // sometimes a NavigationEntry's unique ID needs to be set (e.g. when
41  // creating a committed entry to correspond to a to-be-deleted pending entry,
42  // the pending entry's ID must be copied).
43  virtual int GetUniqueID() const = 0;
44
45  // The page type tells us if this entry is for an interstitial or error page.
46  virtual content::PageType GetPageType() const = 0;
47
48  // The actual URL of the page. For some about pages, this may be a scary
49  // data: URL or something like that. Use GetVirtualURL() below for showing to
50  // the user.
51  virtual void SetURL(const GURL& url) = 0;
52  virtual const GURL& GetURL() const = 0;
53
54  // Used for specifying a base URL for pages loaded via data URLs.
55  virtual void SetBaseURLForDataURL(const GURL& url) = 0;
56  virtual const GURL& GetBaseURLForDataURL() const = 0;
57
58  // The referring URL. Can be empty.
59  virtual void SetReferrer(const content::Referrer& referrer) = 0;
60  virtual const content::Referrer& GetReferrer() const = 0;
61
62  // The virtual URL, when nonempty, will override the actual URL of the page
63  // when we display it to the user. This allows us to have nice and friendly
64  // URLs that the user sees for things like about: URLs, but actually feed
65  // the renderer a data URL that results in the content loading.
66  //
67  // GetVirtualURL() will return the URL to display to the user in all cases, so
68  // if there is no overridden display URL, it will return the actual one.
69  virtual void SetVirtualURL(const GURL& url) = 0;
70  virtual const GURL& GetVirtualURL() const = 0;
71
72  // The title as set by the page. This will be empty if there is no title set.
73  // The caller is responsible for detecting when there is no title and
74  // displaying the appropriate "Untitled" label if this is being displayed to
75  // the user.
76  virtual void SetTitle(const base::string16& title) = 0;
77  virtual const base::string16& GetTitle() const = 0;
78
79  // Page state is an opaque blob created by Blink that represents the state of
80  // the page. This includes form entries and scroll position for each frame.
81  // We store it so that we can supply it back to Blink to restore form state
82  // properly when the user goes back and forward.
83  //
84  // NOTE: This state is saved to disk and used to restore previous states.  If
85  // the format is modified in the future, we should still be able to deal with
86  // older versions.
87  virtual void SetPageState(const PageState& state) = 0;
88  virtual const PageState& GetPageState() const = 0;
89
90  // Describes the current page that the tab represents. This is the ID that the
91  // renderer generated for the page and is how we can tell new versus
92  // renavigations.
93  virtual void SetPageID(int page_id) = 0;
94  virtual int32 GetPageID() const = 0;
95
96  // Page-related helpers ------------------------------------------------------
97
98  // Returns the title to be displayed on the tab. This could be the title of
99  // the page if it is available or the URL. |languages| is the list of
100  // accpeted languages (e.g., prefs::kAcceptLanguages) or empty if proper
101  // URL formatting isn't needed (e.g., unit tests).
102  virtual const base::string16& GetTitleForDisplay(
103      const std::string& languages) const = 0;
104
105  // Returns true if the current tab is in view source mode. This will be false
106  // if there is no navigation.
107  virtual bool IsViewSourceMode() const = 0;
108
109  // Tracking stuff ------------------------------------------------------------
110
111  // The transition type indicates what the user did to move to this page from
112  // the previous page.
113  virtual void SetTransitionType(content::PageTransition transition_type) = 0;
114  virtual content::PageTransition GetTransitionType() const = 0;
115
116  // The user typed URL was the URL that the user initiated the navigation
117  // with, regardless of any redirects. This is used to generate keywords, for
118  // example, based on "what the user thinks the site is called" rather than
119  // what it's actually called. For example, if the user types "foo.com", that
120  // may redirect somewhere arbitrary like "bar.com/foo", and we want to use
121  // the name that the user things of the site as having.
122  //
123  // This URL will be is_empty() if the URL was navigated to some other way.
124  // Callers should fall back on using the regular or display URL in this case.
125  virtual const GURL& GetUserTypedURL() const = 0;
126
127  // Post data is form data that was posted to get to this page. The data will
128  // have to be reposted to reload the page properly. This flag indicates
129  // whether the page had post data.
130  //
131  // The actual post data is stored either in
132  // 1) browser_initiated_post_data when a new post data request is started.
133  // 2) content_state when a post request has started and is extracted by
134  //    WebKit to actually make the request.
135  virtual void SetHasPostData(bool has_post_data) = 0;
136  virtual bool GetHasPostData() const = 0;
137
138  // The Post identifier associated with the page.
139  virtual void SetPostID(int64 post_id) = 0;
140  virtual int64 GetPostID() const = 0;
141
142  // Holds the raw post data of a browser initiated post request.
143  // For efficiency, this should be cleared when content_state is populated
144  // since the data is duplicated.
145  // Note, this field:
146  // 1) is not persisted in session restore.
147  // 2) is shallow copied with the static copy Create method above.
148  // 3) may be NULL so check before use.
149  virtual void SetBrowserInitiatedPostData(
150      const base::RefCountedMemory* data) = 0;
151  virtual const base::RefCountedMemory* GetBrowserInitiatedPostData() const = 0;
152
153  // The favicon data and tracking information. See content::FaviconStatus.
154  virtual const FaviconStatus& GetFavicon() const = 0;
155  virtual FaviconStatus& GetFavicon() = 0;
156
157  // All the SSL flags and state. See content::SSLStatus.
158  virtual const SSLStatus& GetSSL() const = 0;
159  virtual SSLStatus& GetSSL() = 0;
160
161  // Store the URL that caused this NavigationEntry to be created.
162  virtual void SetOriginalRequestURL(const GURL& original_url) = 0;
163  virtual const GURL& GetOriginalRequestURL() const = 0;
164
165  // Store whether or not we're overriding the user agent.
166  virtual void SetIsOverridingUserAgent(bool override) = 0;
167  virtual bool GetIsOverridingUserAgent() const = 0;
168
169  // The time at which the last known local navigation has
170  // completed. (A navigation can be completed more than once if the
171  // page is reloaded.)
172  //
173  // If GetTimestamp() returns a null time, that means that either:
174  //
175  //   - this navigation hasn't completed yet;
176  //   - this navigation was restored and for some reason the
177  //     timestamp wasn't available;
178  //   - or this navigation was copied from a foreign session.
179  virtual void SetTimestamp(base::Time timestamp) = 0;
180  virtual base::Time GetTimestamp() const = 0;
181
182  // Used to specify if this entry should be able to access local file://
183  // resources.
184  virtual void SetCanLoadLocalResources(bool allow) = 0;
185  virtual bool GetCanLoadLocalResources() const = 0;
186
187  // Used to specify which frame to navigate. If empty, the main frame is
188  // navigated. This is currently not persisted in session restore, because it
189  // is currently only used in tests.
190  virtual void SetFrameToNavigate(const std::string& frame_name) = 0;
191  virtual const std::string& GetFrameToNavigate() const = 0;
192
193  // Set extra data on this NavigationEntry according to the specified |key|.
194  // This data is not persisted by default.
195  virtual void SetExtraData(const std::string& key,
196                            const base::string16& data) = 0;
197  // If present, fills the |data| present at the specified |key|.
198  virtual bool GetExtraData(const std::string& key,
199                            base::string16* data) const = 0;
200  // Removes the data at the specified |key|.
201  virtual void ClearExtraData(const std::string& key) = 0;
202
203  // The status code of the last known successful navigation.  If
204  // GetHttpStatusCode() returns 0 that means that either:
205  //
206  //   - this navigation hasn't completed yet;
207  //   - a response wasn't received;
208  //   - or this navigation was restored and for some reason the
209  //     status code wasn't available.
210  virtual void SetHttpStatusCode(int http_status_code) = 0;
211  virtual int GetHttpStatusCode() const = 0;
212};
213
214}  // namespace content
215
216#endif  // CONTENT_PUBLIC_BROWSER_NAVIGATION_ENTRY_H_
217