Experimental Chromium Web Platform Features

The prototype implementation (which was shipped in 2020 and then shape-changed in 2023) contained a method called `getInnerHTML()` that could be used to serialize DOM trees containing shadow roots. That part of the prototype was not standardized with the rest of declarative shadow dom, and only recently has it reached spec consensus (https://github.com/whatwg/html/issues/8867). As part of that consensus, the shape of the getInnerHTML API changed. This feature represents the desire to ship the new, agreed-upon shape, which is: - getHTML({serializableShadowRoots:bool, shadowRoots:[roots]}).

The prior behavior caused issues if a top layer element (dialog, fullscreen, etc.) was DOM-nested within a popover. The inner element, when promoted to the top layer, would cause the outer popover to be hidden, which also (via CSS display:none) hid the inner element. That, in turn, caused issues at least for dialogs, which inert the entire page. This change makes top layer elements "nestable" within popovers.

This enables individual control over whether a shadow root is clonable (via standard platform cloning commands such as `cloneNode()`). Imperative shadow roots can now be controlled via a parameter to `attachShadow({clonable:true})`. Declarative shadow roots can be controlled via a new attribute, `<template shadowrootmode=open shadowrootclonable>`.

Functionality added to the WebGPU spec after its first shipment in a browser. ServiceWorker and SharedWorker support is added to WebGPU, aligning with existing WebGL capabilities.

UAs are starting to provide writing suggestions to users as they type on various editable fields across the web. While this is generally useful for users, there are cases when developers may want to turn off UA-provided writing assistance, such as extensions or sites that wish to provide similar functionality on their own. To that end, developers need a solution that would turn on/off UA-provided writing assistance. The new attribute 'writingsuggestions' has values 'true'/'false' that would allow developers to turn on/off browser-provided writing suggestions. The attribute's state for an element can also be inherited from ancestor elements, thereby allowing developers to control this functionality at a per-element or per-document/sub-document scale.

CSS property writing-mode allow elements to go vertical, but users cannot set the direction in which value changes. With this feature, we are allowing the form control elements meter, progress and range input type to have vertical writing mode and choose the form control's value direction. If direction is rtl, the value is rendered from bottom to top. If direction is ltr, the value is rendered from top to bottom. For Web compatibility, we plan to slowly rollout the change in 123 and enable in stable in 124.

Improves accessibility by making scroll containers focusable using sequential focus navigation. Today, the tab key doesn't focus scrollers unless tabIndex is explicitly set to 0 or more. By making scrollers focusable by default, users who can't (or don't want to) use a mouse will be able to focus clipped content using a keyboard's tab and arrow keys. This behavior is enabled only if the scroller does not contain any keyboard focusable children. This logic is necessary so we don't cause regressions for existing focusable elements that might exist within a scroller like a <textarea>.

This is about adding support in Chrome for the VoiceIsolation getUserMedia constraint (https://w3c.github.io/mediacapture-extensions/#voiceisolation-constraint). The constraint only takes effect on platforms where there is low-level support for voice-isolation style denoising. Currently this is limited to a selected number of ChromeOS devices, but further platforms will be added.

Allows <button> and <datalist> in <selectlist> which replace the default button and listbox respectively, as well as introducing a new <selectedoption> element that shows the chosen value.

This feature allows web developers to create WebAuthn[0] credentials (that is, "publickey" credentials, aka passkeys) in cross-origin iframes. Two conditions are required for this new ability: 1. The iframe has a publickey-credentials-create-feature permission policy. 2. The iframe has transient user activation. This will allow developers to create passkeys in embedded scenarios, such as after an identity step-up flow where the Relying Party is providing a federated identity experience. [0]: https://w3c.github.io/webauthn/

`align-content` CSS property works for block containers and table cells. The property worked only for flex containers and grid containers. It supports block containers and table cells, that is to say `display: block`, `display: list-item`, `display: table-cell`, etc.

Auto Sizes allows developers to set the sizes attribute to auto (sizes=auto) for lazy loaded image elements with srcset. For this use case the image's width and height should be provided. The browser will use the layout width of the image in order to select the source url from the srcset.

After an event target gets removed from the DOM, the logical target of the pointer as implied by the Pointer and Mouse boundary events (i.e. over, out, enter and leave events) should be the nearest ancestor still attached to the DOM. PEWG has recently reached consensus on this behavior, see https://github.com/web-platform-tests/interop/issues/380. Chrome has been keeping track of a node even after it gets removed from DOM. As a result, if the pointer moves to a new node B after the hit-test node A is removed from DOM, the boundary event sequence (pointerover, pointerout, pointerenter, pointerleave events and the corresponding mouse events) used to imply a pointer movement from A to B. As per the new consensus, the event sequence should imply a pointer movement from the "parent of A" to B.

"Close requests" are a new concept that encompasses user requests to close something currently open, using the Esc key on desktop or the back gesture/button on Android. Integrating them into Chromium comes with two changes: * CloseWatcher, a new API for directly listening and responding to close requests. * Upgrades to <dialog> and popover="" to use the new close request framework, so that they respond to the Android back button.

It allows to import stylesheets and layers conditioned on supports(). If the support() doesn't match, the import will not be fetched.

Canceling mousemove will not prevent text selection or drag-and-drop. Chrome allowed cancelling mousemove events to prevent other APIs like text selection (and even drag-and-drop in the past). This does not match other major browsers; nor does it conform to the UI Event spec: https://w3c.github.io/uievents/#event-type-mousemove Through this feature, text selection will no longer be the default-action of mousemove. Text selection and drag-and-drop can still be prevented through cancelling selectstart and dragstart events respectively, which are spec compliant and fully interoperable.

navigation.activation stores state about when the current Document was activated (e.g., when it was initialized, or restored from the back/forward cache).

We propose to block access to IP address 0.0.0.0. Chrome is deprecating direct access to private network endpoints from public websites as part of the Private Network Access (PNA) specification (https://developer.chrome.com/blog/private-network-access-preflight/). Services listening on the localhost (127.0.0.0/8) are considered private according to the specification (https://wicg.github.io/private-network-access/#ip-address-space-heading). Chrome's PNA protection can be bypassed using the IP address 0.0.0.0 to access services listening on the localhost on macOS and Linux. This can also be abused in DNS rebinding attacks targeting a web application listening on the localhost.

Enables trusted applications to bypass security restrictions in the WebUSB API. The WebUSB specification defines a blocklist of vulnerable devices and a table of protected interfaces classes that are blocked from access through WebUSB. With this feature, Isolated Web Apps with permission to access the "usb-unrestricted" Permission Policy feature will be allowed to access blocklisted devices and protected interface classes.

Allows easy inspection of whether a URLPattern uses one or more ECMAScript regular expression groups, and therefore may not be suitable for use in cases where an ECMAScript engine is not available (such as some upcoming planned APIs). Strictly speaking this reflects back something developers could know anyway from inspecting the pattern, but having easy access to the UA's implementation of this check makes that more straightforward.

The Web Preference API aims to provide a way for sites to override the value for a given user preference (e.g. color-scheme preference) in a way that fully integrates with existing Web APIs.