blob: 52a6dc73fde2c18fe10c7b268dc6d1d371679237 [file] [log] [blame]
Avi Drissman4e1b7bc32022-09-15 14:03:501// Copyright 2013 The Chromium Authors
danakjc492bf82020-09-09 20:02:442// 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 Sonzognic686e8f2024-01-11 08:36:3711#include <optional>
danakjc492bf82020-09-09 20:02:4412#include <string>
David Sanders2c1194d92022-04-19 23:32:3213#include <utility>
danakjc492bf82020-09-09 20:02:4414
15#include "base/gtest_prod_util.h"
Keishi Hattori0e45c022021-11-27 09:25:5216#include "base/memory/raw_ptr.h"
Christian Biesingere1865c57c2023-10-20 15:19:2917#include "base/memory/safe_ref.h"
David Sanders2c1194d92022-04-19 23:32:3218#include "base/memory/scoped_refptr.h"
David Sandersd4bf5eb2022-03-17 07:12:0519#include "base/observer_list.h"
Mingyu Lei7956b8b2023-07-24 08:24:0820#include "base/task/cancelable_task_tracker.h"
Arthur Sonzognic686e8f2024-01-11 08:36:3721#include "base/time/time.h"
danakjc492bf82020-09-09 20:02:4422#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 Shin7cf88b42022-11-07 13:22:3025#include "content/browser/renderer_host/render_frame_host_owner.h"
danakjc492bf82020-09-09 20:02:4426#include "content/common/content_export.h"
Julie Jeongeun Kimf38c1eca2021-12-14 07:46:5527#include "content/public/browser/frame_type.h"
Rakina Zata Amni58681c62024-06-25 06:32:1328#include "content/public/browser/navigation_discard_reason.h"
danakjc492bf82020-09-09 20:02:4429#include "services/network/public/mojom/content_security_policy.mojom-forward.h"
Julie Jeongeun Kim0e242242022-11-30 10:45:0930#include "services/network/public/mojom/referrer_policy.mojom-forward.h"
Kevin McNee43fe8292021-10-04 22:59:4131#include "third_party/blink/public/common/frame/frame_owner_element_type.h"
danakjc492bf82020-09-09 20:02:4432#include "third_party/blink/public/common/frame/frame_policy.h"
danakjc492bf82020-09-09 20:02:4433#include "third_party/blink/public/mojom/frame/frame_owner_properties.mojom.h"
Gyuyoung Kimc16e52e92021-03-19 02:45:3734#include "third_party/blink/public/mojom/frame/frame_replication_state.mojom-forward.h"
Daniel Cheng6ac128172021-05-25 18:49:0135#include "third_party/blink/public/mojom/frame/tree_scope_type.mojom.h"
David Sanders2c1194d92022-04-19 23:32:3236#include "third_party/blink/public/mojom/frame/user_activation_update_types.mojom-forward.h"
Miyoung Shinaf9a34362023-01-31 02:46:5137#include "third_party/blink/public/mojom/webauthn/virtual_authenticator.mojom-forward.h"
danakjc492bf82020-09-09 20:02:4438#include "url/gurl.h"
39#include "url/origin.h"
40
41namespace content {
42
43class NavigationRequest;
danakjc492bf82020-09-09 20:02:4444class NavigationEntryImpl;
Paul Semel3e241042022-10-11 12:57:3145class FrameTree;
danakjc492bf82020-09-09 20:02:4446
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 Shin7cf88b42022-11-07 13:22:3059class CONTENT_EXPORT FrameTreeNode : public RenderFrameHostOwner {
danakjc492bf82020-09-09 20:02:4460 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 Hemerye4659282022-03-28 08:36:1569 // 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 Dalya1d569972021-03-16 03:24:5373 virtual ~Observer() = default;
danakjc492bf82020-09-09 20:02:4474 };
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 Sonzognif6785ec2022-12-05 10:11:5089 FrameTree& frame_tree,
danakjc492bf82020-09-09 20:02:4490 RenderFrameHostImpl* parent,
Daniel Cheng6ac128172021-05-25 18:49:0191 blink::mojom::TreeScopeType tree_scope_type,
danakjc492bf82020-09-09 20:02:4492 bool is_created_by_script,
danakjc492bf82020-09-09 20:02:4493 const blink::mojom::FrameOwnerProperties& frame_owner_properties,
Kevin McNee43fe8292021-10-04 22:59:4194 blink::FrameOwnerElementType owner_type,
Dominic Farolino08662c82021-06-11 07:36:3495 const blink::FramePolicy& frame_owner);
danakjc492bf82020-09-09 20:02:4496
Peter Boström828b9022021-09-21 02:28:4397 FrameTreeNode(const FrameTreeNode&) = delete;
98 FrameTreeNode& operator=(const FrameTreeNode&) = delete;
99
Miyoung Shin7cf88b42022-11-07 13:22:30100 ~FrameTreeNode() override;
danakjc492bf82020-09-09 20:02:44101
102 void AddObserver(Observer* observer);
103 void RemoveObserver(Observer* observer);
104
Ian Vollick25a9d032022-04-12 23:20:17105 // 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.
danakjc492bf82020-09-09 20:02:44111 bool IsMainFrame() const;
Arthur Hemerya06697f2023-03-14 09:20:57112 bool IsOutermostMainFrame() const;
danakjc492bf82020-09-09 20:02:44113
Arthur Sonzognif6785ec2022-12-05 10:11:50114 FrameTree& frame_tree() const { return frame_tree_.get(); }
Paul Semel3e241042022-10-11 12:57:31115 Navigator& navigator();
danakjc492bf82020-09-09 20:02:44116
117 RenderFrameHostManager* render_manager() { return &render_manager_; }
Alexander Timin33e2e2c12022-03-03 04:21:33118 const RenderFrameHostManager* render_manager() const {
119 return &render_manager_;
120 }
danakjc492bf82020-09-09 20:02:44121 int frame_tree_node_id() const { return frame_tree_node_id_; }
Yuzu Saijo03dbf9b2022-07-22 04:29:45122 // 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 Bolaria4eacb3a2021-12-13 20:03:47127 const std::string& frame_name() const {
128 return render_manager_.current_replication_state().name;
129 }
danakjc492bf82020-09-09 20:02:44130
131 const std::string& unique_name() const {
Harkiran Bolaria4eacb3a2021-12-13 20:03:47132 return render_manager_.current_replication_state().unique_name;
danakjc492bf82020-09-09 20:02:44133 }
134
danakjc492bf82020-09-09 20:02:44135 size_t child_count() const { return current_frame_host()->child_count(); }
136
danakjc492bf82020-09-09 20:02:44137 RenderFrameHostImpl* parent() const { return parent_; }
138
Dave Tapuskac8de3b02021-12-03 21:51:01139 // See `RenderFrameHost::GetParentOrOuterDocument()` for
140 // documentation.
Arthur Hemerya06697f2023-03-14 09:20:57141 RenderFrameHostImpl* GetParentOrOuterDocument() const;
Dave Tapuskac8de3b02021-12-03 21:51:01142
143 // See `RenderFrameHostImpl::GetParentOrOuterDocumentOrEmbedder()` for
144 // documentation.
145 RenderFrameHostImpl* GetParentOrOuterDocumentOrEmbedder();
146
danakjc492bf82020-09-09 20:02:44147 FrameTreeNode* opener() const { return opener_; }
148
Rakina Zata Amni3a48ae42022-05-05 03:39:56149 FrameTreeNode* first_live_main_frame_in_original_opener_chain() const {
150 return first_live_main_frame_in_original_opener_chain_;
151 }
danakjc492bf82020-09-09 20:02:44152
Arthur Sonzognic686e8f2024-01-11 08:36:37153 const std::optional<base::UnguessableToken>& opener_devtools_frame_token() {
Wolfgang Beyerd8809db2020-09-30 15:29:39154 return opener_devtools_frame_token_;
155 }
156
Julie Jeongeun Kimf38c1eca2021-12-14 07:46:55157 // Returns the type of the frame. Refer to frame_type.h for the details.
158 FrameType GetFrameType() const;
159
danakjc492bf82020-09-09 20:02:44160 // 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 Beyerd8809db2020-09-30 15:29:39172 // 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
danakjc492bf82020-09-09 20:02:44178 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 Reis734db662024-01-11 18:20:03187 // 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 Amni86c88fa2021-11-01 01:27:30199 bool is_on_initial_empty_document() const {
Charlie Reis734db662024-01-11 18:20:03200 return is_on_initial_empty_document_;
Rakina Zata Amnifc4cc3d42021-06-10 09:03:56201 }
202
danakjc492bf82020-09-09 20:02:44203 // 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 Bolaria4eacb3a2021-12-13 20:03:47223 return render_manager_.current_replication_state().origin;
danakjc492bf82020-09-09 20:02:44224 }
225
danakjc492bf82020-09-09 20:02:44226 // 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 Brady25a14162022-12-02 15:25:57230 // 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().
danakjc492bf82020-09-09 20:02:44234 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 Hu5130d25e2021-03-05 21:53:39251 // the permissions policy container policy, which is set by the iframe's
danakjc492bf82020-09-09 20:02:44252 // 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 Bolaria4eacb3a2021-12-13 20:03:47259 return render_manager_.current_replication_state().frame_policy;
danakjc492bf82020-09-09 20:02:44260 }
261
danakjc492bf82020-09-09 20:02:44262 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 Saijo03dbf9b2022-07-22 04:29:45271 // Reflects the attributes of the corresponding iframe html element, such
Arthur Sonzogni64457592022-11-22 11:08:59272 // as 'credentialless', 'id', 'name' and 'src'. These values should not be
Yuzu Saijo03dbf9b2022-07-22 04:29:45273 // exposed to cross-origin renderers.
274 const network::mojom::ContentSecurityPolicy* csp_attribute() const {
275 return attributes_->parsed_csp_attribute.get();
danakjc492bf82020-09-09 20:02:44276 }
Yao Xiao9c54b3e2023-03-14 04:25:04277 // 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 Barnes6d2966c82023-08-23 21:16:18281
Orr Bernsteina0cc6792023-11-14 22:12:35282 // 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 Barnes6d2966c82023-08-23 21:16:18287 // Tracks iframe's 'sharedstoragewritable' attribute, indicating what value
Camillia Smith Barnesc267be62023-11-01 20:01:02288 // 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 Barnes6d2966c82023-08-23 21:16:18292 // service will send the `Shared-Storage-Write` request header.
Camillia Smith Barnesc267be62023-11-01 20:01:02293 bool shared_storage_writable_opted_in() const {
294 return attributes_->shared_storage_writable_opted_in;
Camillia Smith Barnes6d2966c82023-08-23 21:16:18295 }
Arthur Sonzognic686e8f2024-01-11 08:36:37296 const std::optional<std::string> html_id() const { return attributes_->id; }
Yuzu Saijo03dbf9b2022-07-22 04:29:45297 // 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 Sonzognic686e8f2024-01-11 08:36:37300 const std::optional<std::string> html_name() const {
Yuzu Saijodc870f92023-01-20 03:39:11301 return attributes_->name;
302 }
Arthur Sonzognic686e8f2024-01-11 08:36:37303 const std::optional<std::string> html_src() const { return attributes_->src; }
danakjc492bf82020-09-09 20:02:44304
Yuzu Saijo03dbf9b2022-07-22 04:29:45305 void SetAttributes(blink::mojom::IframeAttributesPtr attributes);
Antonio Sartori5abc8de2021-07-13 08:42:47306
danakjc492bf82020-09-09 20:02:44307 bool HasSameOrigin(const FrameTreeNode& node) const {
Harkiran Bolaria4eacb3a2021-12-13 20:03:47308 return render_manager_.current_replication_state().origin.IsSameOriginWith(
309 node.current_replication_state().origin);
danakjc492bf82020-09-09 20:02:44310 }
311
Gyuyoung Kimc16e52e92021-03-19 02:45:37312 const blink::mojom::FrameReplicationState& current_replication_state() const {
Harkiran Bolaria4eacb3a2021-12-13 20:03:47313 return render_manager_.current_replication_state();
danakjc492bf82020-09-09 20:02:44314 }
315
316 RenderFrameHostImpl* current_frame_host() const {
317 return render_manager_.current_frame_host();
318 }
319
danakjc492bf82020-09-09 20:02:44320 // Returns true if this node is in a loading state.
321 bool IsLoading() const;
Nate Chapin470dbc62023-04-25 16:34:38322 LoadingState GetLoadingState() const;
danakjc492bf82020-09-09 20:02:44323
Alex Moshchuk9b0fd822020-10-26 23:08:15324 // Returns true if this node has a cross-document navigation in progress.
325 bool HasPendingCrossDocumentNavigation() const;
326
danakjc492bf82020-09-09 20:02:44327 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 Reis09952ee2022-12-08 16:35:07339 void TakeNavigationRequest(
danakjc492bf82020-09-09 20:02:44340 std::unique_ptr<NavigationRequest> navigation_request);
341
Rakina Zata Amnif8f2bb62022-11-23 05:54:32342 // 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 Amni33175cb92022-11-24 02:46:03344 // 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 Cheng390e2a72022-09-28 06:07:53348 void ResetNavigationRequest(NavigationDiscardReason reason);
349
Rakina Zata Amnif8f2bb62022-11-23 05:54:32350 // Similar to `ResetNavigationRequest()`, but keeps the state created by the
Daniel Cheng390e2a72022-09-28 06:07:53351 // NavigationRequest (e.g. speculative RenderFrameHost, loading state).
Rakina Zata Amni58681c62024-06-25 06:32:13352 void ResetNavigationRequestButKeepState(NavigationDiscardReason reason);
danakjc492bf82020-09-09 20:02:44353
danakjc492bf82020-09-09 20:02:44354 // 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
danakjc492bf82020-09-09 20:02:44376 // 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 Bolaria4eacb3a2021-12-13 20:03:47385 return render_manager_.current_replication_state().active_sandbox_flags;
danakjc492bf82020-09-09 20:02:44386 }
387
danakjc492bf82020-09-09 20:02:44388 // 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 Bolaria4eacb3a2021-12-13 20:03:47391 return render_manager_.current_replication_state()
392 .has_received_user_gesture_before_nav;
danakjc492bf82020-09-09 20:02:44393 }
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 Shin8a66ec022022-11-28 23:50:09404 // Deprecated. Use directly HasStickyUserActivation in RFHI.
danakjc492bf82020-09-09 20:02:44405 // Returns the sticky bit of the User Activation v2 state of the
406 // |FrameTreeNode|.
407 bool HasStickyUserActivation() const {
Miyoung Shin8a66ec022022-11-28 23:50:09408 return current_frame_host()->HasStickyUserActivation();
danakjc492bf82020-09-09 20:02:44409 }
410
Miyoung Shin8a66ec022022-11-28 23:50:09411 // Deprecated. Use directly HasStickyUserActivation in RFHI.
danakjc492bf82020-09-09 20:02:44412 // Returns the transient bit of the User Activation v2 state of the
413 // |FrameTreeNode|.
414 bool HasTransientUserActivation() {
Miyoung Shin8a66ec022022-11-28 23:50:09415 return current_frame_host()->HasTransientUserActivation();
danakjc492bf82020-09-09 20:02:44416 }
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 Kandalkarb43affa72022-09-27 16:48:01423 using FencedFrameStatus = RenderFrameHostImpl::FencedFrameStatus;
Abhijeet Kandalkar3f29bc42022-09-23 12:39:58424 FencedFrameStatus fenced_frame_status() const { return fenced_frame_status_; }
425
Kevin McNee43fe8292021-10-04 22:59:41426 blink::FrameOwnerElementType frame_owner_element_type() const {
Daniel Cheng9bd90f92021-04-23 20:49:45427 return frame_owner_element_type_;
danakjc492bf82020-09-09 20:02:44428 }
danakjc492bf82020-09-09 20:02:44429
Daniel Cheng6ac128172021-05-25 18:49:01430 blink::mojom::TreeScopeType tree_scope_type() const {
431 return tree_scope_type_;
432 }
433
arthursonzogni034bb9c2020-10-01 08:29:56434 // 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 Bolaria59290d62021-03-17 01:53:01453 // Sets the associated FrameTree for this node. The node can change FrameTrees
Domenic Denicola7767a9c2023-07-13 15:36:39454 // 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 Bolaria59290d62021-03-17 01:53:01456 void SetFrameTree(FrameTree& frame_tree);
457
Alexander Timin074cd182022-03-23 18:11:22458 using TraceProto = perfetto::protos::pbzero::FrameTreeNodeInfo;
Alexander Timinf785f342021-03-18 00:00:56459 // Write a representation of this object into a trace.
Alexander Timin074cd182022-03-23 18:11:22460 void WriteIntoTrace(perfetto::TracedProto<TraceProto> proto) const;
Alexander Timinf785f342021-03-18 00:00:56461
Carlos Caballero76711352021-03-24 17:38:21462 // Returns true the node is navigating, i.e. it has an associated
463 // NavigationRequest.
464 bool HasNavigation();
465
murakinonoka97a8f042024-01-10 09:17:07466 // 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
shivanigithubf3ddff52021-07-03 22:06:30473 // Fenced frames (meta-bug crbug.com/1111084):
shivanigithub4cd016a2021-09-20 21:10:30474 // 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 //
shivanigithubf3ddff52021-07-03 22:06:30478 // 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 Farolino4bc10ee2021-08-31 00:37:36484 bool IsFencedFrameRoot() const;
shivanigithubf3ddff52021-07-03 22:06:30485
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
shivanigithub4cd016a2021-09-20 21:10:30491 // Returns a valid nonce if `IsInFencedFrameTree()` returns true for `this`.
Garrett Tanzer34cb92fe2022-09-28 17:50:54492 // 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 Sonzognic686e8f2024-01-11 08:36:37513 std::optional<base::UnguessableToken> GetFencedFrameNonce();
shivanigithub4cd016a2021-09-20 21:10:30514
Garrett Tanzer34cb92fe2022-09-28 17:50:54515 // If applicable, initialize the default fenced frame properties. Right now,
516 // this means setting a new fenced frame nonce. See comment on
shivanigithub4cd016a2021-09-20 21:10:30517 // fenced_frame_nonce() for when it is set to a non-null value. Invoked
518 // by FrameTree::Init() or FrameTree::AddFrame().
Garrett Tanzer34cb92fe2022-09-28 17:50:54519 void SetFencedFramePropertiesIfNeeded();
shivanigithub4cd016a2021-09-20 21:10:30520
Garrett Tanzer291a2d52023-03-20 22:41:57521 // 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 Gale770f3fc2024-04-27 00:39:58524 // TODO(crbug.com/40233168): Refactor and expand use of test utils so there is
Garrett Tanzer291a2d52023-03-20 22:41:57525 // 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 Tanzer06980702023-12-12 19:48:20530 fenced_frame_properties_
531 ->SetFencedFramePropertiesOpaqueAdsModeForTesting();
Garrett Tanzer291a2d52023-03-20 22:41:57532 }
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 Lin171fe9a2022-02-17 16:42:16538
Dave Tapuskac8de3b02021-12-03 21:51:01539 // Helper for GetParentOrOuterDocument/GetParentOrOuterDocumentOrEmbedder.
540 // Do not use directly.
Kevin McNee86e64ee2023-02-17 16:35:50541 // `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 Hemerya06697f2023-03-14 09:20:57547 RenderFrameHostImpl* GetParentOrOuterDocumentHelper(
548 bool escape_guest_view,
549 bool include_prospective) const;
Dave Tapuskac8de3b02021-12-03 21:51:01550
Harkiran Bolariab4437fd2021-08-11 17:51:22551 // 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 Gale770f3fc2024-04-27 00:39:58556 // TODO(crbug.com/40192974): Remove this once the BrowsingContextState
Harkiran Bolaria4eacb3a2021-12-13 20:03:47557 // is implemented to utilize the new path.
Harkiran Bolariab4437fd2021-08-11 17:51:22558 void set_frame_name_for_activation(const std::string& unique_name,
559 const std::string& name) {
Harkiran Bolaria0b3bdef02022-03-10 13:04:40560 current_frame_host()->browsing_context_state()->set_frame_name(unique_name,
561 name);
Harkiran Bolariab4437fd2021-08-11 17:51:22562 }
563
Nan Linaaf84f72021-12-02 22:31:56564 // Returns true if error page isolation is enabled.
565 bool IsErrorPageIsolationEnabled() const;
566
W. James MacLean81b8d01f2022-01-25 20:50:59567 // 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 Tanzerc69f4642022-08-15 22:15:14572 void set_fenced_frame_properties(
Arthur Sonzognic686e8f2024-01-11 08:36:37573 const std::optional<FencedFrameProperties>& fenced_frame_properties) {
Alison Gale770f3fc2024-04-27 00:39:58574 // TODO(crbug.com/40202462): Reenable this DCHECK once ShadowDOM and
Garrett Tanzer2975eeac2022-08-22 16:34:01575 // loading urns in iframes (for FLEDGE OT) are gone.
576 // DCHECK_EQ(fenced_frame_status_,
577 // RenderFrameHostImpl::FencedFrameStatus::kFencedFrameRoot);
Garrett Tanzerc69f4642022-08-15 22:15:14578 fenced_frame_properties_ = fenced_frame_properties;
579 }
580
Xiaochen Zhou86f2e712023-09-13 19:55:04581 // 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 Gale770f3fc2024-04-27 00:39:58595 // TODO(crbug.com/40060657): Once navigation support for urn::uuid in iframes
Xiaochen Zhou86f2e712023-09-13 19:55:04596 // is deprecated, remove the parameter `node_source`.
Arthur Sonzognic686e8f2024-01-11 08:36:37597 std::optional<FencedFrameProperties>& GetFencedFrameProperties(
Xiaochen Zhou86f2e712023-09-13 19:55:04598 FencedFramePropertiesNodeSource node_source =
599 FencedFramePropertiesNodeSource::kClosestAncestor);
Garrett Tanzerc69f4642022-08-15 22:15:14600
Liam Brady27da6a22024-06-05 16:35:34601 // Helper function for getting the FrameTreeNode that houses the relevant
602 // FencedFrameProperties when GetFencedFrameProperties() is called with
603 // kClosestAncestor.
604 FrameTreeNode* GetClosestAncestorWithFencedFrameProperties();
605
Liam Brady86ca0482023-12-06 19:49:25606 bool HasFencedFrameProperties() const {
607 return fenced_frame_properties_.has_value();
608 }
609
Liam Brady6da2cc9e2023-01-30 17:09:43610 // Called from the currently active document via the
611 // `Fence.setReportEventDataForAutomaticBeacons` JS API.
612 void SetFencedFrameAutomaticBeaconReportEventData(
Liam Brady95434ea62023-11-02 19:18:32613 blink::mojom::AutomaticBeaconType event_type,
Liam Brady6da2cc9e2023-01-30 17:09:43614 const std::string& event_data,
Nan Lindbce6e32023-05-10 22:42:55615 const std::vector<blink::FencedFrame::ReportingDestination>& destinations,
Liam Brady86ca0482023-12-06 19:49:25616 bool once,
617 bool cross_origin_exposed) override;
Liam Bradybe6621d12023-07-20 19:43:40618
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 Brady95434ea62023-11-02 19:18:32622 void MaybeResetFencedFrameAutomaticBeaconReportEventData(
623 blink::mojom::AutomaticBeaconType event_type);
Liam Brady6da2cc9e2023-01-30 17:09:43624
Yao Xiaof9ae90a2023-03-01 20:52:44625 // Returns the number of fenced frame boundaries above this frame. The
Yao Xiaoa2337ad2022-10-12 20:59:29626 // 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 Xiaof9ae90a2023-03-01 20:52:44629 //
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 Gale770f3fc2024-04-27 00:39:58634 // TODO(crbug.com/40233168): Remove this check once we put permissions inside
Yao Xiaof9ae90a2023-03-01 20:52:44635 // FencedFrameConfig.
636 size_t GetFencedFrameDepth(size_t& shared_storage_fenced_frame_root_count);
Yao Xiaoa2337ad2022-10-12 20:59:29637
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 Tanzer29de7112022-12-06 21:26:32646 std::vector<const SharedStorageBudgetMetadata*>
Yao Xiao1ac702d2022-06-08 17:20:49647 FindSharedStorageBudgetMetadata();
648
Camillia Smith Barnes7218518c2023-03-06 19:02:17649 // 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 Sonzognic686e8f2024-01-11 08:36:37654 std::optional<std::u16string> GetEmbedderSharedStorageContextIfAllowed();
Camillia Smith Barnes7218518c2023-03-06 19:02:17655
Harkiran Bolariaebbe7702022-02-22 19:19:03656 // 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 Hemerye4659282022-03-28 08:36:15667 // Clears the opener property of popups referencing this FrameTreeNode as
668 // their opener.
669 void ClearOpenerReferences();
670
Liam Brady95d36d12023-03-13 21:13:06671 // 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 Bradyd2a41e152022-07-19 13:58:48675 bool AncestorOrSelfHasCSPEE() const;
676
Arthur Sonzogni8e8eb1f2023-01-10 14:51:01677 // 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 Shin7cf88b42022-11-07 13:22:30687 // RenderFrameHostOwner implementation:
Nate Chapin470dbc62023-04-25 16:34:38688 void DidStartLoading(LoadingState previous_frame_tree_loading_state) override;
Julie Jeongeun Kim07c077bd2022-12-05 08:40:31689 void DidStopLoading() override;
Miyoung Shin7cf88b42022-11-07 13:22:30690 void RestartNavigationAsCrossDocument(
691 std::unique_ptr<NavigationRequest> navigation_request) override;
Miyoung Shin1504eb712022-12-07 10:32:18692 bool Reload() override;
Julie Jeongeun Kimc1b07c32022-11-11 10:26:32693 Navigator& GetCurrentNavigator() override;
Miyoung Shine16cd2262022-11-30 05:52:16694 RenderFrameHostManager& GetRenderFrameHostManager() override;
Miyoung Shin64fd1bea2023-01-04 04:22:08695 FrameTreeNode* GetOpener() const override;
Julie Jeongeun Kim2132b37f82022-11-23 08:30:46696 void SetFocusedFrame(SiteInstanceGroup* source) override;
Julie Jeongeun Kim0e242242022-11-30 10:45:09697 void DidChangeReferrerPolicy(
698 network::mojom::ReferrerPolicy referrer_policy) override;
Miyoung Shin8a66ec022022-11-28 23:50:09699 // 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 Chapin47276a62023-02-16 16:53:44710 void DidConsumeHistoryUserActivation() override;
Charlie Reis734db662024-01-11 18:20:03711 void DidOpenDocumentInputStream() override;
Miyoung Shinff13ed22022-11-30 09:21:47712 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 Sonzognic686e8f2024-01-11 08:36:37718 const std::optional<GURL>& initiator_base_url,
Miyoung Shinff13ed22022-11-30 09:21:47719 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 Shinff13ed22022-11-30 09:21:47729 int http_response_code) override;
Rakina Zata Amni58681c62024-06-25 06:32:13730 void CancelNavigation(NavigationDiscardReason reason) override;
Miyoung Shinc9ff4812023-01-05 08:58:05731 bool Credentialless() const override;
Miyoung Shinaf9a34362023-01-31 02:46:51732#if !BUILDFLAG(IS_ANDROID)
733 void GetVirtualAuthenticatorManager(
734 mojo::PendingReceiver<blink::test::mojom::VirtualAuthenticatorManager>
735 receiver) override;
736#endif
Miyoung Shinff13ed22022-11-30 09:21:47737
Mingyu Lei7956b8b2023-07-24 08:24:08738 // 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 Biesingere1865c57c2023-10-20 15:19:29756 base::SafeRef<FrameTreeNode> GetSafeRef() {
757 return weak_factory_.GetSafeRef();
758 }
759
danakjc492bf82020-09-09 20:02:44760 private:
Yuzu Saijo03dbf9b2022-07-22 04:29:45761 friend class CSPEmbeddedEnforcementUnitTest;
Charlie Hubb5943d2021-03-09 19:46:12762 FRIEND_TEST_ALL_PREFIXES(SitePerProcessPermissionsPolicyBrowserTest,
danakjc492bf82020-09-09 20:02:44763 ContainerPolicyDynamic);
Charlie Hubb5943d2021-03-09 19:46:12764 FRIEND_TEST_ALL_PREFIXES(SitePerProcessPermissionsPolicyBrowserTest,
danakjc492bf82020-09-09 20:02:44765 ContainerPolicySandboxDynamic);
Yuzu Saijo03dbf9b2022-07-22 04:29:45766 FRIEND_TEST_ALL_PREFIXES(NavigationRequestTest, StorageKeyToCommit);
Arthur Sonzogni64457592022-11-22 11:08:59767 FRIEND_TEST_ALL_PREFIXES(
768 NavigationRequestTest,
769 NavigationToCredentiallessDocumentNetworkIsolationInfo);
Yuzu Saijo03dbf9b2022-07-22 04:29:45770 FRIEND_TEST_ALL_PREFIXES(RenderFrameHostImplTest,
Arthur Sonzogni64457592022-11-22 11:08:59771 ChildOfCredentiallessIsCredentialless);
Yifan Luo86a79f42022-08-16 18:38:27772 FRIEND_TEST_ALL_PREFIXES(ContentPasswordManagerDriverTest,
Arthur Sonzogni64457592022-11-22 11:08:59773 PasswordAutofillDisabledOnCredentiallessIframe);
danakjc492bf82020-09-09 20:02:44774
Dominic Farolino8a2187b2021-12-24 20:44:21775 // 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
danakjc492bf82020-09-09 20:02:44779 class OpenerDestroyedObserver;
780
danakjc492bf82020-09-09 20:02:44781 // The |notification_type| parameter is used for histograms only.
Liam Brady38b84562024-03-07 22:11:26782 // |sticky_only| is set to true when propagating sticky user activation during
783 // cross-document navigations. The transient state remains unchanged.
danakjc492bf82020-09-09 20:02:44784 bool NotifyUserActivation(
Liam Brady38b84562024-03-07 22:11:26785 blink::mojom::UserActivationNotificationType notification_type,
786 bool sticky_only = false);
787
788 bool NotifyUserActivationStickyOnly();
danakjc492bf82020-09-09 20:02:44789
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 Lei7956b8b2023-07-24 08:24:08801 // See `RestartBackForwardCachedNavigationAsync()`.
802 void RestartBackForwardCachedNavigationImpl(int nav_entry_id);
803
danakjc492bf82020-09-09 20:02:44804 // The next available browser-global FrameTreeNode ID.
805 static int next_frame_tree_node_id_;
806
Arthur Sonzognif6785ec2022-12-05 10:11:50807 // The FrameTree owning |this|. It can change with Prerender2 during
808 // activation.
809 raw_ref<FrameTree> frame_tree_;
danakjc492bf82020-09-09 20:02:44810
danakjc492bf82020-09-09 20:02:44811 // 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 Hattori0e45c022021-11-27 09:25:52817 const raw_ptr<RenderFrameHostImpl> parent_;
danakjc492bf82020-09-09 20:02:44818
danakjc492bf82020-09-09 20:02:44819 // 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 Hattori0e45c022021-11-27 09:25:52822 raw_ptr<FrameTreeNode> opener_ = nullptr;
danakjc492bf82020-09-09 20:02:44823
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 Amni3a48ae42022-05-05 03:39:56831 // 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;
danakjc492bf82020-09-09 20:02:44841
Wolfgang Beyerd8809db2020-09-30 15:29:39842 // 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 Sonzognic686e8f2024-01-11 08:36:37844 std::optional<base::UnguessableToken> opener_devtools_frame_token_;
Wolfgang Beyerd8809db2020-09-30 15:29:39845
Rakina Zata Amni3a48ae42022-05-05 03:39:56846 // 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.
danakjc492bf82020-09-09 20:02:44849 std::unique_ptr<OpenerDestroyedObserver> original_opener_observer_;
850
arthursonzogni034bb9c2020-10-01 08:29:56851 // 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 MacLean81b8d01f2022-01-25 20:50:59859 // 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 Reis734db662024-01-11 18:20:03863 // 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
danakjc492bf82020-09-09 20:02:44890 // Whether the frame's owner element in the parent document is collapsed.
arthursonzogni9816b9192021-03-29 16:09:19891 bool is_collapsed_ = false;
danakjc492bf82020-09-09 20:02:44892
Daniel Cheng6ac128172021-05-25 18:49:01893 // The type of frame owner for this frame. This is only relevant for non-main
894 // frames.
Kevin McNee43fe8292021-10-04 22:59:41895 const blink::FrameOwnerElementType frame_owner_element_type_ =
896 blink::FrameOwnerElementType::kNone;
Daniel Cheng9bd90f92021-04-23 20:49:45897
Daniel Cheng6ac128172021-05-25 18:49:01898 // 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
danakjc492bf82020-09-09 20:02:44905 // 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 Bolaria4eacb3a2021-12-13 20:03:47908 // is stored here, and transferred into
909 // render_manager_.current_replication_state().frame_policy when they take
910 // effect on the next frame navigation.
danakjc492bf82020-09-09 20:02:44911 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).
arthursonzogni9816b9192021-03-29 16:09:19917 const bool is_created_by_script_;
danakjc492bf82020-09-09 20:02:44918
danakjc492bf82020-09-09 20:02:44919 // 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 Saijo03dbf9b2022-07-22 04:29:45927 // Contains the tracked HTML attributes of the corresponding iframe element,
928 // such as 'id' and 'src'.
929 blink::mojom::IframeAttributesPtr attributes_;
Antonio Sartori5abc8de2021-07-13 08:42:47930
danakjc492bf82020-09-09 20:02:44931 // 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
arthursonzogni9816b9192021-03-29 16:09:19940 bool was_discarded_ = false;
danakjc492bf82020-09-09 20:02:44941
Abhijeet Kandalkar3f29bc42022-09-23 12:39:58942 const FencedFrameStatus fenced_frame_status_ =
943 FencedFrameStatus::kNotNestedInFencedFrame;
Harkiran Bolaria16f2c48d2022-04-22 12:39:57944
Garrett Tanzerc69f4642022-08-15 22:15:14945 // If this is a fenced frame resulting from a urn:uuid navigation, this
946 // contains all the metadata specifying the resulting context.
Alison Gale770f3fc2024-04-27 00:39:58947 // TODO(crbug.com/40202462): Move this into the FrameTree once ShadowDOM
Garrett Tanzer34cb92fe2022-09-28 17:50:54948 // and urn iframes are gone.
Arthur Sonzognic686e8f2024-01-11 08:36:37949 std::optional<FencedFrameProperties> fenced_frame_properties_;
Garrett Tanzerc69f4642022-08-15 22:15:14950
Mingyu Lei7956b8b2023-07-24 08:24:08951 // 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 Anforowicz147141962020-12-16 18:03:24956 // 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 Lei7956b8b2023-07-24 08:24:08967
968 base::WeakPtrFactory<FrameTreeNode> weak_factory_{this};
danakjc492bf82020-09-09 20:02:44969};
970
971} // namespace content
972
973#endif // CONTENT_BROWSER_RENDERER_HOST_FRAME_TREE_NODE_H_