Experimental Chromium Web Platform Features

Provide a new HTML element that interacts with the permission flow. The permission prompt is currently triggered directly from JS without the user agent having any strong signal of the user's intent. Having an in-content element that the user uses to trigger the permission flow allows for improved permission prompt UX for users as well as a recovery path from the "denied" permission state for sites. Explainer: https://github.com/WICG/PEPC/blob/main/explainer.md Instructions: https://github.com/WICG/PEPC/blob/main/HOWTO.md

Introduces a new violation type called "Potential Permissions Policy violation", which will only look at Permissions Policy (including report-only policy) and the allow attribute set in iframes to detect the conflict between Permissions Policy enforced vs permissions propagated to iframes.

Chromium supports animation of the caret-color property, but when animated the default blinking behavior of the caret interferes with the animation. For instance, see the example at https://drafts.csswg.org/css-ui/#caret-animation where an animation from blue to red and back is rendered as a blinking cursor that is randomly blue or red. The CSS caret-animation property has two possible values: auto and manual, where auto means browser default (blinking) and manual means the page author is controlling the caret animation. In addition, via a user stylesheet, it allows users who are disturbed by or have adverse reactions to blinking or flashing visuals to disable the blinking.

shape() allows responsive free-form shapes in clip-path. The author can define a series of verbs, roughly equivalent to the verbs in path(), but where the verbs accept responsive units (e.g. % or vw), as well as any CSS values such as custom properties or rather than pixel-values. See https://drafts.csswg.org/css-shapes-2/#shape-function

Expose "paintTime" and "presentationTime" in event timing, element timing, LCP, long animation frames, paint timing. "paintTime" means the time when the rendering phase ended and the browser started the paint phase. "presentationTime" means the time when the "pixels reached the screen", which is somewhat implementation-defined

Extends the use of the "opener" rel type to same-window navigations to signal to the browser that the destination page will open a new window and the referring page expects to be able to access it. Some user agents perform browsing context group changes on navigation that aren't strictly necessary for security in order to improve performance. This results in named window reuse not being possible across a back navigation. Annotating an anchor element with "opener" will signal to the user agent that performing a browsing context group change would break a future opener relationship.

The ClipboardItem, which is the input to the async clipboard write method, now accepts string values in addition to Blobs in its constructor. ClipboardItemData can be a Blob, a string, or a Promise that resolves to either a Blob or a string.

The interactivity property specifies whether an element and its flat tree descendants (including text runs) are inert or not. Making an element inert affects whether it can be focused, edited, selected, and searchable by find-in-page. It also affects whether it is visible in the accessibility tree. The syntax is: interactivity: auto | inert

Allows to style pseudo elements that are nested inside other pseudo elements. So far, support is defined for: ::before::marker ::after::marker With ::column::scroll-marker being supported in the future.

Document-Isolation-Policy allows a document to enable crossOriginIsolation for itself, without having to deploy COOP or COEP, and regardless of the crossOriginIsolation status of the page. The policy is backed by process isolation. Additionally, the document non-CORS cross-origin subresources will either be loaded without credentials or will need to have a CORP header.

One of the nice features of the Popover API is its light dismiss behavior. This chromestatus is about bringing that same capability to `<dialog>`. A new `closedby` attribute controls behavior: `<dialog closedby=none>` - no user-triggered closing of dialogs at all. `<dialog closedby=closerequest>` - user pressing ESC (or other close trigger) closes the dialog `<dialog closedby=any>` - user clicking outside the dialog, or pressing ESC, closes the dialog. Akin to `popover=auto` behavior.

getAllRecords() combines getAllKeys() with getAll() to enumerate both primary keys and values at the same time. For an IDBIndex, getAllRecords() also provides the record's index key in addition to the primary key and value. Lastly, getAllRecords() offers a new direction option to enumerate records sorted by key in descending order. This proposal adds getAllRecords() to both IDBObjectStore and IDBIndex. getAllRecords() creates a new IDBRequest that queries its IDBObjectStore or IDBIndex owner. The IDBRequest completes with an array of IDBRecord results. Each IDBRecord contains the key, primaryKey and value attributes. For IDBIndex, key is the record's index key. For IDBObjectStore, both key and primaryKey return the same value. The pre-existing IDBCursorWithValue interface contains the same attributes and values for both IDBObjectStore and IDBIndex. However, unlike getAllRecords(), a cursor may only read one record at a time.

A keyword for CSS sizing properties (e.g. 'width', 'height') that allows elements to grow to exactly fill their containing block's available space. It is similar to '100%', except the resulting size is applied to the element's margin box instead of the box indicated by 'box-sizing'. Using this keyword allows the element to keep its margins while still being as large as possible. An unprefixed version of '-webkit-fill-available'.

Import maps currently have to load before any ES module and there can only be a single import map per document. That makes them fragile and potentially slow to use in real-life scenarios: Any module that loads before them breaks the entire app, and in apps with many modules the become a large blocking resource, as the entire map for all possible modules needs to load first. This feature is to enable multiple import maps per document, by merging them in a consistent and deterministic way.

Web applications may suffer from bimodal distribution in page load performance, due to factors outside of the web application’s control. For example: * When a user agent first launches (a "cold start" scenario), it must perform many expensive initialization tasks that compete for resources on the system. * Browser extensions can affect the performance of a website. For instance, some extensions run additional code on every page you visit, which can increase CPU usage and result in slower response times. * When a machine is busy performing intensive tasks, it can lead to slower loading of web pages. In these scenarios, content the web app attempts to load will be in competition with other work happening on the system. This makes it difficult to detect if performance issues exist within web applications themselves, or because of external factors. Teams we have worked with have been surprised at the difference between real-world dashboard metrics and what they observe in page profiling tools. Without more information, it is challenging for developers to understand if (and when) their applications may be misbehaving or are simply being loaded in a contended period. A new ‘confidence’ field on the PerformanceNavigationTiming object will enable developers to discern if the navigation timings are representative for their web application.

Resource timing: - responseStart returns the first response, either early hints (interim) or final - Expose the final response headers (2xx/4xx/5xx) time as finalResponseHeadersStart.

A shadow host with delegatesFocus set to true will delegate its focus to its first focusable child. On a mouse click event, the child will receive focus and the event will be marked as handled. No further event dispatching is done. This is a problem because the steps to handle text selection afterward are not ran and the selection does not recognize the focused element as part of the selection. We fix this by continuing event handling even after an element was delegate focused and update how selection recognizes having focus in a shadow tree.

Adds an "overallProgress" property to the JavaScript class Animation[1]. This property provides authors with a convenient and consistent representation of how far along an animation has advanced across its iterations and regardless of the nature of its timeline[2]. [1] https://developer.mozilla.org/en-US/docs/Web/API/Animation [2] https://developer.mozilla.org/en-US/docs/Web/API/AnimationTimeline

Allow anchor-size() values for inset and margin properties. Originally, anchor-size() was only allowed in sizing properties. The specification was changed to allow anchor-size() in insets and margins as well.

This change makes the HTML parser allow additional tags in <select> besides <option>, <optgroup>, and <hr>. This change is in support of the customizable <select> feature but is being shipped first because it can be done separately and has some compat risk which I'd like to get feedback on. This feature is gated by the temporary policy (SelectParserRelaxationEnabled). This is a temporary transition period, and the policy will stop working on milestone M141. Customizable select explainer: https://open-ui.org/components/customizableselect/ I did a compat analysis and determined that the vast majority of sites which would see the effects of the parser changes would not have their behavior changed. More details here: https://github.com/whatwg/html/issues/10310 If there are major issues with this change, I will reassess and make adjustments to the parser as needed.

It is useful for web authors do determine when their <dialog> elements open and close. popover already has `ToggleEvent` which is dispatched when a popover opens or closes, but <dialog> does not. The current way to detect when a <dialog> opens is to register a mutation observer to check for open, however, this is quite a lot of work where an event would be easier. This change incorporates the same `ToggleEvent`s that popovers dispatch, but for `<dialog>` elements: when `showModal` or `show` is called, <dialog> dispatches a ToggleEvent with newState=open. When a dialog is closed (via form or button or closewatcher) it should dispatch a ToggleEvent with newState=closed.

Add a bytes() method to the Request and Response interfaces, which returns a promise that resolves with a Uint8Array. While Request and Response have an arrayBuffer() method, we can't read directly from a buffer. We have to create a view such as a Uint8Array to read it. The bytes() method improves the ergonomics of getting the body of Request and Response.

The Rust font stack for Chrome integrates the Fontations font libraries into Chromium as a safe replacement for FreeType (https://github.com/googlefonts/fontations/). This project is a collaboration between Chrome and Google Fonts. By replacing FreeType we make font processing in Chrome safer and more reliable and move from a C codebase to a modern set of efficient and ergonomic Rust libraries for font processing in Chrome. We reduce the engineering time needed to keep FreeType secure and spend less time having to address incoming issues found by Fuzzers. We open up the possibility of unsandboxing font processing code. We move to relying on a shared codebase for font processing in Chrome and font production in Google Fonts. Internal document: http://go/rust-fontstack-chrome

Reference Target is a feature to enable using IDREF attributes such as `for` and `aria-labelledby` to refer to elements inside a component's shadow DOM, while maintaining encapsulation of the internal details of the shadow DOM. The main goal of this feature is to enable ARIA to work across shadow root boundaries. A component can specify an element in its shadow tree to act as its "reference target". When the host component is the target of a IDREF like a label's `for` attribute, the reference target becomes the effective target of the label. The shadow root specifies the ID of the target element inside the shadow DOM. This is done either in JavaScript with the `referenceTarget` attribute on the `ShadowRoot` object, or in HTML markup using the `shadowrootreferencetarget` attribute on the `<template>` element.