blob: 94b0aec543a18956f7e6cbe2042fc08b2d2869be [file] [log] [blame]
danakjc492bf82020-09-09 20:02:441// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef CONTENT_BROWSER_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>
11#include <string>
12#include <vector>
13
14#include "base/gtest_prod_util.h"
Keishi Hattori0e45c022021-11-27 09:25:5215#include "base/memory/raw_ptr.h"
danakjc492bf82020-09-09 20:02:4416#include "base/memory/ref_counted.h"
17#include "content/browser/renderer_host/frame_tree.h"
18#include "content/browser/renderer_host/frame_tree_node_blame_context.h"
19#include "content/browser/renderer_host/navigator.h"
20#include "content/browser/renderer_host/render_frame_host_impl.h"
21#include "content/browser/renderer_host/render_frame_host_manager.h"
22#include "content/common/content_export.h"
Julie Jeongeun Kimf38c1eca2021-12-14 07:46:5523#include "content/public/browser/frame_type.h"
danakjc492bf82020-09-09 20:02:4424#include "services/network/public/mojom/content_security_policy.mojom-forward.h"
Lei Zhang698df03c2021-05-21 04:23:3425#include "third_party/abseil-cpp/absl/types/optional.h"
Kevin McNee43fe8292021-10-04 22:59:4126#include "third_party/blink/public/common/frame/frame_owner_element_type.h"
danakjc492bf82020-09-09 20:02:4427#include "third_party/blink/public/common/frame/frame_policy.h"
28#include "third_party/blink/public/common/frame/user_activation_state.h"
danakjc492bf82020-09-09 20:02:4429#include "third_party/blink/public/mojom/frame/frame_owner_properties.mojom.h"
Gyuyoung Kimc16e52e92021-03-19 02:45:3730#include "third_party/blink/public/mojom/frame/frame_replication_state.mojom-forward.h"
Daniel Cheng6ac128172021-05-25 18:49:0131#include "third_party/blink/public/mojom/frame/tree_scope_type.mojom.h"
danakjc492bf82020-09-09 20:02:4432#include "third_party/blink/public/mojom/frame/user_activation_update_types.mojom.h"
33#include "third_party/blink/public/mojom/security_context/insecure_request_policy.mojom-forward.h"
34
35#include "url/gurl.h"
36#include "url/origin.h"
37
38namespace content {
39
40class NavigationRequest;
41class RenderFrameHostImpl;
42class NavigationEntryImpl;
43
44// When a page contains iframes, its renderer process maintains a tree structure
45// of those frames. We are mirroring this tree in the browser process. This
46// class represents a node in this tree and is a wrapper for all objects that
47// are frame-specific (as opposed to page-specific).
48//
49// Each FrameTreeNode has a current RenderFrameHost, which can change over
50// time as the frame is navigated. Any immediate subframes of the current
51// document are tracked using FrameTreeNodes owned by the current
52// RenderFrameHost, rather than as children of FrameTreeNode itself. This
53// allows subframe FrameTreeNodes to stay alive while a RenderFrameHost is
54// still alive - for example while pending deletion, after a new current
55// RenderFrameHost has replaced it.
56class CONTENT_EXPORT FrameTreeNode {
57 public:
58 class Observer {
59 public:
60 // Invoked when a FrameTreeNode is being destroyed.
61 virtual void OnFrameTreeNodeDestroyed(FrameTreeNode* node) {}
62
63 // Invoked when a FrameTreeNode becomes focused.
64 virtual void OnFrameTreeNodeFocused(FrameTreeNode* node) {}
65
Fergal Dalya1d569972021-03-16 03:24:5366 virtual ~Observer() = default;
danakjc492bf82020-09-09 20:02:4467 };
68
69 static const int kFrameTreeNodeInvalidId;
70
71 // Returns the FrameTreeNode with the given global |frame_tree_node_id|,
72 // regardless of which FrameTree it is in.
73 static FrameTreeNode* GloballyFindByID(int frame_tree_node_id);
74
75 // Returns the FrameTreeNode for the given |rfh|. Same as
76 // rfh->frame_tree_node(), but also supports nullptrs.
77 static FrameTreeNode* From(RenderFrameHost* rfh);
78
79 // Callers are are expected to initialize sandbox flags separately after
80 // calling the constructor.
81 FrameTreeNode(
82 FrameTree* frame_tree,
83 RenderFrameHostImpl* parent,
Daniel Cheng6ac128172021-05-25 18:49:0184 blink::mojom::TreeScopeType tree_scope_type,
danakjc492bf82020-09-09 20:02:4485 const std::string& name,
86 const std::string& unique_name,
87 bool is_created_by_script,
88 const base::UnguessableToken& devtools_frame_token,
89 const blink::mojom::FrameOwnerProperties& frame_owner_properties,
Kevin McNee43fe8292021-10-04 22:59:4190 blink::FrameOwnerElementType owner_type,
Dominic Farolino08662c82021-06-11 07:36:3491 const blink::FramePolicy& frame_owner);
danakjc492bf82020-09-09 20:02:4492
Peter Boström828b9022021-09-21 02:28:4393 FrameTreeNode(const FrameTreeNode&) = delete;
94 FrameTreeNode& operator=(const FrameTreeNode&) = delete;
95
danakjc492bf82020-09-09 20:02:4496 ~FrameTreeNode();
97
98 void AddObserver(Observer* observer);
99 void RemoveObserver(Observer* observer);
100
101 bool IsMainFrame() const;
102
arthursonzogni76098e52020-11-25 14:18:45103 // Clears any state in this node which was set by the document itself (CSP &
104 // UserActivationState) and notifies proxies as appropriate. Invoked after
105 // committing navigation to a new document (since the new document comes with
106 // a fresh set of CSP).
107 // TODO(arthursonzogni): Remove this function. The frame/document must not be
108 // left temporarily with lax state.
Hiroki Nakagawaab309622021-05-19 16:38:13109 void ResetForNavigation();
danakjc492bf82020-09-09 20:02:44110
111 FrameTree* frame_tree() const { return frame_tree_; }
112 Navigator& navigator() { return frame_tree()->navigator(); }
113
114 RenderFrameHostManager* render_manager() { return &render_manager_; }
115 int frame_tree_node_id() const { return frame_tree_node_id_; }
Harkiran Bolaria4eacb3a2021-12-13 20:03:47116 const std::string& frame_name() const {
117 return render_manager_.current_replication_state().name;
118 }
danakjc492bf82020-09-09 20:02:44119
120 const std::string& unique_name() const {
Harkiran Bolaria4eacb3a2021-12-13 20:03:47121 return render_manager_.current_replication_state().unique_name;
danakjc492bf82020-09-09 20:02:44122 }
123
124 // See comment on the member declaration.
125 const base::UnguessableToken& devtools_frame_token() const {
126 return devtools_frame_token_;
127 }
128
129 size_t child_count() const { return current_frame_host()->child_count(); }
130
danakjc492bf82020-09-09 20:02:44131 RenderFrameHostImpl* parent() const { return parent_; }
132
Dave Tapuskac8de3b02021-12-03 21:51:01133 // See `RenderFrameHost::GetParentOrOuterDocument()` for
134 // documentation.
135 RenderFrameHostImpl* GetParentOrOuterDocument();
136
137 // See `RenderFrameHostImpl::GetParentOrOuterDocumentOrEmbedder()` for
138 // documentation.
139 RenderFrameHostImpl* GetParentOrOuterDocumentOrEmbedder();
140
danakjc492bf82020-09-09 20:02:44141 FrameTreeNode* opener() const { return opener_; }
142
143 FrameTreeNode* original_opener() const { return original_opener_; }
144
Anton Bikineevf62d1bf2021-05-15 17:56:07145 const absl::optional<base::UnguessableToken>& opener_devtools_frame_token() {
Wolfgang Beyerd8809db2020-09-30 15:29:39146 return opener_devtools_frame_token_;
147 }
148
Julie Jeongeun Kimf38c1eca2021-12-14 07:46:55149 // Returns the type of the frame. Refer to frame_type.h for the details.
150 FrameType GetFrameType() const;
151
danakjc492bf82020-09-09 20:02:44152 // Assigns a new opener for this node and, if |opener| is non-null, registers
153 // an observer that will clear this node's opener if |opener| is ever
154 // destroyed.
155 void SetOpener(FrameTreeNode* opener);
156
157 // Assigns the initial opener for this node, and if |opener| is non-null,
158 // registers an observer that will clear this node's opener if |opener| is
159 // ever destroyed. The value set here is the root of the tree.
160 //
161 // It is not possible to change the opener once it was set.
162 void SetOriginalOpener(FrameTreeNode* opener);
163
Wolfgang Beyerd8809db2020-09-30 15:29:39164 // Assigns an opener frame id for this node. This string id is only set once
165 // and cannot be changed. It persists, even if the |opener| is destroyed. It
166 // is used for attribution in the DevTools frontend.
167 void SetOpenerDevtoolsFrameToken(
168 base::UnguessableToken opener_devtools_frame_token);
169
danakjc492bf82020-09-09 20:02:44170 FrameTreeNode* child_at(size_t index) const {
171 return current_frame_host()->child_at(index);
172 }
173
174 // Returns the URL of the last committed page in the current frame.
175 const GURL& current_url() const {
176 return current_frame_host()->GetLastCommittedURL();
177 }
178
Rakina Zata Amni86c88fa2021-11-01 01:27:30179 // Sets the last committed URL for this frame.
danakjc492bf82020-09-09 20:02:44180 void SetCurrentURL(const GURL& url);
181
Rakina Zata Amni86c88fa2021-11-01 01:27:30182 // The frame committed a document that is not the initial empty document.
183 // Update `has_committed_real_load_` and `is_on_initial_empty_document_`
184 // accordingly.
185 void DidCommitNonInitialEmptyDocument();
186
Rakina Zata Amni91d485b42021-12-08 02:50:13187 // Returns false if the frame has committed a document that is not the initial
Rakina Zata Amni86c88fa2021-11-01 01:27:30188 // empty document, or if the current document's input stream has been opened
189 // with document.open(), causing the document to lose its "initial empty
190 // document" status. For more details, see the definition of
191 // `is_on_initial_empty_document_`.
192 bool is_on_initial_empty_document() const {
193 return is_on_initial_empty_document_;
Rakina Zata Amnifc4cc3d42021-06-10 09:03:56194 }
195
Rakina Zata Amni86c88fa2021-11-01 01:27:30196 // Sets `is_on_initial_empty_document_` to
Rakina Zata Amnifc4cc3d42021-06-10 09:03:56197 // false. Must only be called after the current document's input stream has
198 // been opened with document.open().
Rakina Zata Amni86c88fa2021-11-01 01:27:30199 void DidOpenDocumentInputStream() { is_on_initial_empty_document_ = false; }
Rakina Zata Amnid09b6112021-06-05 06:20:14200
danakjc492bf82020-09-09 20:02:44201 // Returns whether the frame's owner element in the parent document is
202 // collapsed, that is, removed from the layout as if it did not exist, as per
203 // request by the embedder (of the content/ layer).
204 bool is_collapsed() const { return is_collapsed_; }
205
206 // Sets whether to collapse the frame's owner element in the parent document,
207 // that is, to remove it from the layout as if it did not exist, as per
208 // request by the embedder (of the content/ layer). Cannot be called for main
209 // frames.
210 //
211 // This only has an effect for <iframe> owner elements, and is a no-op when
212 // called on sub-frames hosted in <frame>, <object>, and <embed> elements.
213 void SetCollapsed(bool collapsed);
214
215 // Returns the origin of the last committed page in this frame.
216 // WARNING: To get the last committed origin for a particular
217 // RenderFrameHost, use RenderFrameHost::GetLastCommittedOrigin() instead,
218 // which will behave correctly even when the RenderFrameHost is not the
219 // current one for this frame (such as when it's pending deletion).
220 const url::Origin& current_origin() const {
Harkiran Bolaria4eacb3a2021-12-13 20:03:47221 return render_manager_.current_replication_state().origin;
danakjc492bf82020-09-09 20:02:44222 }
223
danakjc492bf82020-09-09 20:02:44224 // Set the current name and notify proxies about the update.
225 void SetFrameName(const std::string& name, const std::string& unique_name);
226
danakjc492bf82020-09-09 20:02:44227 // Returns the latest frame policy (sandbox flags and container policy) for
228 // this frame. This includes flags inherited from parent frames and the latest
229 // flags from the <iframe> element hosting this frame. The returned policies
230 // may not yet have taken effect, since "sandbox" and "allow" attribute
231 // updates in an <iframe> element take effect on next navigation. To retrieve
232 // the currently active policy for this frame, use effective_frame_policy().
233 const blink::FramePolicy& pending_frame_policy() const {
234 return pending_frame_policy_;
235 }
236
237 // Update this frame's sandbox flags and container policy. This is called
238 // when a parent frame updates the "sandbox" attribute in the <iframe> element
239 // for this frame, or any of the attributes which affect the container policy
240 // ("allowfullscreen", "allowpaymentrequest", "allow", and "src".)
241 // These policies won't take effect until next navigation. If this frame's
242 // parent is itself sandboxed, the parent's sandbox flags are combined with
243 // those in |frame_policy|.
244 // Attempting to change the container policy on the main frame will have no
245 // effect.
246 void SetPendingFramePolicy(blink::FramePolicy frame_policy);
247
248 // Returns the currently active frame policy for this frame, including the
249 // sandbox flags which were present at the time the document was loaded, and
Charlie Hu5130d25e2021-03-05 21:53:39250 // the permissions policy container policy, which is set by the iframe's
danakjc492bf82020-09-09 20:02:44251 // allowfullscreen, allowpaymentrequest, and allow attributes, along with the
252 // origin of the iframe's src attribute (which may be different from the URL
253 // of the document currently loaded into the frame). This does not include
254 // policy changes that have been made by updating the containing iframe
255 // element attributes since the frame was last navigated; use
256 // pending_frame_policy() for those.
257 const blink::FramePolicy& effective_frame_policy() const {
Harkiran Bolaria4eacb3a2021-12-13 20:03:47258 return render_manager_.current_replication_state().frame_policy;
danakjc492bf82020-09-09 20:02:44259 }
260
261 // Set the frame_policy provided in function parameter as active frame policy,
262 // while leaving pending_frame_policy_ untouched.
263 bool CommitFramePolicy(const blink::FramePolicy& frame_policy);
264
265 const blink::mojom::FrameOwnerProperties& frame_owner_properties() {
266 return frame_owner_properties_;
267 }
268
269 void set_frame_owner_properties(
270 const blink::mojom::FrameOwnerProperties& frame_owner_properties) {
271 frame_owner_properties_ = frame_owner_properties;
272 }
273
274 const network::mojom::ContentSecurityPolicy* csp_attribute() {
275 return csp_attribute_.get();
276 }
277
278 void set_csp_attribute(
279 network::mojom::ContentSecurityPolicyPtr parsed_csp_attribute) {
280 csp_attribute_ = std::move(parsed_csp_attribute);
281 }
282
Antonio Sartori5abc8de2021-07-13 08:42:47283 // Reflects the 'anonymous' attribute of the corresponding iframe html
284 // element.
285 bool anonymous() const { return anonymous_; }
286 void set_anonymous(bool anonymous) { anonymous_ = anonymous; }
287
danakjc492bf82020-09-09 20:02:44288 bool HasSameOrigin(const FrameTreeNode& node) const {
Harkiran Bolaria4eacb3a2021-12-13 20:03:47289 return render_manager_.current_replication_state().origin.IsSameOriginWith(
290 node.current_replication_state().origin);
danakjc492bf82020-09-09 20:02:44291 }
292
Gyuyoung Kimc16e52e92021-03-19 02:45:37293 const blink::mojom::FrameReplicationState& current_replication_state() const {
Harkiran Bolaria4eacb3a2021-12-13 20:03:47294 return render_manager_.current_replication_state();
danakjc492bf82020-09-09 20:02:44295 }
296
297 RenderFrameHostImpl* current_frame_host() const {
298 return render_manager_.current_frame_host();
299 }
300
danakjc492bf82020-09-09 20:02:44301 // Returns true if this node is in a loading state.
302 bool IsLoading() const;
303
Alex Moshchuk9b0fd822020-10-26 23:08:15304 // Returns true if this node has a cross-document navigation in progress.
305 bool HasPendingCrossDocumentNavigation() const;
306
danakjc492bf82020-09-09 20:02:44307 NavigationRequest* navigation_request() { return navigation_request_.get(); }
308
309 // Transfers the ownership of the NavigationRequest to |render_frame_host|.
310 // From ReadyToCommit to DidCommit, the NavigationRequest is owned by the
311 // RenderFrameHost that is committing the navigation.
312 void TransferNavigationRequestOwnership(
313 RenderFrameHostImpl* render_frame_host);
314
315 // Takes ownership of |navigation_request| and makes it the current
316 // NavigationRequest of this frame. This corresponds to the start of a new
317 // navigation. If there was an ongoing navigation request before calling this
318 // function, it is canceled. |navigation_request| should not be null.
319 void CreatedNavigationRequest(
320 std::unique_ptr<NavigationRequest> navigation_request);
321
322 // Resets the current navigation request. If |keep_state| is true, any state
323 // created by the NavigationRequest (e.g. speculative RenderFrameHost,
324 // loading state) will not be reset by the function.
325 void ResetNavigationRequest(bool keep_state);
326
327 // A RenderFrameHost in this node started loading.
Nate Chapin9aabf5f2021-11-12 00:31:19328 // |should_show_loading_ui| indicates whether this navigation should be
329 // visible in the UI. True for cross-document navigations and navigations
330 // intercepted by appHistory's transitionWhile().
danakjc492bf82020-09-09 20:02:44331 // |was_previously_loading| is false if the FrameTree was not loading before.
332 // The caller is required to provide this boolean as the delegate should only
333 // be notified if the FrameTree went from non-loading to loading state.
334 // However, when it is called, the FrameTree should be in a loading state.
Nate Chapin9aabf5f2021-11-12 00:31:19335 void DidStartLoading(bool should_show_loading_ui,
336 bool was_previously_loading);
danakjc492bf82020-09-09 20:02:44337
338 // A RenderFrameHost in this node stopped loading.
339 void DidStopLoading();
340
341 // The load progress for a RenderFrameHost in this node was updated to
342 // |load_progress|. This will notify the FrameTree which will in turn notify
343 // the WebContents.
344 void DidChangeLoadProgress(double load_progress);
345
346 // Called when the user directed the page to stop loading. Stops all loads
347 // happening in the FrameTreeNode. This method should be used with
348 // FrameTree::ForEach to stop all loads in the entire FrameTree.
349 bool StopLoading();
350
351 // Returns the time this frame was last focused.
352 base::TimeTicks last_focus_time() const { return last_focus_time_; }
353
354 // Called when this node becomes focused. Updates the node's last focused
355 // time and notifies observers.
356 void DidFocus();
357
358 // Called when the user closed the modal dialogue for BeforeUnload and
359 // cancelled the navigation. This should stop any load happening in the
360 // FrameTreeNode.
361 void BeforeUnloadCanceled();
362
363 // Returns the BlameContext associated with this node.
364 FrameTreeNodeBlameContext& blame_context() { return blame_context_; }
365
366 // Updates the user activation state in the browser frame tree and in the
367 // frame trees in all renderer processes except the renderer for this node
368 // (which initiated the update). Returns |false| if the update tries to
369 // consume an already consumed/expired transient state, |true| otherwise. See
370 // the comment on user_activation_state_ below.
371 //
372 // The |notification_type| parameter is used for histograms, only for the case
373 // |update_state == kNotifyActivation|.
374 bool UpdateUserActivationState(
375 blink::mojom::UserActivationUpdateType update_type,
376 blink::mojom::UserActivationNotificationType notification_type);
377
danakjc492bf82020-09-09 20:02:44378 // Returns the sandbox flags currently in effect for this frame. This includes
379 // flags inherited from parent frames, the currently active flags from the
380 // <iframe> element hosting this frame, as well as any flags set from a
381 // Content-Security-Policy HTTP header. This does not include flags that have
382 // have been updated in an <iframe> element but have not taken effect yet; use
383 // pending_frame_policy() for those. To see the flags which will take effect
384 // on navigation (which does not include the CSP-set flags), use
385 // effective_frame_policy().
386 network::mojom::WebSandboxFlags active_sandbox_flags() const {
Harkiran Bolaria4eacb3a2021-12-13 20:03:47387 return render_manager_.current_replication_state().active_sandbox_flags;
danakjc492bf82020-09-09 20:02:44388 }
389
390 // Updates the active sandbox flags in this frame, in response to a
391 // Content-Security-Policy header adding additional flags, in addition to
392 // those given to this frame by its parent, or in response to the
Charlie Hu5130d25e2021-03-05 21:53:39393 // Permissions-Policy header being set. Note that on navigation, these updates
danakjc492bf82020-09-09 20:02:44394 // will be cleared, and the flags in the pending frame policy will be applied
395 // to the frame.
Alexander Timin45b716c2020-11-06 01:40:31396 // Returns true iff this operation has changed state of either sandbox flags
Charlie Hu5130d25e2021-03-05 21:53:39397 // or permissions policy.
Alexander Timin45b716c2020-11-06 01:40:31398 bool UpdateFramePolicyHeaders(
danakjc492bf82020-09-09 20:02:44399 network::mojom::WebSandboxFlags sandbox_flags,
Charlie Hue24f04832021-03-04 21:07:06400 const blink::ParsedPermissionsPolicy& parsed_header);
danakjc492bf82020-09-09 20:02:44401
402 // Returns whether the frame received a user gesture on a previous navigation
403 // on the same eTLD+1.
404 bool has_received_user_gesture_before_nav() const {
Harkiran Bolaria4eacb3a2021-12-13 20:03:47405 return render_manager_.current_replication_state()
406 .has_received_user_gesture_before_nav;
danakjc492bf82020-09-09 20:02:44407 }
408
409 // When a tab is discarded, WebContents sets was_discarded on its
410 // root FrameTreeNode.
411 // In addition, when a child frame is created, this bit is passed on from
412 // parent to child.
413 // When a navigation request is created, was_discarded is passed on to the
414 // request and reset to false in FrameTreeNode.
415 void set_was_discarded() { was_discarded_ = true; }
416 bool was_discarded() const { return was_discarded_; }
417
418 // Returns the sticky bit of the User Activation v2 state of the
419 // |FrameTreeNode|.
420 bool HasStickyUserActivation() const {
421 return user_activation_state_.HasBeenActive();
422 }
423
424 // Returns the transient bit of the User Activation v2 state of the
425 // |FrameTreeNode|.
426 bool HasTransientUserActivation() {
427 return user_activation_state_.IsActive();
428 }
429
430 // Remove history entries for all frames created by script in this frame's
431 // subtree. If a frame created by a script is removed, then its history entry
432 // will never be reused - this saves memory.
433 void PruneChildFrameNavigationEntries(NavigationEntryImpl* entry);
434
Kevin McNee43fe8292021-10-04 22:59:41435 blink::FrameOwnerElementType frame_owner_element_type() const {
Daniel Cheng9bd90f92021-04-23 20:49:45436 return frame_owner_element_type_;
danakjc492bf82020-09-09 20:02:44437 }
danakjc492bf82020-09-09 20:02:44438
Daniel Cheng6ac128172021-05-25 18:49:01439 blink::mojom::TreeScopeType tree_scope_type() const {
440 return tree_scope_type_;
441 }
442
arthursonzogni034bb9c2020-10-01 08:29:56443 // The initial popup URL for new window opened using:
444 // `window.open(initial_popup_url)`.
445 // An empty GURL otherwise.
446 //
447 // [WARNING] There is no guarantee the FrameTreeNode will ever host a
448 // document served from this URL. The FrameTreeNode always starts hosting the
449 // initial empty document and attempts a navigation toward this URL. However
450 // the navigation might be delayed, redirected and even cancelled.
451 void SetInitialPopupURL(const GURL& initial_popup_url);
452 const GURL& initial_popup_url() const { return initial_popup_url_; }
453
454 // The origin of the document that used window.open() to create this frame.
455 // Otherwise, an opaque Origin with a nonce different from all previously
456 // existing Origins.
457 void SetPopupCreatorOrigin(const url::Origin& popup_creator_origin);
458 const url::Origin& popup_creator_origin() const {
459 return popup_creator_origin_;
460 }
461
Harkiran Bolaria59290d62021-03-17 01:53:01462 // Sets the associated FrameTree for this node. The node can change FrameTrees
463 // when blink::features::Prerender2 is enabled, which allows a page loaded in
464 // the prerendered FrameTree to be used for a navigation in the primary frame
465 // tree.
466 void SetFrameTree(FrameTree& frame_tree);
467
Alexander Timinf785f342021-03-18 00:00:56468 // Write a representation of this object into a trace.
Alexander Timinbebb2002021-04-20 15:42:24469 void WriteIntoTrace(perfetto::TracedValue context) const;
Rakina Zata Amni4b1968d2021-09-09 03:29:47470 void WriteIntoTrace(
471 perfetto::TracedProto<perfetto::protos::pbzero::FrameTreeNodeInfo> proto);
Alexander Timinf785f342021-03-18 00:00:56472
Carlos Caballero76711352021-03-24 17:38:21473 // Returns true the node is navigating, i.e. it has an associated
474 // NavigationRequest.
475 bool HasNavigation();
476
shivanigithubf3ddff52021-07-03 22:06:30477 // Fenced frames (meta-bug crbug.com/1111084):
shivanigithub4cd016a2021-09-20 21:10:30478 // Note that these two functions cannot be invoked from a FrameTree's or
479 // its root node's constructor since they require the frame tree and the
480 // root node to be completely constructed.
481 //
shivanigithubf3ddff52021-07-03 22:06:30482 // Returns false if fenced frames are disabled. Returns true if the feature is
483 // enabled and if |this| is a fenced frame. Returns false for
484 // iframes embedded in a fenced frame. To clarify: for the MPArch
485 // implementation this only returns true if |this| is the actual
486 // root node of the inner FrameTree and not the proxy FrameTreeNode in the
487 // outer FrameTree.
Dominic Farolino4bc10ee2021-08-31 00:37:36488 bool IsFencedFrameRoot() const;
shivanigithubf3ddff52021-07-03 22:06:30489
490 // Returns false if fenced frames are disabled. Returns true if the
491 // feature is enabled and if |this| or any of its ancestor nodes is a
492 // fenced frame.
493 bool IsInFencedFrameTree() const;
494
shivanigithub4cd016a2021-09-20 21:10:30495 // Returns a valid nonce if `IsInFencedFrameTree()` returns true for `this`.
496 // Returns nullopt otherwise. See comments on `fenced_frame_nonce_` for more
497 // details.
498 absl::optional<base::UnguessableToken> fenced_frame_nonce() {
499 return fenced_frame_nonce_;
500 }
501
502 // If applicable, set the fenced frame nonce. See comment on
503 // fenced_frame_nonce() for when it is set to a non-null value. Invoked
504 // by FrameTree::Init() or FrameTree::AddFrame().
505 void SetFencedFrameNonceIfNeeded();
506
Dave Tapuskac8de3b02021-12-03 21:51:01507 // Helper for GetParentOrOuterDocument/GetParentOrOuterDocumentOrEmbedder.
508 // Do not use directly.
509 RenderFrameHostImpl* GetParentOrOuterDocumentHelper(bool escape_guest_view);
510
Harkiran Bolariab4437fd2021-08-11 17:51:22511 // Sets the unique_name and name fields on replication_state_. To be used in
512 // prerender activation to make sure the FrameTreeNode replication state is
513 // correct after the RenderFrameHost is moved between FrameTreeNodes. The
514 // renderers should already have the correct value, so unlike
515 // FrameTreeNode::SetFrameName, we do not notify them here.
Harkiran Bolaria4eacb3a2021-12-13 20:03:47516 // TODO(https://crbug.com/1237091): Remove this once the BrowsingContextState
517 // is implemented to utilize the new path.
Harkiran Bolariab4437fd2021-08-11 17:51:22518 void set_frame_name_for_activation(const std::string& unique_name,
519 const std::string& name) {
Harkiran Bolaria4eacb3a2021-12-13 20:03:47520 render_manager_.browsing_context_state()->set_frame_name(unique_name, name);
Harkiran Bolariab4437fd2021-08-11 17:51:22521 }
522
Nan Linaaf84f72021-12-02 22:31:56523 // Returns true if error page isolation is enabled.
524 bool IsErrorPageIsolationEnabled() const;
525
danakjc492bf82020-09-09 20:02:44526 private:
Charlie Hubb5943d2021-03-09 19:46:12527 FRIEND_TEST_ALL_PREFIXES(SitePerProcessPermissionsPolicyBrowserTest,
danakjc492bf82020-09-09 20:02:44528 ContainerPolicyDynamic);
Charlie Hubb5943d2021-03-09 19:46:12529 FRIEND_TEST_ALL_PREFIXES(SitePerProcessPermissionsPolicyBrowserTest,
danakjc492bf82020-09-09 20:02:44530 ContainerPolicySandboxDynamic);
531
Dominic Farolino8a2187b2021-12-24 20:44:21532 // Called by the destructor. When `this` is an outer dummy FrameTreeNode
533 // representing an inner FrameTree, this method destroys said inner FrameTree.
534 void DestroyInnerFrameTreeIfExists();
535
danakjc492bf82020-09-09 20:02:44536 class OpenerDestroyedObserver;
537
danakjc492bf82020-09-09 20:02:44538 // The |notification_type| parameter is used for histograms only.
539 bool NotifyUserActivation(
540 blink::mojom::UserActivationNotificationType notification_type);
541
542 bool ConsumeTransientUserActivation();
543
544 bool ClearUserActivation();
545
546 // Verify that the renderer process is allowed to set user activation on this
547 // frame by checking whether this frame's RenderWidgetHost had previously seen
548 // an input event that might lead to user activation. If user activation
549 // should be allowed, this returns true and also clears corresponding pending
550 // user activation state in the widget. Otherwise, this returns false.
551 bool VerifyUserActivation();
552
553 // The next available browser-global FrameTreeNode ID.
554 static int next_frame_tree_node_id_;
555
556 // The FrameTree that owns us.
Keishi Hattori0e45c022021-11-27 09:25:52557 raw_ptr<FrameTree> frame_tree_; // not owned.
danakjc492bf82020-09-09 20:02:44558
danakjc492bf82020-09-09 20:02:44559 // A browser-global identifier for the frame in the page, which stays stable
560 // even if the frame does a cross-process navigation.
561 const int frame_tree_node_id_;
562
563 // The RenderFrameHost owning this FrameTreeNode, which cannot change for the
564 // life of this FrameTreeNode. |nullptr| if this node is the root.
Keishi Hattori0e45c022021-11-27 09:25:52565 const raw_ptr<RenderFrameHostImpl> parent_;
danakjc492bf82020-09-09 20:02:44566
danakjc492bf82020-09-09 20:02:44567 // The frame that opened this frame, if any. Will be set to null if the
568 // opener is closed, or if this frame disowns its opener by setting its
569 // window.opener to null.
Keishi Hattori0e45c022021-11-27 09:25:52570 raw_ptr<FrameTreeNode> opener_ = nullptr;
danakjc492bf82020-09-09 20:02:44571
572 // An observer that clears this node's |opener_| if the opener is destroyed.
573 // This observer is added to the |opener_|'s observer list when the |opener_|
574 // is set to a non-null node, and it is removed from that list when |opener_|
575 // changes or when this node is destroyed. It is also cleared if |opener_|
576 // is disowned.
577 std::unique_ptr<OpenerDestroyedObserver> opener_observer_;
578
579 // The frame that opened this frame, if any. Contrary to opener_, this
580 // cannot be changed unless the original opener is destroyed.
Keishi Hattori0e45c022021-11-27 09:25:52581 raw_ptr<FrameTreeNode> original_opener_ = nullptr;
danakjc492bf82020-09-09 20:02:44582
Wolfgang Beyerd8809db2020-09-30 15:29:39583 // The devtools frame token of the frame which opened this frame. This is
584 // not cleared even if the opener is destroyed or disowns the frame.
Anton Bikineevf62d1bf2021-05-15 17:56:07585 absl::optional<base::UnguessableToken> opener_devtools_frame_token_;
Wolfgang Beyerd8809db2020-09-30 15:29:39586
danakjc492bf82020-09-09 20:02:44587 // An observer that clears this node's |original_opener_| if the opener is
588 // destroyed.
589 std::unique_ptr<OpenerDestroyedObserver> original_opener_observer_;
590
arthursonzogni034bb9c2020-10-01 08:29:56591 // When created by an opener, the URL specified in window.open(url)
592 // Please refer to {Get,Set}InitialPopupURL() documentation.
593 GURL initial_popup_url_;
594
595 // When created using window.open, the origin of the creator.
596 // Please refer to {Get,Set}PopupCreatorOrigin() documentation.
597 url::Origin popup_creator_origin_;
598
Rakina Zata Amni86c88fa2021-11-01 01:27:30599 // Whether this frame is still on the initial about:blank document or the
600 // synchronously committed about:blank document committed at frame creation,
601 // and its "initial empty document"-ness is still true.
602 // This will be false if either of these has happened:
603 // - SetCurrentUrl() was called after committing a document that is not the
604 // initial about:blank document or the synchronously committed about:blank
605 // document, per
606 // https://html.spec.whatwg.org/multipage/browsers.html#creating-browsing-contexts:is-initial-about:blank
607 // - The document's input stream has been opened with document.open(), per
608 // https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#opening-the-input-stream:is-initial-about:blank
609 // NOTE: we treat both the "initial about:blank document" and the
610 // "synchronously committed about:blank document" as the initial empty
611 // document. In the future, we plan to remove the synchronous about:blank
612 // commit so that this state will only be true if the frame is on the
613 // "initial about:blank document". See also:
614 // - https://github.com/whatwg/html/issues/6863
615 // - https://crbug.com/1215096
616 bool is_on_initial_empty_document_ = true;
Rakina Zata Amnifc4cc3d42021-06-10 09:03:56617
danakjc492bf82020-09-09 20:02:44618 // Whether the frame's owner element in the parent document is collapsed.
arthursonzogni9816b9192021-03-29 16:09:19619 bool is_collapsed_ = false;
danakjc492bf82020-09-09 20:02:44620
Daniel Cheng6ac128172021-05-25 18:49:01621 // The type of frame owner for this frame. This is only relevant for non-main
622 // frames.
Kevin McNee43fe8292021-10-04 22:59:41623 const blink::FrameOwnerElementType frame_owner_element_type_ =
624 blink::FrameOwnerElementType::kNone;
Daniel Cheng9bd90f92021-04-23 20:49:45625
Daniel Cheng6ac128172021-05-25 18:49:01626 // The tree scope type of frame owner element, i.e. whether the element is in
627 // the document tree (https://dom.spec.whatwg.org/#document-trees) or the
628 // shadow tree (https://dom.spec.whatwg.org/#shadow-trees). This is only
629 // relevant for non-main frames.
630 const blink::mojom::TreeScopeType tree_scope_type_ =
631 blink::mojom::TreeScopeType::kDocument;
632
danakjc492bf82020-09-09 20:02:44633 // Track the pending sandbox flags and container policy for this frame. When a
634 // parent frame dynamically updates 'sandbox', 'allow', 'allowfullscreen',
635 // 'allowpaymentrequest' or 'src' attributes, the updated policy for the frame
Harkiran Bolaria4eacb3a2021-12-13 20:03:47636 // is stored here, and transferred into
637 // render_manager_.current_replication_state().frame_policy when they take
638 // effect on the next frame navigation.
danakjc492bf82020-09-09 20:02:44639 blink::FramePolicy pending_frame_policy_;
640
641 // Whether the frame was created by javascript. This is useful to prune
642 // history entries when the frame is removed (because frames created by
643 // scripts are never recreated with the same unique name - see
644 // https://crbug.com/500260).
arthursonzogni9816b9192021-03-29 16:09:19645 const bool is_created_by_script_;
danakjc492bf82020-09-09 20:02:44646
647 // Used for devtools instrumentation and trace-ability. The token is
648 // propagated to Blink's LocalFrame and both Blink and content/
649 // can tag calls and requests with this token in order to attribute them
650 // to the context frame.
651 // |devtools_frame_token_| is only defined by the browser process and is never
652 // sent back from the renderer in the control calls. It should be never used
653 // to look up the FrameTreeNode instance.
arthursonzogni9816b9192021-03-29 16:09:19654 const base::UnguessableToken devtools_frame_token_;
danakjc492bf82020-09-09 20:02:44655
656 // Tracks the scrolling and margin properties for this frame. These
657 // properties affect the child renderer but are stored on its parent's
658 // frame element. When this frame's parent dynamically updates these
659 // properties, we update them here too.
660 //
661 // Note that dynamic updates only take effect on the next frame navigation.
662 blink::mojom::FrameOwnerProperties frame_owner_properties_;
663
664 // Contains the current parsed value of the 'csp' attribute of this frame.
665 network::mojom::ContentSecurityPolicyPtr csp_attribute_;
666
Antonio Sartori5abc8de2021-07-13 08:42:47667 // Reflects the 'anonymous' attribute of the corresponding iframe html
668 // element.
669 bool anonymous_ = false;
670
danakjc492bf82020-09-09 20:02:44671 // Owns an ongoing NavigationRequest until it is ready to commit. It will then
672 // be reset and a RenderFrameHost will be responsible for the navigation.
673 std::unique_ptr<NavigationRequest> navigation_request_;
674
675 // List of objects observing this FrameTreeNode.
676 base::ObserverList<Observer>::Unchecked observers_;
677
678 base::TimeTicks last_focus_time_;
679
arthursonzogni9816b9192021-03-29 16:09:19680 bool was_discarded_ = false;
danakjc492bf82020-09-09 20:02:44681
682 // The user activation state of the current frame. See |UserActivationState|
683 // for details on how this state is maintained.
684 blink::UserActivationState user_activation_state_;
685
686 // A helper for tracing the snapshots of this FrameTreeNode and attributing
687 // browser process activities to this node (when possible). It is unrelated
688 // to the core logic of FrameTreeNode.
689 FrameTreeNodeBlameContext blame_context_;
690
shivanigithub4cd016a2021-09-20 21:10:30691 // Fenced Frames:
692 // Nonce used in the net::IsolationInfo and blink::StorageKey for a fenced
693 // frame and any iframes nested within it. Not set if this frame is not in a
694 // fenced frame's FrameTree. Note that this could be a field in FrameTree for
695 // the MPArch version but for the shadow DOM version we need to keep it here
696 // since the fenced frame root is not a main frame for the latter. The value
697 // of the nonce will be the same for all of the the frames inside a fenced
698 // frame tree. If there is a nested fenced frame it will have a different
699 // nonce than its parent fenced frame. The nonce will stay the same across
700 // navigations because it is always used in conjunction with other fields of
701 // the keys. If the navigation is same-origin/site then the same network stack
702 // partition/storage will be reused and if it's cross-origin/site then other
703 // parts of the key will change and so, even with the same nonce, another
704 // partition will be used.
705 absl::optional<base::UnguessableToken> fenced_frame_nonce_;
706
Lukasz Anforowicz147141962020-12-16 18:03:24707 // Manages creation and swapping of RenderFrameHosts for this frame.
708 //
709 // This field needs to be declared last, because destruction of
710 // RenderFrameHostManager may call arbitrary callbacks (e.g. via
711 // WebContentsObserver::DidFinishNavigation fired after RenderFrameHostManager
712 // destructs a RenderFrameHostImpl and its NavigationRequest). Such callbacks
713 // may try to use FrameTreeNode's fields above - this would be an undefined
714 // behavior if the fields (even trivially-destructible ones) were destructed
715 // before the RenderFrameHostManager's destructor runs. See also
716 // https://crbug.com/1157988.
717 RenderFrameHostManager render_manager_;
danakjc492bf82020-09-09 20:02:44718};
719
720} // namespace content
721
722#endif // CONTENT_BROWSER_RENDERER_HOST_FRAME_TREE_NODE_H_