Avi Drissman | 4e1b7bc3 | 2022-09-15 14:03:50 | [diff] [blame] | 1 | // Copyright 2013 The Chromium Authors |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 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_RENDERER_HOST_FRAME_TREE_NODE_H_ |
| 6 | #define CONTENT_BROWSER_RENDERER_HOST_FRAME_TREE_NODE_H_ |
| 7 | |
| 8 | #include <stddef.h> |
| 9 | |
| 10 | #include <memory> |
Arthur Sonzogni | c686e8f | 2024-01-11 08:36:37 | [diff] [blame] | 11 | #include <optional> |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 12 | #include <string> |
David Sanders | 2c1194d9 | 2022-04-19 23:32:32 | [diff] [blame] | 13 | #include <utility> |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 14 | |
| 15 | #include "base/gtest_prod_util.h" |
Keishi Hattori | 0e45c02 | 2021-11-27 09:25:52 | [diff] [blame] | 16 | #include "base/memory/raw_ptr.h" |
Christian Biesinger | e1865c57c | 2023-10-20 15:19:29 | [diff] [blame] | 17 | #include "base/memory/safe_ref.h" |
David Sanders | 2c1194d9 | 2022-04-19 23:32:32 | [diff] [blame] | 18 | #include "base/memory/scoped_refptr.h" |
David Sanders | d4bf5eb | 2022-03-17 07:12:05 | [diff] [blame] | 19 | #include "base/observer_list.h" |
Mingyu Lei | 7956b8b | 2023-07-24 08:24:08 | [diff] [blame] | 20 | #include "base/task/cancelable_task_tracker.h" |
Arthur Sonzogni | c686e8f | 2024-01-11 08:36:37 | [diff] [blame] | 21 | #include "base/time/time.h" |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 22 | #include "content/browser/renderer_host/navigator.h" |
| 23 | #include "content/browser/renderer_host/render_frame_host_impl.h" |
| 24 | #include "content/browser/renderer_host/render_frame_host_manager.h" |
Miyoung Shin | 7cf88b4 | 2022-11-07 13:22:30 | [diff] [blame] | 25 | #include "content/browser/renderer_host/render_frame_host_owner.h" |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 26 | #include "content/common/content_export.h" |
Julie Jeongeun Kim | f38c1eca | 2021-12-14 07:46:55 | [diff] [blame] | 27 | #include "content/public/browser/frame_type.h" |
Rakina Zata Amni | 58681c6 | 2024-06-25 06:32:13 | [diff] [blame^] | 28 | #include "content/public/browser/navigation_discard_reason.h" |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 29 | #include "services/network/public/mojom/content_security_policy.mojom-forward.h" |
Julie Jeongeun Kim | 0e24224 | 2022-11-30 10:45:09 | [diff] [blame] | 30 | #include "services/network/public/mojom/referrer_policy.mojom-forward.h" |
Kevin McNee | 43fe829 | 2021-10-04 22:59:41 | [diff] [blame] | 31 | #include "third_party/blink/public/common/frame/frame_owner_element_type.h" |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 32 | #include "third_party/blink/public/common/frame/frame_policy.h" |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 33 | #include "third_party/blink/public/mojom/frame/frame_owner_properties.mojom.h" |
Gyuyoung Kim | c16e52e9 | 2021-03-19 02:45:37 | [diff] [blame] | 34 | #include "third_party/blink/public/mojom/frame/frame_replication_state.mojom-forward.h" |
Daniel Cheng | 6ac12817 | 2021-05-25 18:49:01 | [diff] [blame] | 35 | #include "third_party/blink/public/mojom/frame/tree_scope_type.mojom.h" |
David Sanders | 2c1194d9 | 2022-04-19 23:32:32 | [diff] [blame] | 36 | #include "third_party/blink/public/mojom/frame/user_activation_update_types.mojom-forward.h" |
Miyoung Shin | af9a3436 | 2023-01-31 02:46:51 | [diff] [blame] | 37 | #include "third_party/blink/public/mojom/webauthn/virtual_authenticator.mojom-forward.h" |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 38 | #include "url/gurl.h" |
| 39 | #include "url/origin.h" |
| 40 | |
| 41 | namespace content { |
| 42 | |
| 43 | class NavigationRequest; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 44 | class NavigationEntryImpl; |
Paul Semel | 3e24104 | 2022-10-11 12:57:31 | [diff] [blame] | 45 | class FrameTree; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 46 | |
| 47 | // When a page contains iframes, its renderer process maintains a tree structure |
| 48 | // of those frames. We are mirroring this tree in the browser process. This |
| 49 | // class represents a node in this tree and is a wrapper for all objects that |
| 50 | // are frame-specific (as opposed to page-specific). |
| 51 | // |
| 52 | // Each FrameTreeNode has a current RenderFrameHost, which can change over |
| 53 | // time as the frame is navigated. Any immediate subframes of the current |
| 54 | // document are tracked using FrameTreeNodes owned by the current |
| 55 | // RenderFrameHost, rather than as children of FrameTreeNode itself. This |
| 56 | // allows subframe FrameTreeNodes to stay alive while a RenderFrameHost is |
| 57 | // still alive - for example while pending deletion, after a new current |
| 58 | // RenderFrameHost has replaced it. |
Miyoung Shin | 7cf88b4 | 2022-11-07 13:22:30 | [diff] [blame] | 59 | class CONTENT_EXPORT FrameTreeNode : public RenderFrameHostOwner { |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 60 | public: |
| 61 | class Observer { |
| 62 | public: |
| 63 | // Invoked when a FrameTreeNode is being destroyed. |
| 64 | virtual void OnFrameTreeNodeDestroyed(FrameTreeNode* node) {} |
| 65 | |
| 66 | // Invoked when a FrameTreeNode becomes focused. |
| 67 | virtual void OnFrameTreeNodeFocused(FrameTreeNode* node) {} |
| 68 | |
Arthur Hemery | e465928 | 2022-03-28 08:36:15 | [diff] [blame] | 69 | // Invoked when a FrameTreeNode moves to a different BrowsingInstance and |
| 70 | // the popups it opened should be disowned. |
| 71 | virtual void OnFrameTreeNodeDisownedOpenee(FrameTreeNode* node) {} |
| 72 | |
Fergal Daly | a1d56997 | 2021-03-16 03:24:53 | [diff] [blame] | 73 | virtual ~Observer() = default; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 74 | }; |
| 75 | |
| 76 | static const int kFrameTreeNodeInvalidId; |
| 77 | |
| 78 | // Returns the FrameTreeNode with the given global |frame_tree_node_id|, |
| 79 | // regardless of which FrameTree it is in. |
| 80 | static FrameTreeNode* GloballyFindByID(int frame_tree_node_id); |
| 81 | |
| 82 | // Returns the FrameTreeNode for the given |rfh|. Same as |
| 83 | // rfh->frame_tree_node(), but also supports nullptrs. |
| 84 | static FrameTreeNode* From(RenderFrameHost* rfh); |
| 85 | |
| 86 | // Callers are are expected to initialize sandbox flags separately after |
| 87 | // calling the constructor. |
| 88 | FrameTreeNode( |
Arthur Sonzogni | f6785ec | 2022-12-05 10:11:50 | [diff] [blame] | 89 | FrameTree& frame_tree, |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 90 | RenderFrameHostImpl* parent, |
Daniel Cheng | 6ac12817 | 2021-05-25 18:49:01 | [diff] [blame] | 91 | blink::mojom::TreeScopeType tree_scope_type, |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 92 | bool is_created_by_script, |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 93 | const blink::mojom::FrameOwnerProperties& frame_owner_properties, |
Kevin McNee | 43fe829 | 2021-10-04 22:59:41 | [diff] [blame] | 94 | blink::FrameOwnerElementType owner_type, |
Dominic Farolino | 08662c8 | 2021-06-11 07:36:34 | [diff] [blame] | 95 | const blink::FramePolicy& frame_owner); |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 96 | |
Peter Boström | 828b902 | 2021-09-21 02:28:43 | [diff] [blame] | 97 | FrameTreeNode(const FrameTreeNode&) = delete; |
| 98 | FrameTreeNode& operator=(const FrameTreeNode&) = delete; |
| 99 | |
Miyoung Shin | 7cf88b4 | 2022-11-07 13:22:30 | [diff] [blame] | 100 | ~FrameTreeNode() override; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 101 | |
| 102 | void AddObserver(Observer* observer); |
| 103 | void RemoveObserver(Observer* observer); |
| 104 | |
Ian Vollick | 25a9d03 | 2022-04-12 23:20:17 | [diff] [blame] | 105 | // Frame trees may be nested so it can be the case that IsMainFrame() is true, |
| 106 | // but is not the outermost main frame. In particular, !IsMainFrame() cannot |
| 107 | // be used to check if the frame is an embedded frame -- use |
| 108 | // !IsOutermostMainFrame() instead. NB: this does not escape guest views; |
| 109 | // IsOutermostMainFrame will be true for the outermost main frame in an inner |
| 110 | // guest view. |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 111 | bool IsMainFrame() const; |
Arthur Hemery | a06697f | 2023-03-14 09:20:57 | [diff] [blame] | 112 | bool IsOutermostMainFrame() const; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 113 | |
Arthur Sonzogni | f6785ec | 2022-12-05 10:11:50 | [diff] [blame] | 114 | FrameTree& frame_tree() const { return frame_tree_.get(); } |
Paul Semel | 3e24104 | 2022-10-11 12:57:31 | [diff] [blame] | 115 | Navigator& navigator(); |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 116 | |
| 117 | RenderFrameHostManager* render_manager() { return &render_manager_; } |
Alexander Timin | 33e2e2c1 | 2022-03-03 04:21:33 | [diff] [blame] | 118 | const RenderFrameHostManager* render_manager() const { |
| 119 | return &render_manager_; |
| 120 | } |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 121 | int frame_tree_node_id() const { return frame_tree_node_id_; } |
Yuzu Saijo | 03dbf9b | 2022-07-22 04:29:45 | [diff] [blame] | 122 | // This reflects window.name, which is initially set to the the "name" |
| 123 | // attribute. But this won't reflect changes of 'name' attribute and instead |
| 124 | // reflect changes to the Window object's name property. |
| 125 | // This is different from IframeAttributes' name in that this will not get |
| 126 | // updated when 'name' attribute gets updated. |
Harkiran Bolaria | 4eacb3a | 2021-12-13 20:03:47 | [diff] [blame] | 127 | const std::string& frame_name() const { |
| 128 | return render_manager_.current_replication_state().name; |
| 129 | } |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 130 | |
| 131 | const std::string& unique_name() const { |
Harkiran Bolaria | 4eacb3a | 2021-12-13 20:03:47 | [diff] [blame] | 132 | return render_manager_.current_replication_state().unique_name; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 133 | } |
| 134 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 135 | size_t child_count() const { return current_frame_host()->child_count(); } |
| 136 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 137 | RenderFrameHostImpl* parent() const { return parent_; } |
| 138 | |
Dave Tapuska | c8de3b0 | 2021-12-03 21:51:01 | [diff] [blame] | 139 | // See `RenderFrameHost::GetParentOrOuterDocument()` for |
| 140 | // documentation. |
Arthur Hemery | a06697f | 2023-03-14 09:20:57 | [diff] [blame] | 141 | RenderFrameHostImpl* GetParentOrOuterDocument() const; |
Dave Tapuska | c8de3b0 | 2021-12-03 21:51:01 | [diff] [blame] | 142 | |
| 143 | // See `RenderFrameHostImpl::GetParentOrOuterDocumentOrEmbedder()` for |
| 144 | // documentation. |
| 145 | RenderFrameHostImpl* GetParentOrOuterDocumentOrEmbedder(); |
| 146 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 147 | FrameTreeNode* opener() const { return opener_; } |
| 148 | |
Rakina Zata Amni | 3a48ae4 | 2022-05-05 03:39:56 | [diff] [blame] | 149 | FrameTreeNode* first_live_main_frame_in_original_opener_chain() const { |
| 150 | return first_live_main_frame_in_original_opener_chain_; |
| 151 | } |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 152 | |
Arthur Sonzogni | c686e8f | 2024-01-11 08:36:37 | [diff] [blame] | 153 | const std::optional<base::UnguessableToken>& opener_devtools_frame_token() { |
Wolfgang Beyer | d8809db | 2020-09-30 15:29:39 | [diff] [blame] | 154 | return opener_devtools_frame_token_; |
| 155 | } |
| 156 | |
Julie Jeongeun Kim | f38c1eca | 2021-12-14 07:46:55 | [diff] [blame] | 157 | // Returns the type of the frame. Refer to frame_type.h for the details. |
| 158 | FrameType GetFrameType() const; |
| 159 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 160 | // Assigns a new opener for this node and, if |opener| is non-null, registers |
| 161 | // an observer that will clear this node's opener if |opener| is ever |
| 162 | // destroyed. |
| 163 | void SetOpener(FrameTreeNode* opener); |
| 164 | |
| 165 | // Assigns the initial opener for this node, and if |opener| is non-null, |
| 166 | // registers an observer that will clear this node's opener if |opener| is |
| 167 | // ever destroyed. The value set here is the root of the tree. |
| 168 | // |
| 169 | // It is not possible to change the opener once it was set. |
| 170 | void SetOriginalOpener(FrameTreeNode* opener); |
| 171 | |
Wolfgang Beyer | d8809db | 2020-09-30 15:29:39 | [diff] [blame] | 172 | // Assigns an opener frame id for this node. This string id is only set once |
| 173 | // and cannot be changed. It persists, even if the |opener| is destroyed. It |
| 174 | // is used for attribution in the DevTools frontend. |
| 175 | void SetOpenerDevtoolsFrameToken( |
| 176 | base::UnguessableToken opener_devtools_frame_token); |
| 177 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 178 | FrameTreeNode* child_at(size_t index) const { |
| 179 | return current_frame_host()->child_at(index); |
| 180 | } |
| 181 | |
| 182 | // Returns the URL of the last committed page in the current frame. |
| 183 | const GURL& current_url() const { |
| 184 | return current_frame_host()->GetLastCommittedURL(); |
| 185 | } |
| 186 | |
Charlie Reis | 734db66 | 2024-01-11 18:20:03 | [diff] [blame] | 187 | // Moves this frame out of the initial empty document state, which is a |
| 188 | // one-way change for FrameTreeNode (i.e., it cannot go back into the initial |
| 189 | // empty document state). |
| 190 | void set_not_on_initial_empty_document() { |
| 191 | is_on_initial_empty_document_ = false; |
| 192 | } |
| 193 | |
| 194 | // Returns false if the frame has committed a document that is not the initial |
| 195 | // empty document, or if the current document's input stream has been opened |
| 196 | // with document.open(), causing the document to lose its "initial empty |
| 197 | // document" status. For more details, see the definition of |
| 198 | // `is_on_initial_empty_document_`. |
Rakina Zata Amni | 86c88fa | 2021-11-01 01:27:30 | [diff] [blame] | 199 | bool is_on_initial_empty_document() const { |
Charlie Reis | 734db66 | 2024-01-11 18:20:03 | [diff] [blame] | 200 | return is_on_initial_empty_document_; |
Rakina Zata Amni | fc4cc3d4 | 2021-06-10 09:03:56 | [diff] [blame] | 201 | } |
| 202 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 203 | // Returns whether the frame's owner element in the parent document is |
| 204 | // collapsed, that is, removed from the layout as if it did not exist, as per |
| 205 | // request by the embedder (of the content/ layer). |
| 206 | bool is_collapsed() const { return is_collapsed_; } |
| 207 | |
| 208 | // Sets whether to collapse the frame's owner element in the parent document, |
| 209 | // that is, to remove it from the layout as if it did not exist, as per |
| 210 | // request by the embedder (of the content/ layer). Cannot be called for main |
| 211 | // frames. |
| 212 | // |
| 213 | // This only has an effect for <iframe> owner elements, and is a no-op when |
| 214 | // called on sub-frames hosted in <frame>, <object>, and <embed> elements. |
| 215 | void SetCollapsed(bool collapsed); |
| 216 | |
| 217 | // Returns the origin of the last committed page in this frame. |
| 218 | // WARNING: To get the last committed origin for a particular |
| 219 | // RenderFrameHost, use RenderFrameHost::GetLastCommittedOrigin() instead, |
| 220 | // which will behave correctly even when the RenderFrameHost is not the |
| 221 | // current one for this frame (such as when it's pending deletion). |
| 222 | const url::Origin& current_origin() const { |
Harkiran Bolaria | 4eacb3a | 2021-12-13 20:03:47 | [diff] [blame] | 223 | return render_manager_.current_replication_state().origin; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 224 | } |
| 225 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 226 | // Returns the latest frame policy (sandbox flags and container policy) for |
| 227 | // this frame. This includes flags inherited from parent frames and the latest |
| 228 | // flags from the <iframe> element hosting this frame. The returned policies |
| 229 | // may not yet have taken effect, since "sandbox" and "allow" attribute |
Liam Brady | 25a1416 | 2022-12-02 15:25:57 | [diff] [blame] | 230 | // updates in an <iframe> element take effect on next navigation. For |
| 231 | // <fencedframe> elements, not everything in the frame policy might actually |
| 232 | // take effect after the navigation. To retrieve the currently active policy |
| 233 | // for this frame, use effective_frame_policy(). |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 234 | const blink::FramePolicy& pending_frame_policy() const { |
| 235 | return pending_frame_policy_; |
| 236 | } |
| 237 | |
| 238 | // Update this frame's sandbox flags and container policy. This is called |
| 239 | // when a parent frame updates the "sandbox" attribute in the <iframe> element |
| 240 | // for this frame, or any of the attributes which affect the container policy |
| 241 | // ("allowfullscreen", "allowpaymentrequest", "allow", and "src".) |
| 242 | // These policies won't take effect until next navigation. If this frame's |
| 243 | // parent is itself sandboxed, the parent's sandbox flags are combined with |
| 244 | // those in |frame_policy|. |
| 245 | // Attempting to change the container policy on the main frame will have no |
| 246 | // effect. |
| 247 | void SetPendingFramePolicy(blink::FramePolicy frame_policy); |
| 248 | |
| 249 | // Returns the currently active frame policy for this frame, including the |
| 250 | // sandbox flags which were present at the time the document was loaded, and |
Charlie Hu | 5130d25e | 2021-03-05 21:53:39 | [diff] [blame] | 251 | // the permissions policy container policy, which is set by the iframe's |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 252 | // allowfullscreen, allowpaymentrequest, and allow attributes, along with the |
| 253 | // origin of the iframe's src attribute (which may be different from the URL |
| 254 | // of the document currently loaded into the frame). This does not include |
| 255 | // policy changes that have been made by updating the containing iframe |
| 256 | // element attributes since the frame was last navigated; use |
| 257 | // pending_frame_policy() for those. |
| 258 | const blink::FramePolicy& effective_frame_policy() const { |
Harkiran Bolaria | 4eacb3a | 2021-12-13 20:03:47 | [diff] [blame] | 259 | return render_manager_.current_replication_state().frame_policy; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 260 | } |
| 261 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 262 | const blink::mojom::FrameOwnerProperties& frame_owner_properties() { |
| 263 | return frame_owner_properties_; |
| 264 | } |
| 265 | |
| 266 | void set_frame_owner_properties( |
| 267 | const blink::mojom::FrameOwnerProperties& frame_owner_properties) { |
| 268 | frame_owner_properties_ = frame_owner_properties; |
| 269 | } |
| 270 | |
Yuzu Saijo | 03dbf9b | 2022-07-22 04:29:45 | [diff] [blame] | 271 | // Reflects the attributes of the corresponding iframe html element, such |
Arthur Sonzogni | 6445759 | 2022-11-22 11:08:59 | [diff] [blame] | 272 | // as 'credentialless', 'id', 'name' and 'src'. These values should not be |
Yuzu Saijo | 03dbf9b | 2022-07-22 04:29:45 | [diff] [blame] | 273 | // exposed to cross-origin renderers. |
| 274 | const network::mojom::ContentSecurityPolicy* csp_attribute() const { |
| 275 | return attributes_->parsed_csp_attribute.get(); |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 276 | } |
Yao Xiao | 9c54b3e | 2023-03-14 04:25:04 | [diff] [blame] | 277 | // Tracks iframe's 'browsingtopics' attribute, indicating whether the |
| 278 | // navigation requests on this frame should calculate and send the |
| 279 | // `Sec-Browsing-Topics` header. |
| 280 | bool browsing_topics() const { return attributes_->browsing_topics; } |
Camillia Smith Barnes | 6d2966c8 | 2023-08-23 21:16:18 | [diff] [blame] | 281 | |
Orr Bernstein | a0cc679 | 2023-11-14 22:12:35 | [diff] [blame] | 282 | // Tracks iframe's 'adauctionheaders' attribute, indicating whether the |
| 283 | // navigation request on this frame should calculate and send the |
| 284 | // 'Sec-Ad-Auction-Fetch` header. |
| 285 | bool ad_auction_headers() const { return attributes_->ad_auction_headers; } |
| 286 | |
Camillia Smith Barnes | 6d2966c8 | 2023-08-23 21:16:18 | [diff] [blame] | 287 | // Tracks iframe's 'sharedstoragewritable' attribute, indicating what value |
Camillia Smith Barnes | c267be6 | 2023-11-01 20:01:02 | [diff] [blame] | 288 | // the the corresponding |
| 289 | // `network::ResourceRequest::shared_storage_writable_eligible` should take |
| 290 | // for the navigation(s) on this frame, pending a permissions policy check. If |
| 291 | // true, and if the permissions policy check returns "enabled", the network |
Camillia Smith Barnes | 6d2966c8 | 2023-08-23 21:16:18 | [diff] [blame] | 292 | // service will send the `Shared-Storage-Write` request header. |
Camillia Smith Barnes | c267be6 | 2023-11-01 20:01:02 | [diff] [blame] | 293 | bool shared_storage_writable_opted_in() const { |
| 294 | return attributes_->shared_storage_writable_opted_in; |
Camillia Smith Barnes | 6d2966c8 | 2023-08-23 21:16:18 | [diff] [blame] | 295 | } |
Arthur Sonzogni | c686e8f | 2024-01-11 08:36:37 | [diff] [blame] | 296 | const std::optional<std::string> html_id() const { return attributes_->id; } |
Yuzu Saijo | 03dbf9b | 2022-07-22 04:29:45 | [diff] [blame] | 297 | // This tracks iframe's 'name' attribute instead of window.name, which is |
| 298 | // tracked in FrameReplicationState. See the comment for frame_name() for |
| 299 | // more details. |
Arthur Sonzogni | c686e8f | 2024-01-11 08:36:37 | [diff] [blame] | 300 | const std::optional<std::string> html_name() const { |
Yuzu Saijo | dc870f9 | 2023-01-20 03:39:11 | [diff] [blame] | 301 | return attributes_->name; |
| 302 | } |
Arthur Sonzogni | c686e8f | 2024-01-11 08:36:37 | [diff] [blame] | 303 | const std::optional<std::string> html_src() const { return attributes_->src; } |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 304 | |
Yuzu Saijo | 03dbf9b | 2022-07-22 04:29:45 | [diff] [blame] | 305 | void SetAttributes(blink::mojom::IframeAttributesPtr attributes); |
Antonio Sartori | 5abc8de | 2021-07-13 08:42:47 | [diff] [blame] | 306 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 307 | bool HasSameOrigin(const FrameTreeNode& node) const { |
Harkiran Bolaria | 4eacb3a | 2021-12-13 20:03:47 | [diff] [blame] | 308 | return render_manager_.current_replication_state().origin.IsSameOriginWith( |
| 309 | node.current_replication_state().origin); |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 310 | } |
| 311 | |
Gyuyoung Kim | c16e52e9 | 2021-03-19 02:45:37 | [diff] [blame] | 312 | const blink::mojom::FrameReplicationState& current_replication_state() const { |
Harkiran Bolaria | 4eacb3a | 2021-12-13 20:03:47 | [diff] [blame] | 313 | return render_manager_.current_replication_state(); |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 314 | } |
| 315 | |
| 316 | RenderFrameHostImpl* current_frame_host() const { |
| 317 | return render_manager_.current_frame_host(); |
| 318 | } |
| 319 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 320 | // Returns true if this node is in a loading state. |
| 321 | bool IsLoading() const; |
Nate Chapin | 470dbc6 | 2023-04-25 16:34:38 | [diff] [blame] | 322 | LoadingState GetLoadingState() const; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 323 | |
Alex Moshchuk | 9b0fd82 | 2020-10-26 23:08:15 | [diff] [blame] | 324 | // Returns true if this node has a cross-document navigation in progress. |
| 325 | bool HasPendingCrossDocumentNavigation() const; |
| 326 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 327 | NavigationRequest* navigation_request() { return navigation_request_.get(); } |
| 328 | |
| 329 | // Transfers the ownership of the NavigationRequest to |render_frame_host|. |
| 330 | // From ReadyToCommit to DidCommit, the NavigationRequest is owned by the |
| 331 | // RenderFrameHost that is committing the navigation. |
| 332 | void TransferNavigationRequestOwnership( |
| 333 | RenderFrameHostImpl* render_frame_host); |
| 334 | |
| 335 | // Takes ownership of |navigation_request| and makes it the current |
| 336 | // NavigationRequest of this frame. This corresponds to the start of a new |
| 337 | // navigation. If there was an ongoing navigation request before calling this |
| 338 | // function, it is canceled. |navigation_request| should not be null. |
Charlie Reis | 09952ee | 2022-12-08 16:35:07 | [diff] [blame] | 339 | void TakeNavigationRequest( |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 340 | std::unique_ptr<NavigationRequest> navigation_request); |
| 341 | |
Rakina Zata Amni | f8f2bb6 | 2022-11-23 05:54:32 | [diff] [blame] | 342 | // Resets the navigation request owned by `this` (which shouldn't have reached |
| 343 | // the "pending commit" stage yet) and any state created by it, including the |
Rakina Zata Amni | 33175cb9 | 2022-11-24 02:46:03 | [diff] [blame] | 344 | // speculative RenderFrameHost (if there are no other navigations associated |
| 345 | // with it). Note that this does not affect navigations that have reached the |
| 346 | // "pending commit" stage, which are owned by their corresponding |
| 347 | // RenderFrameHosts instead. |
Daniel Cheng | 390e2a7 | 2022-09-28 06:07:53 | [diff] [blame] | 348 | void ResetNavigationRequest(NavigationDiscardReason reason); |
| 349 | |
Rakina Zata Amni | f8f2bb6 | 2022-11-23 05:54:32 | [diff] [blame] | 350 | // Similar to `ResetNavigationRequest()`, but keeps the state created by the |
Daniel Cheng | 390e2a7 | 2022-09-28 06:07:53 | [diff] [blame] | 351 | // NavigationRequest (e.g. speculative RenderFrameHost, loading state). |
Rakina Zata Amni | 58681c6 | 2024-06-25 06:32:13 | [diff] [blame^] | 352 | void ResetNavigationRequestButKeepState(NavigationDiscardReason reason); |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 353 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 354 | // The load progress for a RenderFrameHost in this node was updated to |
| 355 | // |load_progress|. This will notify the FrameTree which will in turn notify |
| 356 | // the WebContents. |
| 357 | void DidChangeLoadProgress(double load_progress); |
| 358 | |
| 359 | // Called when the user directed the page to stop loading. Stops all loads |
| 360 | // happening in the FrameTreeNode. This method should be used with |
| 361 | // FrameTree::ForEach to stop all loads in the entire FrameTree. |
| 362 | bool StopLoading(); |
| 363 | |
| 364 | // Returns the time this frame was last focused. |
| 365 | base::TimeTicks last_focus_time() const { return last_focus_time_; } |
| 366 | |
| 367 | // Called when this node becomes focused. Updates the node's last focused |
| 368 | // time and notifies observers. |
| 369 | void DidFocus(); |
| 370 | |
| 371 | // Called when the user closed the modal dialogue for BeforeUnload and |
| 372 | // cancelled the navigation. This should stop any load happening in the |
| 373 | // FrameTreeNode. |
| 374 | void BeforeUnloadCanceled(); |
| 375 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 376 | // Returns the sandbox flags currently in effect for this frame. This includes |
| 377 | // flags inherited from parent frames, the currently active flags from the |
| 378 | // <iframe> element hosting this frame, as well as any flags set from a |
| 379 | // Content-Security-Policy HTTP header. This does not include flags that have |
| 380 | // have been updated in an <iframe> element but have not taken effect yet; use |
| 381 | // pending_frame_policy() for those. To see the flags which will take effect |
| 382 | // on navigation (which does not include the CSP-set flags), use |
| 383 | // effective_frame_policy(). |
| 384 | network::mojom::WebSandboxFlags active_sandbox_flags() const { |
Harkiran Bolaria | 4eacb3a | 2021-12-13 20:03:47 | [diff] [blame] | 385 | return render_manager_.current_replication_state().active_sandbox_flags; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 386 | } |
| 387 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 388 | // Returns whether the frame received a user gesture on a previous navigation |
| 389 | // on the same eTLD+1. |
| 390 | bool has_received_user_gesture_before_nav() const { |
Harkiran Bolaria | 4eacb3a | 2021-12-13 20:03:47 | [diff] [blame] | 391 | return render_manager_.current_replication_state() |
| 392 | .has_received_user_gesture_before_nav; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 393 | } |
| 394 | |
| 395 | // When a tab is discarded, WebContents sets was_discarded on its |
| 396 | // root FrameTreeNode. |
| 397 | // In addition, when a child frame is created, this bit is passed on from |
| 398 | // parent to child. |
| 399 | // When a navigation request is created, was_discarded is passed on to the |
| 400 | // request and reset to false in FrameTreeNode. |
| 401 | void set_was_discarded() { was_discarded_ = true; } |
| 402 | bool was_discarded() const { return was_discarded_; } |
| 403 | |
Miyoung Shin | 8a66ec02 | 2022-11-28 23:50:09 | [diff] [blame] | 404 | // Deprecated. Use directly HasStickyUserActivation in RFHI. |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 405 | // Returns the sticky bit of the User Activation v2 state of the |
| 406 | // |FrameTreeNode|. |
| 407 | bool HasStickyUserActivation() const { |
Miyoung Shin | 8a66ec02 | 2022-11-28 23:50:09 | [diff] [blame] | 408 | return current_frame_host()->HasStickyUserActivation(); |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 409 | } |
| 410 | |
Miyoung Shin | 8a66ec02 | 2022-11-28 23:50:09 | [diff] [blame] | 411 | // Deprecated. Use directly HasStickyUserActivation in RFHI. |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 412 | // Returns the transient bit of the User Activation v2 state of the |
| 413 | // |FrameTreeNode|. |
| 414 | bool HasTransientUserActivation() { |
Miyoung Shin | 8a66ec02 | 2022-11-28 23:50:09 | [diff] [blame] | 415 | return current_frame_host()->HasTransientUserActivation(); |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 416 | } |
| 417 | |
| 418 | // Remove history entries for all frames created by script in this frame's |
| 419 | // subtree. If a frame created by a script is removed, then its history entry |
| 420 | // will never be reused - this saves memory. |
| 421 | void PruneChildFrameNavigationEntries(NavigationEntryImpl* entry); |
| 422 | |
Abhijeet Kandalkar | b43affa7 | 2022-09-27 16:48:01 | [diff] [blame] | 423 | using FencedFrameStatus = RenderFrameHostImpl::FencedFrameStatus; |
Abhijeet Kandalkar | 3f29bc4 | 2022-09-23 12:39:58 | [diff] [blame] | 424 | FencedFrameStatus fenced_frame_status() const { return fenced_frame_status_; } |
| 425 | |
Kevin McNee | 43fe829 | 2021-10-04 22:59:41 | [diff] [blame] | 426 | blink::FrameOwnerElementType frame_owner_element_type() const { |
Daniel Cheng | 9bd90f9 | 2021-04-23 20:49:45 | [diff] [blame] | 427 | return frame_owner_element_type_; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 428 | } |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 429 | |
Daniel Cheng | 6ac12817 | 2021-05-25 18:49:01 | [diff] [blame] | 430 | blink::mojom::TreeScopeType tree_scope_type() const { |
| 431 | return tree_scope_type_; |
| 432 | } |
| 433 | |
arthursonzogni | 034bb9c | 2020-10-01 08:29:56 | [diff] [blame] | 434 | // The initial popup URL for new window opened using: |
| 435 | // `window.open(initial_popup_url)`. |
| 436 | // An empty GURL otherwise. |
| 437 | // |
| 438 | // [WARNING] There is no guarantee the FrameTreeNode will ever host a |
| 439 | // document served from this URL. The FrameTreeNode always starts hosting the |
| 440 | // initial empty document and attempts a navigation toward this URL. However |
| 441 | // the navigation might be delayed, redirected and even cancelled. |
| 442 | void SetInitialPopupURL(const GURL& initial_popup_url); |
| 443 | const GURL& initial_popup_url() const { return initial_popup_url_; } |
| 444 | |
| 445 | // The origin of the document that used window.open() to create this frame. |
| 446 | // Otherwise, an opaque Origin with a nonce different from all previously |
| 447 | // existing Origins. |
| 448 | void SetPopupCreatorOrigin(const url::Origin& popup_creator_origin); |
| 449 | const url::Origin& popup_creator_origin() const { |
| 450 | return popup_creator_origin_; |
| 451 | } |
| 452 | |
Harkiran Bolaria | 59290d6 | 2021-03-17 01:53:01 | [diff] [blame] | 453 | // Sets the associated FrameTree for this node. The node can change FrameTrees |
Domenic Denicola | 7767a9c | 2023-07-13 15:36:39 | [diff] [blame] | 454 | // as part of prerendering, which allows a page loaded in the prerendered |
| 455 | // FrameTree to be used for a navigation in the primary frame tree. |
Harkiran Bolaria | 59290d6 | 2021-03-17 01:53:01 | [diff] [blame] | 456 | void SetFrameTree(FrameTree& frame_tree); |
| 457 | |
Alexander Timin | 074cd18 | 2022-03-23 18:11:22 | [diff] [blame] | 458 | using TraceProto = perfetto::protos::pbzero::FrameTreeNodeInfo; |
Alexander Timin | f785f34 | 2021-03-18 00:00:56 | [diff] [blame] | 459 | // Write a representation of this object into a trace. |
Alexander Timin | 074cd18 | 2022-03-23 18:11:22 | [diff] [blame] | 460 | void WriteIntoTrace(perfetto::TracedProto<TraceProto> proto) const; |
Alexander Timin | f785f34 | 2021-03-18 00:00:56 | [diff] [blame] | 461 | |
Carlos Caballero | 7671135 | 2021-03-24 17:38:21 | [diff] [blame] | 462 | // Returns true the node is navigating, i.e. it has an associated |
| 463 | // NavigationRequest. |
| 464 | bool HasNavigation(); |
| 465 | |
murakinonoka | 97a8f04 | 2024-01-10 09:17:07 | [diff] [blame] | 466 | // Returns true if there are any navigations happening in FrameTreeNode that |
| 467 | // is pending commit (i.e. between ReadyToCommit and DidCommit). Note that |
| 468 | // those navigations won't live in the FrameTreeNode itself, as they will |
| 469 | // already be owned by the committing RenderFrameHost (either the current |
| 470 | // RenderFrameHost or the speculative RenderFrameHost). |
| 471 | bool HasPendingCommitNavigation(); |
| 472 | |
shivanigithub | f3ddff5 | 2021-07-03 22:06:30 | [diff] [blame] | 473 | // Fenced frames (meta-bug crbug.com/1111084): |
shivanigithub | 4cd016a | 2021-09-20 21:10:30 | [diff] [blame] | 474 | // Note that these two functions cannot be invoked from a FrameTree's or |
| 475 | // its root node's constructor since they require the frame tree and the |
| 476 | // root node to be completely constructed. |
| 477 | // |
shivanigithub | f3ddff5 | 2021-07-03 22:06:30 | [diff] [blame] | 478 | // Returns false if fenced frames are disabled. Returns true if the feature is |
| 479 | // enabled and if |this| is a fenced frame. Returns false for |
| 480 | // iframes embedded in a fenced frame. To clarify: for the MPArch |
| 481 | // implementation this only returns true if |this| is the actual |
| 482 | // root node of the inner FrameTree and not the proxy FrameTreeNode in the |
| 483 | // outer FrameTree. |
Dominic Farolino | 4bc10ee | 2021-08-31 00:37:36 | [diff] [blame] | 484 | bool IsFencedFrameRoot() const; |
shivanigithub | f3ddff5 | 2021-07-03 22:06:30 | [diff] [blame] | 485 | |
| 486 | // Returns false if fenced frames are disabled. Returns true if the |
| 487 | // feature is enabled and if |this| or any of its ancestor nodes is a |
| 488 | // fenced frame. |
| 489 | bool IsInFencedFrameTree() const; |
| 490 | |
shivanigithub | 4cd016a | 2021-09-20 21:10:30 | [diff] [blame] | 491 | // Returns a valid nonce if `IsInFencedFrameTree()` returns true for `this`. |
Garrett Tanzer | 34cb92fe | 2022-09-28 17:50:54 | [diff] [blame] | 492 | // Returns nullopt otherwise. |
| 493 | // |
| 494 | // Nonce used in the net::IsolationInfo and blink::StorageKey for a fenced |
| 495 | // frame and any iframes nested within it. Not set if this frame is not in a |
| 496 | // fenced frame's FrameTree. Note that this could be a field in FrameTree for |
| 497 | // the MPArch version but for the shadow DOM version we need to keep it here |
| 498 | // since the fenced frame root is not a main frame for the latter. The value |
| 499 | // of the nonce will be the same for all of the the iframes inside a fenced |
| 500 | // frame tree. If there is a nested fenced frame it will have a different |
| 501 | // nonce than its parent fenced frame. The nonce will stay the same across |
| 502 | // navigations initiated from the fenced frame tree because it is always used |
| 503 | // in conjunction with other fields of the keys and would be good to access |
| 504 | // the same storage across same-origin navigations. If the navigation is |
| 505 | // same-origin/site then the same network stack partition/storage will be |
| 506 | // reused and if it's cross-origin/site then other parts of the key will |
| 507 | // change and so, even with the same nonce, another partition will be used. |
| 508 | // But if the navigation is initiated from the embedder, the nonce will be |
| 509 | // reinitialized irrespective of same or cross origin such that there is no |
| 510 | // privacy leak via storage shared between two embedder initiated navigations. |
| 511 | // Note that this reinitialization is implemented for all embedder-initiated |
| 512 | // navigations in MPArch, but only urn:uuid navigations in ShadowDOM. |
Arthur Sonzogni | c686e8f | 2024-01-11 08:36:37 | [diff] [blame] | 513 | std::optional<base::UnguessableToken> GetFencedFrameNonce(); |
shivanigithub | 4cd016a | 2021-09-20 21:10:30 | [diff] [blame] | 514 | |
Garrett Tanzer | 34cb92fe | 2022-09-28 17:50:54 | [diff] [blame] | 515 | // If applicable, initialize the default fenced frame properties. Right now, |
| 516 | // this means setting a new fenced frame nonce. See comment on |
shivanigithub | 4cd016a | 2021-09-20 21:10:30 | [diff] [blame] | 517 | // fenced_frame_nonce() for when it is set to a non-null value. Invoked |
| 518 | // by FrameTree::Init() or FrameTree::AddFrame(). |
Garrett Tanzer | 34cb92fe | 2022-09-28 17:50:54 | [diff] [blame] | 519 | void SetFencedFramePropertiesIfNeeded(); |
shivanigithub | 4cd016a | 2021-09-20 21:10:30 | [diff] [blame] | 520 | |
Garrett Tanzer | 291a2d5 | 2023-03-20 22:41:57 | [diff] [blame] | 521 | // Set the current FencedFrameProperties to have "opaque ads mode". |
| 522 | // This should only be used during tests, when the proper embedder-initiated |
| 523 | // fenced frame root urn/config navigation flow isn't available. |
Alison Gale | 770f3fc | 2024-04-27 00:39:58 | [diff] [blame] | 524 | // TODO(crbug.com/40233168): Refactor and expand use of test utils so there is |
Garrett Tanzer | 291a2d5 | 2023-03-20 22:41:57 | [diff] [blame] | 525 | // a consistent way to do this properly everywhere. Consider removing |
| 526 | // arbitrary restrictions in "default mode" so that using opaque ads mode is |
| 527 | // less necessary. |
| 528 | void SetFencedFramePropertiesOpaqueAdsModeForTesting() { |
| 529 | if (fenced_frame_properties_.has_value()) { |
Garrett Tanzer | 0698070 | 2023-12-12 19:48:20 | [diff] [blame] | 530 | fenced_frame_properties_ |
| 531 | ->SetFencedFramePropertiesOpaqueAdsModeForTesting(); |
Garrett Tanzer | 291a2d5 | 2023-03-20 22:41:57 | [diff] [blame] | 532 | } |
| 533 | } |
| 534 | |
| 535 | // Returns the mode attribute from the `FencedFrameProperties` if this frame |
| 536 | // is in a fenced frame tree, otherwise returns `kDefault`. |
| 537 | blink::FencedFrame::DeprecatedFencedFrameMode GetDeprecatedFencedFrameMode(); |
Nan Lin | 171fe9a | 2022-02-17 16:42:16 | [diff] [blame] | 538 | |
Dave Tapuska | c8de3b0 | 2021-12-03 21:51:01 | [diff] [blame] | 539 | // Helper for GetParentOrOuterDocument/GetParentOrOuterDocumentOrEmbedder. |
| 540 | // Do not use directly. |
Kevin McNee | 86e64ee | 2023-02-17 16:35:50 | [diff] [blame] | 541 | // `escape_guest_view` determines whether to iterate out of guest views and is |
| 542 | // the behaviour distinction between GetParentOrOuterDocument and |
| 543 | // GetParentOrOuterDocumentOrEmbedder. See the comment on |
| 544 | // GetParentOrOuterDocumentOrEmbedder for details. |
| 545 | // `include_prospective` includes embedders which own our frame tree, but have |
| 546 | // not yet attached it to the outer frame tree. |
Arthur Hemery | a06697f | 2023-03-14 09:20:57 | [diff] [blame] | 547 | RenderFrameHostImpl* GetParentOrOuterDocumentHelper( |
| 548 | bool escape_guest_view, |
| 549 | bool include_prospective) const; |
Dave Tapuska | c8de3b0 | 2021-12-03 21:51:01 | [diff] [blame] | 550 | |
Harkiran Bolaria | b4437fd | 2021-08-11 17:51:22 | [diff] [blame] | 551 | // Sets the unique_name and name fields on replication_state_. To be used in |
| 552 | // prerender activation to make sure the FrameTreeNode replication state is |
| 553 | // correct after the RenderFrameHost is moved between FrameTreeNodes. The |
| 554 | // renderers should already have the correct value, so unlike |
| 555 | // FrameTreeNode::SetFrameName, we do not notify them here. |
Alison Gale | 770f3fc | 2024-04-27 00:39:58 | [diff] [blame] | 556 | // TODO(crbug.com/40192974): Remove this once the BrowsingContextState |
Harkiran Bolaria | 4eacb3a | 2021-12-13 20:03:47 | [diff] [blame] | 557 | // is implemented to utilize the new path. |
Harkiran Bolaria | b4437fd | 2021-08-11 17:51:22 | [diff] [blame] | 558 | void set_frame_name_for_activation(const std::string& unique_name, |
| 559 | const std::string& name) { |
Harkiran Bolaria | 0b3bdef0 | 2022-03-10 13:04:40 | [diff] [blame] | 560 | current_frame_host()->browsing_context_state()->set_frame_name(unique_name, |
| 561 | name); |
Harkiran Bolaria | b4437fd | 2021-08-11 17:51:22 | [diff] [blame] | 562 | } |
| 563 | |
Nan Lin | aaf84f7 | 2021-12-02 22:31:56 | [diff] [blame] | 564 | // Returns true if error page isolation is enabled. |
| 565 | bool IsErrorPageIsolationEnabled() const; |
| 566 | |
W. James MacLean | 81b8d01f | 2022-01-25 20:50:59 | [diff] [blame] | 567 | // Functions to store and retrieve a frame's srcdoc value on this |
| 568 | // FrameTreeNode. |
| 569 | void SetSrcdocValue(const std::string& srcdoc_value); |
| 570 | const std::string& srcdoc_value() const { return srcdoc_value_; } |
| 571 | |
Garrett Tanzer | c69f464 | 2022-08-15 22:15:14 | [diff] [blame] | 572 | void set_fenced_frame_properties( |
Arthur Sonzogni | c686e8f | 2024-01-11 08:36:37 | [diff] [blame] | 573 | const std::optional<FencedFrameProperties>& fenced_frame_properties) { |
Alison Gale | 770f3fc | 2024-04-27 00:39:58 | [diff] [blame] | 574 | // TODO(crbug.com/40202462): Reenable this DCHECK once ShadowDOM and |
Garrett Tanzer | 2975eeac | 2022-08-22 16:34:01 | [diff] [blame] | 575 | // loading urns in iframes (for FLEDGE OT) are gone. |
| 576 | // DCHECK_EQ(fenced_frame_status_, |
| 577 | // RenderFrameHostImpl::FencedFrameStatus::kFencedFrameRoot); |
Garrett Tanzer | c69f464 | 2022-08-15 22:15:14 | [diff] [blame] | 578 | fenced_frame_properties_ = fenced_frame_properties; |
| 579 | } |
| 580 | |
Xiaochen Zhou | 86f2e71 | 2023-09-13 19:55:04 | [diff] [blame] | 581 | // This function returns the fenced frame properties associated with the given |
| 582 | // source. |
| 583 | // - If `source_node` is set to `kClosestAncestor`, the fenced frame |
| 584 | // properties are obtained by a bottom-up traversal from this node. |
| 585 | // - If `source_node` is set tp `kFrameTreeRoot`, the fenced frame properties |
| 586 | // from the fenced frame tree root are returned. |
| 587 | // For example, for an urn iframe that is nested inside a fenced frame. |
| 588 | // Calling this function from the nested urn iframe with `source_node` set to: |
| 589 | // - `kClosestAncestor`: returns the fenced frame properties from the urn |
| 590 | // iframe. |
| 591 | // - `kFrameTreeRoot`: returns the fenced frame properties from the fenced |
| 592 | // frame. |
| 593 | // Clients should decide which one to use depending on how the application of |
| 594 | // the fenced frame properties interact with urn iframes. |
Alison Gale | 770f3fc | 2024-04-27 00:39:58 | [diff] [blame] | 595 | // TODO(crbug.com/40060657): Once navigation support for urn::uuid in iframes |
Xiaochen Zhou | 86f2e71 | 2023-09-13 19:55:04 | [diff] [blame] | 596 | // is deprecated, remove the parameter `node_source`. |
Arthur Sonzogni | c686e8f | 2024-01-11 08:36:37 | [diff] [blame] | 597 | std::optional<FencedFrameProperties>& GetFencedFrameProperties( |
Xiaochen Zhou | 86f2e71 | 2023-09-13 19:55:04 | [diff] [blame] | 598 | FencedFramePropertiesNodeSource node_source = |
| 599 | FencedFramePropertiesNodeSource::kClosestAncestor); |
Garrett Tanzer | c69f464 | 2022-08-15 22:15:14 | [diff] [blame] | 600 | |
Liam Brady | 27da6a2 | 2024-06-05 16:35:34 | [diff] [blame] | 601 | // Helper function for getting the FrameTreeNode that houses the relevant |
| 602 | // FencedFrameProperties when GetFencedFrameProperties() is called with |
| 603 | // kClosestAncestor. |
| 604 | FrameTreeNode* GetClosestAncestorWithFencedFrameProperties(); |
| 605 | |
Liam Brady | 86ca048 | 2023-12-06 19:49:25 | [diff] [blame] | 606 | bool HasFencedFrameProperties() const { |
| 607 | return fenced_frame_properties_.has_value(); |
| 608 | } |
| 609 | |
Liam Brady | 6da2cc9e | 2023-01-30 17:09:43 | [diff] [blame] | 610 | // Called from the currently active document via the |
| 611 | // `Fence.setReportEventDataForAutomaticBeacons` JS API. |
| 612 | void SetFencedFrameAutomaticBeaconReportEventData( |
Liam Brady | 95434ea6 | 2023-11-02 19:18:32 | [diff] [blame] | 613 | blink::mojom::AutomaticBeaconType event_type, |
Liam Brady | 6da2cc9e | 2023-01-30 17:09:43 | [diff] [blame] | 614 | const std::string& event_data, |
Nan Lin | dbce6e3 | 2023-05-10 22:42:55 | [diff] [blame] | 615 | const std::vector<blink::FencedFrame::ReportingDestination>& destinations, |
Liam Brady | 86ca048 | 2023-12-06 19:49:25 | [diff] [blame] | 616 | bool once, |
| 617 | bool cross_origin_exposed) override; |
Liam Brady | be6621d1 | 2023-07-20 19:43:40 | [diff] [blame] | 618 | |
| 619 | // Helper function to clear out automatic beacon data after one automatic |
| 620 | // beacon if `once` was set to true when calling |
| 621 | // `setReportEventDataForAutomaticBeacons()`. |
Liam Brady | 95434ea6 | 2023-11-02 19:18:32 | [diff] [blame] | 622 | void MaybeResetFencedFrameAutomaticBeaconReportEventData( |
| 623 | blink::mojom::AutomaticBeaconType event_type); |
Liam Brady | 6da2cc9e | 2023-01-30 17:09:43 | [diff] [blame] | 624 | |
Yao Xiao | f9ae90a | 2023-03-01 20:52:44 | [diff] [blame] | 625 | // Returns the number of fenced frame boundaries above this frame. The |
Yao Xiao | a2337ad | 2022-10-12 20:59:29 | [diff] [blame] | 626 | // outermost main frame's frame tree has fenced frame depth 0, a topmost |
| 627 | // fenced frame tree embedded in the outermost main frame has fenced frame |
| 628 | // depth 1, etc. |
Yao Xiao | f9ae90a | 2023-03-01 20:52:44 | [diff] [blame] | 629 | // |
| 630 | // Also, sets `shared_storage_fenced_frame_root_count` to the |
| 631 | // number of fenced frame boundaries (roots) above this frame that originate |
| 632 | // from shared storage. This is used to check whether a fenced frame |
| 633 | // originates from shared storage only (i.e. not from FLEDGE). |
Alison Gale | 770f3fc | 2024-04-27 00:39:58 | [diff] [blame] | 634 | // TODO(crbug.com/40233168): Remove this check once we put permissions inside |
Yao Xiao | f9ae90a | 2023-03-01 20:52:44 | [diff] [blame] | 635 | // FencedFrameConfig. |
| 636 | size_t GetFencedFrameDepth(size_t& shared_storage_fenced_frame_root_count); |
Yao Xiao | a2337ad | 2022-10-12 20:59:29 | [diff] [blame] | 637 | |
| 638 | // Traverse up from this node. Return all valid |
| 639 | // `node->fenced_frame_properties_->shared_storage_budget_metadata` (i.e. this |
| 640 | // node is subjected to the shared storage budgeting associated with those |
| 641 | // metadata). Every node that originates from sharedStorage.selectURL() will |
| 642 | // have an associated metadata. This indicates that the metadata can only |
| 643 | // possibly be associated with a fenced frame root, unless when |
| 644 | // `kAllowURNsInIframes` is enabled in which case they could be be associated |
| 645 | // with any node. |
Garrett Tanzer | 29de711 | 2022-12-06 21:26:32 | [diff] [blame] | 646 | std::vector<const SharedStorageBudgetMetadata*> |
Yao Xiao | 1ac702d | 2022-06-08 17:20:49 | [diff] [blame] | 647 | FindSharedStorageBudgetMetadata(); |
| 648 | |
Camillia Smith Barnes | 7218518c | 2023-03-06 19:02:17 | [diff] [blame] | 649 | // Returns any shared storage context string that was written to a |
| 650 | // `blink::FencedFrameConfig` before navigation via |
| 651 | // `setSharedStorageContext()`, as long as the request is for a same-origin |
| 652 | // frame within the config's fenced frame tree (or a same-origin descendant of |
| 653 | // a URN iframe). |
Arthur Sonzogni | c686e8f | 2024-01-11 08:36:37 | [diff] [blame] | 654 | std::optional<std::u16string> GetEmbedderSharedStorageContextIfAllowed(); |
Camillia Smith Barnes | 7218518c | 2023-03-06 19:02:17 | [diff] [blame] | 655 | |
Harkiran Bolaria | ebbe770 | 2022-02-22 19:19:03 | [diff] [blame] | 656 | // Accessor to BrowsingContextState for subframes only. Only main frame |
| 657 | // navigations can change BrowsingInstances and BrowsingContextStates, |
| 658 | // therefore for subframes associated BrowsingContextState never changes. This |
| 659 | // helper method makes this more explicit and guards against calling this on |
| 660 | // main frames (there an appropriate BrowsingContextState should be obtained |
| 661 | // from RenderFrameHost or from RenderFrameProxyHost as e.g. during |
| 662 | // cross-BrowsingInstance navigations multiple BrowsingContextStates exist in |
| 663 | // the same frame). |
| 664 | const scoped_refptr<BrowsingContextState>& |
| 665 | GetBrowsingContextStateForSubframe() const; |
| 666 | |
Arthur Hemery | e465928 | 2022-03-28 08:36:15 | [diff] [blame] | 667 | // Clears the opener property of popups referencing this FrameTreeNode as |
| 668 | // their opener. |
| 669 | void ClearOpenerReferences(); |
| 670 | |
Liam Brady | 95d36d1 | 2023-03-13 21:13:06 | [diff] [blame] | 671 | // Calculates whether one of the ancestor frames or this frame has a CSPEE in |
| 672 | // place. This is eventually sent over to LocalFrame in the renderer where it |
| 673 | // will be used by NavigatorAuction::canLoadAdAuctionFencedFrame for |
| 674 | // information it can't get on its own. |
Liam Brady | d2a41e15 | 2022-07-19 13:58:48 | [diff] [blame] | 675 | bool AncestorOrSelfHasCSPEE() const; |
| 676 | |
Arthur Sonzogni | 8e8eb1f | 2023-01-10 14:51:01 | [diff] [blame] | 677 | // Reset every navigation in this frame, and its descendants. This is called |
| 678 | // after the <iframe> element has been removed, or after the document owning |
| 679 | // this frame has been navigated away. |
| 680 | // |
| 681 | // This takes into account: |
| 682 | // - Non-pending commit NavigationRequest owned by the FrameTreeNode |
| 683 | // - Pending commit NavigationRequest owned by the current RenderFrameHost |
| 684 | // - Speculative RenderFrameHost and its pending commit NavigationRequests. |
| 685 | void ResetAllNavigationsForFrameDetach(); |
| 686 | |
Miyoung Shin | 7cf88b4 | 2022-11-07 13:22:30 | [diff] [blame] | 687 | // RenderFrameHostOwner implementation: |
Nate Chapin | 470dbc6 | 2023-04-25 16:34:38 | [diff] [blame] | 688 | void DidStartLoading(LoadingState previous_frame_tree_loading_state) override; |
Julie Jeongeun Kim | 07c077bd | 2022-12-05 08:40:31 | [diff] [blame] | 689 | void DidStopLoading() override; |
Miyoung Shin | 7cf88b4 | 2022-11-07 13:22:30 | [diff] [blame] | 690 | void RestartNavigationAsCrossDocument( |
| 691 | std::unique_ptr<NavigationRequest> navigation_request) override; |
Miyoung Shin | 1504eb71 | 2022-12-07 10:32:18 | [diff] [blame] | 692 | bool Reload() override; |
Julie Jeongeun Kim | c1b07c3 | 2022-11-11 10:26:32 | [diff] [blame] | 693 | Navigator& GetCurrentNavigator() override; |
Miyoung Shin | e16cd226 | 2022-11-30 05:52:16 | [diff] [blame] | 694 | RenderFrameHostManager& GetRenderFrameHostManager() override; |
Miyoung Shin | 64fd1bea | 2023-01-04 04:22:08 | [diff] [blame] | 695 | FrameTreeNode* GetOpener() const override; |
Julie Jeongeun Kim | 2132b37f8 | 2022-11-23 08:30:46 | [diff] [blame] | 696 | void SetFocusedFrame(SiteInstanceGroup* source) override; |
Julie Jeongeun Kim | 0e24224 | 2022-11-30 10:45:09 | [diff] [blame] | 697 | void DidChangeReferrerPolicy( |
| 698 | network::mojom::ReferrerPolicy referrer_policy) override; |
Miyoung Shin | 8a66ec02 | 2022-11-28 23:50:09 | [diff] [blame] | 699 | // Updates the user activation state in the browser frame tree and in the |
| 700 | // frame trees in all renderer processes except the renderer for this node |
| 701 | // (which initiated the update). Returns |false| if the update tries to |
| 702 | // consume an already consumed/expired transient state, |true| otherwise. See |
| 703 | // the comment on `user_activation_state_` in RenderFrameHostImpl. |
| 704 | // |
| 705 | // The |notification_type| parameter is used for histograms, only for the case |
| 706 | // |update_state == kNotifyActivation|. |
| 707 | bool UpdateUserActivationState( |
| 708 | blink::mojom::UserActivationUpdateType update_type, |
| 709 | blink::mojom::UserActivationNotificationType notification_type) override; |
Nate Chapin | 47276a6 | 2023-02-16 16:53:44 | [diff] [blame] | 710 | void DidConsumeHistoryUserActivation() override; |
Charlie Reis | 734db66 | 2024-01-11 18:20:03 | [diff] [blame] | 711 | void DidOpenDocumentInputStream() override; |
Miyoung Shin | ff13ed2 | 2022-11-30 09:21:47 | [diff] [blame] | 712 | std::unique_ptr<NavigationRequest> |
| 713 | CreateNavigationRequestForSynchronousRendererCommit( |
| 714 | RenderFrameHostImpl* render_frame_host, |
| 715 | bool is_same_document, |
| 716 | const GURL& url, |
| 717 | const url::Origin& origin, |
Arthur Sonzogni | c686e8f | 2024-01-11 08:36:37 | [diff] [blame] | 718 | const std::optional<GURL>& initiator_base_url, |
Miyoung Shin | ff13ed2 | 2022-11-30 09:21:47 | [diff] [blame] | 719 | const net::IsolationInfo& isolation_info_for_subresources, |
| 720 | blink::mojom::ReferrerPtr referrer, |
| 721 | const ui::PageTransition& transition, |
| 722 | bool should_replace_current_entry, |
| 723 | const std::string& method, |
| 724 | bool has_transient_activation, |
| 725 | bool is_overriding_user_agent, |
| 726 | const std::vector<GURL>& redirects, |
| 727 | const GURL& original_url, |
| 728 | std::unique_ptr<CrossOriginEmbedderPolicyReporter> coep_reporter, |
Miyoung Shin | ff13ed2 | 2022-11-30 09:21:47 | [diff] [blame] | 729 | int http_response_code) override; |
Rakina Zata Amni | 58681c6 | 2024-06-25 06:32:13 | [diff] [blame^] | 730 | void CancelNavigation(NavigationDiscardReason reason) override; |
Miyoung Shin | c9ff481 | 2023-01-05 08:58:05 | [diff] [blame] | 731 | bool Credentialless() const override; |
Miyoung Shin | af9a3436 | 2023-01-31 02:46:51 | [diff] [blame] | 732 | #if !BUILDFLAG(IS_ANDROID) |
| 733 | void GetVirtualAuthenticatorManager( |
| 734 | mojo::PendingReceiver<blink::test::mojom::VirtualAuthenticatorManager> |
| 735 | receiver) override; |
| 736 | #endif |
Miyoung Shin | ff13ed2 | 2022-11-30 09:21:47 | [diff] [blame] | 737 | |
Mingyu Lei | 7956b8b | 2023-07-24 08:24:08 | [diff] [blame] | 738 | // Restart the navigation restoring the page from the back-forward cache |
| 739 | // as a regular non-BFCached history navigation. |
| 740 | // |
| 741 | // The restart itself is asynchronous as it's dangerous to restart navigation |
| 742 | // with arbitrary state on the stack (another navigation might be starting), |
| 743 | // so this function only posts the actual task to do all the work (See |
| 744 | // `RestartBackForwardCachedNavigationImpl()`). |
| 745 | void RestartBackForwardCachedNavigationAsync(int nav_entry_id); |
| 746 | |
| 747 | // Cancel the asynchronous task that would restart the BFCache navigation. |
| 748 | // This should be called whenever a FrameTreeNode's NavigationRequest would |
| 749 | // normally get cancelled, including when another NavigationRequest starts. |
| 750 | // This preserves the previous behavior where a restarting BFCache |
| 751 | // NavigationRequest is kept around until the task to create the new |
| 752 | // navigation is run, or until that NavigationRequest gets deleted (which |
| 753 | // cancels the task). |
| 754 | void CancelRestartingBackForwardCacheNavigation(); |
| 755 | |
Christian Biesinger | e1865c57c | 2023-10-20 15:19:29 | [diff] [blame] | 756 | base::SafeRef<FrameTreeNode> GetSafeRef() { |
| 757 | return weak_factory_.GetSafeRef(); |
| 758 | } |
| 759 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 760 | private: |
Yuzu Saijo | 03dbf9b | 2022-07-22 04:29:45 | [diff] [blame] | 761 | friend class CSPEmbeddedEnforcementUnitTest; |
Charlie Hu | bb5943d | 2021-03-09 19:46:12 | [diff] [blame] | 762 | FRIEND_TEST_ALL_PREFIXES(SitePerProcessPermissionsPolicyBrowserTest, |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 763 | ContainerPolicyDynamic); |
Charlie Hu | bb5943d | 2021-03-09 19:46:12 | [diff] [blame] | 764 | FRIEND_TEST_ALL_PREFIXES(SitePerProcessPermissionsPolicyBrowserTest, |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 765 | ContainerPolicySandboxDynamic); |
Yuzu Saijo | 03dbf9b | 2022-07-22 04:29:45 | [diff] [blame] | 766 | FRIEND_TEST_ALL_PREFIXES(NavigationRequestTest, StorageKeyToCommit); |
Arthur Sonzogni | 6445759 | 2022-11-22 11:08:59 | [diff] [blame] | 767 | FRIEND_TEST_ALL_PREFIXES( |
| 768 | NavigationRequestTest, |
| 769 | NavigationToCredentiallessDocumentNetworkIsolationInfo); |
Yuzu Saijo | 03dbf9b | 2022-07-22 04:29:45 | [diff] [blame] | 770 | FRIEND_TEST_ALL_PREFIXES(RenderFrameHostImplTest, |
Arthur Sonzogni | 6445759 | 2022-11-22 11:08:59 | [diff] [blame] | 771 | ChildOfCredentiallessIsCredentialless); |
Yifan Luo | 86a79f4 | 2022-08-16 18:38:27 | [diff] [blame] | 772 | FRIEND_TEST_ALL_PREFIXES(ContentPasswordManagerDriverTest, |
Arthur Sonzogni | 6445759 | 2022-11-22 11:08:59 | [diff] [blame] | 773 | PasswordAutofillDisabledOnCredentiallessIframe); |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 774 | |
Dominic Farolino | 8a2187b | 2021-12-24 20:44:21 | [diff] [blame] | 775 | // Called by the destructor. When `this` is an outer dummy FrameTreeNode |
| 776 | // representing an inner FrameTree, this method destroys said inner FrameTree. |
| 777 | void DestroyInnerFrameTreeIfExists(); |
| 778 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 779 | class OpenerDestroyedObserver; |
| 780 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 781 | // The |notification_type| parameter is used for histograms only. |
Liam Brady | 38b8456 | 2024-03-07 22:11:26 | [diff] [blame] | 782 | // |sticky_only| is set to true when propagating sticky user activation during |
| 783 | // cross-document navigations. The transient state remains unchanged. |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 784 | bool NotifyUserActivation( |
Liam Brady | 38b8456 | 2024-03-07 22:11:26 | [diff] [blame] | 785 | blink::mojom::UserActivationNotificationType notification_type, |
| 786 | bool sticky_only = false); |
| 787 | |
| 788 | bool NotifyUserActivationStickyOnly(); |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 789 | |
| 790 | bool ConsumeTransientUserActivation(); |
| 791 | |
| 792 | bool ClearUserActivation(); |
| 793 | |
| 794 | // Verify that the renderer process is allowed to set user activation on this |
| 795 | // frame by checking whether this frame's RenderWidgetHost had previously seen |
| 796 | // an input event that might lead to user activation. If user activation |
| 797 | // should be allowed, this returns true and also clears corresponding pending |
| 798 | // user activation state in the widget. Otherwise, this returns false. |
| 799 | bool VerifyUserActivation(); |
| 800 | |
Mingyu Lei | 7956b8b | 2023-07-24 08:24:08 | [diff] [blame] | 801 | // See `RestartBackForwardCachedNavigationAsync()`. |
| 802 | void RestartBackForwardCachedNavigationImpl(int nav_entry_id); |
| 803 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 804 | // The next available browser-global FrameTreeNode ID. |
| 805 | static int next_frame_tree_node_id_; |
| 806 | |
Arthur Sonzogni | f6785ec | 2022-12-05 10:11:50 | [diff] [blame] | 807 | // The FrameTree owning |this|. It can change with Prerender2 during |
| 808 | // activation. |
| 809 | raw_ref<FrameTree> frame_tree_; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 810 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 811 | // A browser-global identifier for the frame in the page, which stays stable |
| 812 | // even if the frame does a cross-process navigation. |
| 813 | const int frame_tree_node_id_; |
| 814 | |
| 815 | // The RenderFrameHost owning this FrameTreeNode, which cannot change for the |
| 816 | // life of this FrameTreeNode. |nullptr| if this node is the root. |
Keishi Hattori | 0e45c02 | 2021-11-27 09:25:52 | [diff] [blame] | 817 | const raw_ptr<RenderFrameHostImpl> parent_; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 818 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 819 | // The frame that opened this frame, if any. Will be set to null if the |
| 820 | // opener is closed, or if this frame disowns its opener by setting its |
| 821 | // window.opener to null. |
Keishi Hattori | 0e45c02 | 2021-11-27 09:25:52 | [diff] [blame] | 822 | raw_ptr<FrameTreeNode> opener_ = nullptr; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 823 | |
| 824 | // An observer that clears this node's |opener_| if the opener is destroyed. |
| 825 | // This observer is added to the |opener_|'s observer list when the |opener_| |
| 826 | // is set to a non-null node, and it is removed from that list when |opener_| |
| 827 | // changes or when this node is destroyed. It is also cleared if |opener_| |
| 828 | // is disowned. |
| 829 | std::unique_ptr<OpenerDestroyedObserver> opener_observer_; |
| 830 | |
Rakina Zata Amni | 3a48ae4 | 2022-05-05 03:39:56 | [diff] [blame] | 831 | // Unlike `opener_`, the "original opener chain" doesn't reflect |
| 832 | // window.opener, which can be suppressed or updated. The "original opener" |
| 833 | // is the main frame of the actual opener of this frame. This traces the all |
| 834 | // the way back, so if the original opener was closed (deleted or severed due |
| 835 | // to COOP), but _it_ had an original opener, this will return the original |
| 836 | // opener's original opener, etc. So this value will always be set as long as |
| 837 | // there is at least one live frame in the chain whose connection is not |
| 838 | // severed due to COOP. |
| 839 | raw_ptr<FrameTreeNode> first_live_main_frame_in_original_opener_chain_ = |
| 840 | nullptr; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 841 | |
Wolfgang Beyer | d8809db | 2020-09-30 15:29:39 | [diff] [blame] | 842 | // The devtools frame token of the frame which opened this frame. This is |
| 843 | // not cleared even if the opener is destroyed or disowns the frame. |
Arthur Sonzogni | c686e8f | 2024-01-11 08:36:37 | [diff] [blame] | 844 | std::optional<base::UnguessableToken> opener_devtools_frame_token_; |
Wolfgang Beyer | d8809db | 2020-09-30 15:29:39 | [diff] [blame] | 845 | |
Rakina Zata Amni | 3a48ae4 | 2022-05-05 03:39:56 | [diff] [blame] | 846 | // An observer that updates this node's |
| 847 | // |first_live_main_frame_in_original_opener_chain_| to the next original |
| 848 | // opener in the chain if the original opener is destroyed. |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 849 | std::unique_ptr<OpenerDestroyedObserver> original_opener_observer_; |
| 850 | |
arthursonzogni | 034bb9c | 2020-10-01 08:29:56 | [diff] [blame] | 851 | // When created by an opener, the URL specified in window.open(url) |
| 852 | // Please refer to {Get,Set}InitialPopupURL() documentation. |
| 853 | GURL initial_popup_url_; |
| 854 | |
| 855 | // When created using window.open, the origin of the creator. |
| 856 | // Please refer to {Get,Set}PopupCreatorOrigin() documentation. |
| 857 | url::Origin popup_creator_origin_; |
| 858 | |
W. James MacLean | 81b8d01f | 2022-01-25 20:50:59 | [diff] [blame] | 859 | // If the url from the the last BeginNavigation is about:srcdoc, this value |
| 860 | // stores the srcdoc_attribute's value for re-use in history navigations. |
| 861 | std::string srcdoc_value_; |
| 862 | |
Charlie Reis | 734db66 | 2024-01-11 18:20:03 | [diff] [blame] | 863 | // Whether this frame is still on the initial about:blank document or the |
| 864 | // synchronously committed about:blank document committed at frame creation, |
| 865 | // and its "initial empty document"-ness is still true. |
| 866 | // This will be false if either of these has happened: |
| 867 | // - The current RenderFrameHost commits a cross-document navigation that is |
| 868 | // not the synchronously committed about:blank document per: |
| 869 | // https://html.spec.whatwg.org/multipage/browsers.html#creating-browsing-contexts:is-initial-about:blank |
| 870 | // - The document's input stream has been opened with document.open(), per |
| 871 | // https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#opening-the-input-stream:is-initial-about:blank |
| 872 | // NOTE: we treat both the "initial about:blank document" and the |
| 873 | // "synchronously committed about:blank document" as the initial empty |
| 874 | // document. In the future, we plan to remove the synchronous about:blank |
| 875 | // commit so that this state will only be true if the frame is on the |
| 876 | // "initial about:blank document". See also: |
| 877 | // - https://github.com/whatwg/html/issues/6863 |
| 878 | // - https://crbug.com/1215096 |
| 879 | // |
| 880 | // Note that cross-document navigations update this state at |
| 881 | // DidCommitNavigation() time. Thus, this is still true when a cross-document |
| 882 | // navigation from an initial empty document is in the pending-commit window, |
| 883 | // after sending the CommitNavigation IPC but before receiving |
| 884 | // DidCommitNavigation(). This is in contrast to |
| 885 | // has_committed_any_navigation(), which is updated in CommitNavigation(). |
| 886 | // TODO(alexmos): Consider updating this at CommitNavigation() time as well to |
| 887 | // match the has_committed_any_navigation() behavior. |
| 888 | bool is_on_initial_empty_document_ = true; |
| 889 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 890 | // Whether the frame's owner element in the parent document is collapsed. |
arthursonzogni | 9816b919 | 2021-03-29 16:09:19 | [diff] [blame] | 891 | bool is_collapsed_ = false; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 892 | |
Daniel Cheng | 6ac12817 | 2021-05-25 18:49:01 | [diff] [blame] | 893 | // The type of frame owner for this frame. This is only relevant for non-main |
| 894 | // frames. |
Kevin McNee | 43fe829 | 2021-10-04 22:59:41 | [diff] [blame] | 895 | const blink::FrameOwnerElementType frame_owner_element_type_ = |
| 896 | blink::FrameOwnerElementType::kNone; |
Daniel Cheng | 9bd90f9 | 2021-04-23 20:49:45 | [diff] [blame] | 897 | |
Daniel Cheng | 6ac12817 | 2021-05-25 18:49:01 | [diff] [blame] | 898 | // The tree scope type of frame owner element, i.e. whether the element is in |
| 899 | // the document tree (https://dom.spec.whatwg.org/#document-trees) or the |
| 900 | // shadow tree (https://dom.spec.whatwg.org/#shadow-trees). This is only |
| 901 | // relevant for non-main frames. |
| 902 | const blink::mojom::TreeScopeType tree_scope_type_ = |
| 903 | blink::mojom::TreeScopeType::kDocument; |
| 904 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 905 | // Track the pending sandbox flags and container policy for this frame. When a |
| 906 | // parent frame dynamically updates 'sandbox', 'allow', 'allowfullscreen', |
| 907 | // 'allowpaymentrequest' or 'src' attributes, the updated policy for the frame |
Harkiran Bolaria | 4eacb3a | 2021-12-13 20:03:47 | [diff] [blame] | 908 | // is stored here, and transferred into |
| 909 | // render_manager_.current_replication_state().frame_policy when they take |
| 910 | // effect on the next frame navigation. |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 911 | blink::FramePolicy pending_frame_policy_; |
| 912 | |
| 913 | // Whether the frame was created by javascript. This is useful to prune |
| 914 | // history entries when the frame is removed (because frames created by |
| 915 | // scripts are never recreated with the same unique name - see |
| 916 | // https://crbug.com/500260). |
arthursonzogni | 9816b919 | 2021-03-29 16:09:19 | [diff] [blame] | 917 | const bool is_created_by_script_; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 918 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 919 | // Tracks the scrolling and margin properties for this frame. These |
| 920 | // properties affect the child renderer but are stored on its parent's |
| 921 | // frame element. When this frame's parent dynamically updates these |
| 922 | // properties, we update them here too. |
| 923 | // |
| 924 | // Note that dynamic updates only take effect on the next frame navigation. |
| 925 | blink::mojom::FrameOwnerProperties frame_owner_properties_; |
| 926 | |
Yuzu Saijo | 03dbf9b | 2022-07-22 04:29:45 | [diff] [blame] | 927 | // Contains the tracked HTML attributes of the corresponding iframe element, |
| 928 | // such as 'id' and 'src'. |
| 929 | blink::mojom::IframeAttributesPtr attributes_; |
Antonio Sartori | 5abc8de | 2021-07-13 08:42:47 | [diff] [blame] | 930 | |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 931 | // Owns an ongoing NavigationRequest until it is ready to commit. It will then |
| 932 | // be reset and a RenderFrameHost will be responsible for the navigation. |
| 933 | std::unique_ptr<NavigationRequest> navigation_request_; |
| 934 | |
| 935 | // List of objects observing this FrameTreeNode. |
| 936 | base::ObserverList<Observer>::Unchecked observers_; |
| 937 | |
| 938 | base::TimeTicks last_focus_time_; |
| 939 | |
arthursonzogni | 9816b919 | 2021-03-29 16:09:19 | [diff] [blame] | 940 | bool was_discarded_ = false; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 941 | |
Abhijeet Kandalkar | 3f29bc4 | 2022-09-23 12:39:58 | [diff] [blame] | 942 | const FencedFrameStatus fenced_frame_status_ = |
| 943 | FencedFrameStatus::kNotNestedInFencedFrame; |
Harkiran Bolaria | 16f2c48d | 2022-04-22 12:39:57 | [diff] [blame] | 944 | |
Garrett Tanzer | c69f464 | 2022-08-15 22:15:14 | [diff] [blame] | 945 | // If this is a fenced frame resulting from a urn:uuid navigation, this |
| 946 | // contains all the metadata specifying the resulting context. |
Alison Gale | 770f3fc | 2024-04-27 00:39:58 | [diff] [blame] | 947 | // TODO(crbug.com/40202462): Move this into the FrameTree once ShadowDOM |
Garrett Tanzer | 34cb92fe | 2022-09-28 17:50:54 | [diff] [blame] | 948 | // and urn iframes are gone. |
Arthur Sonzogni | c686e8f | 2024-01-11 08:36:37 | [diff] [blame] | 949 | std::optional<FencedFrameProperties> fenced_frame_properties_; |
Garrett Tanzer | c69f464 | 2022-08-15 22:15:14 | [diff] [blame] | 950 | |
Mingyu Lei | 7956b8b | 2023-07-24 08:24:08 | [diff] [blame] | 951 | // The tracker of the task that restarts the BFCache navigation. It might be |
| 952 | // used to cancel the task. |
| 953 | // See `CancelRestartingBackForwardCacheNavigation()`. |
| 954 | base::CancelableTaskTracker restart_back_forward_cached_navigation_tracker_; |
| 955 | |
Lukasz Anforowicz | 14714196 | 2020-12-16 18:03:24 | [diff] [blame] | 956 | // Manages creation and swapping of RenderFrameHosts for this frame. |
| 957 | // |
| 958 | // This field needs to be declared last, because destruction of |
| 959 | // RenderFrameHostManager may call arbitrary callbacks (e.g. via |
| 960 | // WebContentsObserver::DidFinishNavigation fired after RenderFrameHostManager |
| 961 | // destructs a RenderFrameHostImpl and its NavigationRequest). Such callbacks |
| 962 | // may try to use FrameTreeNode's fields above - this would be an undefined |
| 963 | // behavior if the fields (even trivially-destructible ones) were destructed |
| 964 | // before the RenderFrameHostManager's destructor runs. See also |
| 965 | // https://crbug.com/1157988. |
| 966 | RenderFrameHostManager render_manager_; |
Mingyu Lei | 7956b8b | 2023-07-24 08:24:08 | [diff] [blame] | 967 | |
| 968 | base::WeakPtrFactory<FrameTreeNode> weak_factory_{this}; |
danakj | c492bf8 | 2020-09-09 20:02:44 | [diff] [blame] | 969 | }; |
| 970 | |
| 971 | } // namespace content |
| 972 | |
| 973 | #endif // CONTENT_BROWSER_RENDERER_HOST_FRAME_TREE_NODE_H_ |