Presentation API

Controlling user agents MUST implement the following partial interface:

WebIDLpartial interface Presentation {
  attribute PresentationRequest? defaultRequest;
};

The defaultRequest attribute MUST return the default presentation request if any, null otherwise. On setting, the default presentation request MUST be set to the new value.

The controlling user agent SHOULD initiate presentation using the default presentation request only when the user has expressed an intention to do so via a user gesture, for example by clicking a button in the browser chrome.

To initiate presentation using the default presentation request, the controlling user agent MUST follow the steps to start a presentation from a default presentation request.

Support for initiating a presentation using the default presentation request is OPTIONAL.

Receiving user agents MUST implement the following partial interface:

WebIDLpartial interface Presentation {
  readonly attribute PresentationReceiver? receiver;
};

The receiver attribute MUST return the PresentationReceiver instance associated with the receiving browsing context and created by the receiving user agent when the receiving browsing context is created. In any other browsing context (including child navigables of the receiving browsing context) it MUST return null.

When the PresentationRequest constructor is called, the controlling user agent MUST run these steps:

Input

url or urls, the presentation request URLs

Output

A PresentationRequest object

1. If the document object's active sandboxing flag set has the sandboxed presentation browsing context flag set, then throw a SecurityError and abort these steps.
2. If urls is an empty sequence, then throw a NotSupportedError and abort all remaining steps.
3. If a single url was provided, let urls be a one item array containing url.
4. Let presentationUrls be an empty list of URLs.
5. For each URL U in urls:
   1. Let A be an absolute URL that is the result of parsing U relative to the API base URL specified by the current settings object.
   2. If the parse a URL algorithm failed, then throw a SyntaxError exception and abort all remaining steps.
   3. If A's scheme is supported by the controlling user agent, add A to presentationUrls.
6. If presentationUrls is an empty list, then throw a NotSupportedError and abort all remaining steps.
7. If any member of presentationUrls is not a potentially trustworthy URL, then throw a SecurityError and abort these steps.
8. Construct a new PresentationRequest object with presentationUrls as its presentation request URLs and return it.

When the start method is called, the user agent MUST run the following steps to select a presentation display.

Input

presentationRequest, the PresentationRequest object that received the call to start

Output

A Promise

1. If the document's active window does not have transient activation, return a Promise rejected with an InvalidAccessError exception and abort these steps.
2. Let topContext be the top-level browsing context of the controlling browsing context.
3. If there is already an unsettled Promise from a previous call to start in topContext or any browsing context in the descendant navigables of topContext, return a new Promise rejected with an OperationError exception and abort all remaining steps.
4. Let P be a new Promise.
5. Return P, but continue running these steps in parallel.
6. If the user agent is not monitoring the list of available presentation displays, run the steps to monitor the list of available presentation displays in parallel.
7. Let presentationUrls be the presentation request URLs of presentationRequest.
8. Request user permission for the use of a presentation display and selection of one presentation display.
9. If either of the following is true:
   1. The list of available presentation displays is empty and will remain so before the request for user permission is completed.
   2. No member in the list of available presentation displays is an available presentation display for any member of presentationUrls.
   Then run the following steps:
   1. Reject P with a NotFoundError exception.
   2. Abort all remaining steps.
10. If the user denies permission to use a display, reject P with an NotAllowedError exception, and abort all remaining steps.
11. Otherwise, the user grants permission to use a display; let D be that display.
12. Run the steps to start a presentation connection with presentationRequest, D, and P.

When the user expresses an intent to start presentation of a document on a presentation display using the browser chrome (via a dedicated button, user gesture, or other signal), that user agent MUST run the following steps to start a presentation from a default presentation request. If no default presentation request is set on the document, these steps MUST not be run.

Input

W, the document on which the user has expressed an intent to start presentation

presentationRequest, the non-null value of navigator.presentation.defaultRequest set on W

D, the presentation display that is the target for presentation

1. Let presentationUrls be the presentation request URLs of presentationRequest.
2. If there is no presentation request URL for presentationRequest for which D is an available presentation display, then abort these steps.
3. Run the steps to start a presentation connection with presentationRequest and D.

When the user agent is to start a presentation connection, it MUST run the following steps:

Input

presentationRequest, the PresentationRequest that is used to start the presentation connection

D, the selected presentation display

P, an optional Promise that will be resolved with a new presentation connection

1. Let I be a new valid presentation identifier unique among all presentation identifiers for known presentation connections in the set of controlled presentations. To avoid fingerprinting, implementations SHOULD set the presentation identifier to a UUID generated by following forms 4.4 or 4.5 of [rfc4122].
2. Create a new PresentationConnection S.
3. Set the presentation identifier of S to I.
4. Let presentationUrls be the presentation request URLs of presentationRequest.
5. Set the presentation URL for S to the first presentationUrl in presentationUrls for which there exists an entry (presentationUrl, D) in the list of available presentation displays.
6. Set the presentation connection state of S to connecting.
7. Add S to the set of controlled presentations.
8. If P is provided, resolve P with S.
9. Queue a task to fire an event named connectionavailable, that uses the PresentationConnectionAvailableEvent interface, with the connection attribute initialized to S, at presentationRequest. The event must not bubble and must not be cancelable.
10. Let U be the user agent connected to D.
11. If the next step fails, abort all remaining steps and close the presentation connection S with error as closeReason, and a human readable message describing the failure as closeMessage.
12. Using an implementation specific mechanism, tell U to create a receiving browsing context with D, presentationUrl, and I as parameters.
13. Establish a presentation connection with S.

When the reconnect method is called, the user agent MUST run the following steps to reconnect to a presentation:

Input

presentationRequest, the PresentationRequest object that reconnect was called on

presentationId, a valid presentation identifier

Output

P, a Promise

1. Let P be a new Promise.
2. Return P, but continue running these steps in parallel.
3. Search the set of controlled presentations for a PresentationConnection that meets the following criteria:
   • Its controlling browsing context is the current browsing context
   • Its presentation connection state is not terminated
   • Its presentation URL is equal to one of the presentation request URLs of presentationRequest
   • Its presentation identifier is equal to presentationId
4. If such a PresentationConnection exists, run the following steps:
   1. Let existingConnection be that PresentationConnection.
   2. Resolve P with existingConnection.
   3. If the presentation connection state of existingConnection is connecting or connected, then abort all remaining steps.
   4. Set the presentation connection state of existingConnection to connecting.
   5. Establish a presentation connection with existingConnection.
   6. Abort all remaining steps.
5. Search the set of controlled presentations for the first PresentationConnection that meets the following criteria:
   • Its controlling browsing context is not the current browsing context
   • Its presentation connection state is not terminated
   • Its presentation URL is equal to one of the presentation request URLs of presentationRequest
   • Its presentation identifier is equal to presentationId
6. If such a PresentationConnection exists, run the following steps:
   1. Let existingConnection be that PresentationConnection.
   2. Create a new PresentationConnection newConnection.
   3. Set the presentation identifier of newConnection to presentationId.
   4. Set the presentation URL of newConnection to the presentation URL of existingConnection.
   5. Set the presentation connection state of newConnection to connecting.
   6. Add newConnection to the set of controlled presentations.
   7. Resolve P with newConnection.
   8. Queue a task to fire an event named connectionavailable, that uses the PresentationConnectionAvailableEvent interface, with the connection attribute initialized to newConnection, at presentationRequest. The event must not bubble and must not be cancelable.
   9. Establish a presentation connection with newConnection.
   10. Abort all remaining steps.
7. Reject P with a NotFoundError exception.

The following are the event handlers (and their corresponding event handler event types) that must be supported, as event handler IDL attributes, by objects implementing the PresentationRequest interface:

The user agent MUST keep track of the set of presentation availability objects created by the getAvailability method. The set of presentation availability objects is represented as a set of tuples (A, availabilityUrls), initially empty, where:

1. A is a live PresentationAvailability object.
2. availabilityUrls is the list of presentation request URLs for the PresentationRequest when getAvailability was called on it to create A.

The user agent MUST keep a list of available presentation displays. The list of available presentation displays is represented by a list of tuples (availabilityUrl, display). An entry in this list means that display is currently an available presentation display for availabilityUrl. This list of presentation displays may be used for starting new presentations, and is populated based on an implementation specific discovery mechanism. It is set to the most recent result of the algorithm to monitor the list of available presentation displays.

While the set of presentation availability objects is not empty, the user agent MAY monitor the list of available presentation displays continuously, so that pages can use the value property of a PresentationAvailability object to offer presentation only when there are available displays. However, the user agent may not support continuous availability monitoring in the background; for example, because of platform or power consumption restrictions. In this case the Promise returned by getAvailability is rejected, and the algorithm to monitor the list of available presentation displays will only run as part of the select a presentation display algorithm.

When the set of presentation availability objects is empty (that is, there are no availabilityUrls being monitored), user agents SHOULD NOT monitor the list of available presentation displays to satisfy the power saving non-functional requirement. To further save power, the user agent MAY also keep track of whether a page holding a PresentationAvailability object is in the foreground. Using this information, implementation specific discovery of presentation displays can be resumed or suspended.

When the getAvailability method is called, the user agent MUST run the following steps:

Input

presentationRequest, the PresentationRequest object that received the call to getAvailability

Output

A Promise

1. If there is an unsettled Promise from a previous call to getAvailability on presentationRequest, return that Promise and abort these steps.
2. Otherwise, let P be a new Promise constructed in the JavaScript realm of presentationRequest.
3. Return P, but continue running these steps in parallel.
4. If the user agent is unable to continuously monitor the list of available presentation displays in the background, but can later find presentation displays in order to start a connection, then:
   1. Reject P with a NotSupportedError exception.
   2. Abort all the remaining steps.
5. If the presentation display availability for presentationRequest is not null, then:
   1. Resolve P with the request's presentation display availability.
   2. Abort all the remaining steps.
6. Set the presentation display availability for presentationRequest to a newly created PresentationAvailability object constructed in the JavaScript realm of presentationRequest, and let A be that object.
7. Create a tuple (A, presentationUrls) and add it to the set of presentation availability objects.
8. Run the algorithm to monitor the list of available presentation displays.
   Note

   The monitoring algorithm must be run at least one more time after the previous step to pick up the tuple that was added to the set of presentation availability objects.
9. Resolve P with A.

If the set of presentation availability objects is non-empty, or there is a pending request to select a presentation display, the user agent MUST monitor the list of available presentation displays by running the following steps:

1. Let availabilitySet be a shallow copy of the set of presentation availability objects.
2. If there is a pending request to select a presentation display for a PresentationRequest and if the PresentationRequest's presentation display availability is null, then run the following substeps:
   1. Let A be a newly created PresentationAvailability object.
   2. Create a tuple (A, presentationUrls) where presentationUrls is the PresentationRequest's presentation request URLs and add it to availabilitySet.
3. Let newDisplays be an empty list.
4. If the user agent is unable to retrieve presentation displays (e.g., because the user has disabled this capability), then skip the following step.
5. Retrieve presentation displays (using an implementation specific mechanism) and set newDisplays to this list.
6. Set the list of available presentation displays to the empty list.
7. For each member (A, availabilityUrls) of availabilitySet, run the following steps:
   1. Set previousAvailability to the value of A's value property.
   2. Let newAvailability be false.
   3. For each availabilityUrl in availabilityUrls, run the following step:
      1. For each display in newDisplays, if display is an available presentation display for availabilityUrl, then run the following steps:
         1. Insert a tuple (availabilityUrl, display) into the list of available presentation displays, if no identical tuple already exists.
         2. Set newAvailability to true.
   4. If A's value property has not yet been initialized, then set A's value property to newAvailability and skip the following step.
   5. If previousAvailability is not equal to newAvailability, then queue a task to run the following steps:
      1. Set A's value property to newAvailability.
      2. Fire an event named change at A.

When a presentation display availability object is eligible for garbage collection, the user agent SHOULD run the following steps:

1. Let A be the newly deceased PresentationAvailability object
2. Find and remove any entry (A, availabilityUrl) in the set of presentation availability objects.
3. If the set of presentation availability objects is now empty and there is no pending request to select a presentation display, cancel any pending task to monitor the list of available presentation displays for power saving purposes, and set the list of available presentation displays to the empty list.

WebIDL[SecureContext, Exposed=Window]
interface PresentationConnectionAvailableEvent : Event {
  constructor(DOMString type, PresentationConnectionAvailableEventInit eventInitDict);
  [SameObject] readonly attribute PresentationConnection connection;
};
dictionary PresentationConnectionAvailableEventInit : EventInit {
  required PresentationConnection connection;
};

A controlling user agent fires an event named connectionavailable on a PresentationRequest when a connection associated with the object is created. It is fired at the PresentationRequest instance, using the PresentationConnectionAvailableEvent interface, with the connection attribute set to the PresentationConnection object that was created. The event is fired for each connection that is created for the controller, either by the controller calling start or reconnect, or by the controlling user agent creating a connection on the controller's behalf via defaultRequest.

A receiving user agent fires an event named connectionavailable on a PresentationReceiver when an incoming connection is created. It is fired at the presentation controllers monitor, using the PresentationConnectionAvailableEvent interface, with the connection attribute set to the PresentationConnection object that was created. The event is fired for all connections that are created when monitoring incoming presentation connections.

The connection attribute MUST return the value it was set to when the PresentationConnection object was created.

When the PresentationConnectionAvailableEvent constructor is called, the user agent MUST construct a new PresentationConnectionAvailableEvent object with its connection attribute set to the connection member of the PresentationConnectionAvailableEventInit object passed to the constructor.

When the user agent is to establish a presentation connection using a presentation connection, it MUST run the following steps:

Input

presentationConnection, the PresentationConnection object that is to be connected

1. If the presentation connection state of presentationConnection is not connecting, then abort all remaining steps.
2. Request connection of presentationConnection to the receiving browsing context. The presentation identifier of presentationConnection MUST be sent with this request.
3. If connection completes successfully, queue a task to run the following steps:
   1. Set the presentation connection state of presentationConnection to connected.
   2. Fire an event named connect at presentationConnection.
4. If the connection cannot be completed, close the presentation connection S with error as closeReason, and a human readable message describing the failure as closeMessage.

Let presentation message data be the payload data to be transmitted between two browsing contexts. Let presentation message type be the type of that data, one of text or binary.

When the user agent is to send a message through a presentation connection, it MUST run the following steps:

Input

presentationConnection, the presentation connection connected to the other browsing context

messageOrData, the presentation message data to send to the other browsing context

1. If the state property of presentationConnection is not connected, throw an InvalidStateError exception.
2. If the closing procedure of presentationConnection has started, then abort these steps.
3. Let presentation message type messageType be binary if messageOrData is of type ArrayBuffer, ArrayBufferView, or Blob. Let messageType be text if messageOrData is of type DOMString.
4. Using an implementation specific mechanism, transmit the contents of messageOrData as the presentation message data and messageType as the presentation message type to the destination browsing context.
5. If the previous step encounters an unrecoverable error, then abruptly close the presentation connection presentationConnection with error as closeReason, and a closeMessage describing the error encountered.

When the user agent has received a transmission from the remote side consisting of presentation message data and presentation message type, it MUST run the following steps to receive a message through a PresentationConnection:

Input

presentationConnection, the presentation connection receiving the message

messageType, the presentation message type of the message

messageData, the presentation message data of the message

1. If the state property of presentationConnection is not connected, abort these steps.
2. Let event be the result of creating an event using the MessageEvent interface, with the event type message, which does not bubble and is not cancelable.
3. Initialize the event's data attribute as follows:
   1. If messageType is text, then initialize event's data attribute to messageData with type DOMString.
   2. If messageType is binary, and binaryType attribute is set to "blob", then initialize event's data attribute to a new Blob object with messageData as its raw data.
   3. If messageType is binary, and binaryType attribute is set to "arraybuffer", then initialize event's data attribute to a new ArrayBuffer object whose contents are messageData.
4. Queue a task to fire event at presentationConnection.

If the user agent encounters an unrecoverable error while receiving a message through presentationConnection, it MUST abruptly close the presentation connection presentationConnection with error as closeReason. It SHOULD use a human readable description of the error encountered as closeMessage.

WebIDLenum PresentationConnectionCloseReason { "error", "closed", "wentaway" };
[SecureContext, Exposed=Window]
interface PresentationConnectionCloseEvent : Event {
  constructor(DOMString type, PresentationConnectionCloseEventInit eventInitDict);
  readonly attribute PresentationConnectionCloseReason reason;
  readonly attribute DOMString message;
};
dictionary PresentationConnectionCloseEventInit : EventInit {
  required PresentationConnectionCloseReason reason;
  DOMString message = "";
};

A PresentationConnectionCloseEvent is fired when a presentation connection enters a closed state. The reason attribute provides the reason why the connection was closed. It can take one of the values of PresentationConnectionCloseReason:

• error means that the mechanism for connecting or communicating with a presentation entered an unrecoverable error.
• closed means that either the controlling browsing context or the receiving browsing context that were connected by the PresentationConnection called close().
• wentaway means that the browser closed the connection, for example, because the browsing context that owned the connection navigated or was discarded.

When the reason attribute is error, the user agent SHOULD set the message attribute to a human readable description of how the communication channel encountered an error.

When the PresentationConnectionCloseEvent constructor is called, the user agent MUST construct a new PresentationConnectionCloseEvent object, with its reason attribute set to the reason member of the PresentationConnectionCloseEventInit object passed to the constructor, and its message attribute set to the message member of this PresentationConnectionCloseEventInit object if set, to an empty string otherwise.

When the user agent is to start closing a presentation connection, it MUST do the following:

Input

presentationConnection, the presentation connection to be closed

closeReason, the PresentationConnectionCloseReason describing why the connection is to be closed

closeMessage, a human-readable message with details of why the connection was closed

1. If the presentation connection state of presentationConnection is not connecting or connected then abort the remaining steps.
2. Set the presentation connection state of presentationConnection to closed.
3. Start to signal to the destination browsing context the intention to close the corresponding PresentationConnection, passing the closeReason to that context. The user agent does not need to wait for acknowledgement that the corresponding PresentationConnection was actually closed before proceeding to the next step.
4. If closeReason is not wentaway, then locally run the steps to close the presentation connection with presentationConnection, closeReason, and closeMessage.

When the user agent is to close a presentation connection, it MUST do the following:

Input

presentationConnection, the presentation connection to be closed

closeReason, the PresentationConnectionCloseReason describing why the connection is to be closed

closeMessage, a human-readable message with details of why the connection was closed.

1. If there is a pending close the presentation connection task for presentationConnection, or a close the presentation connection task has already run for presentationConnection, then abort the remaining steps.
2. Queue a task to run the following steps:
   1. If the presentation connection state of presentationConnection is not connecting, connected, or closed, then abort the remaining steps.
   2. If the presentation connection state of presentationConnection is not closed, set it to closed.
   3. If the presentationConnection was created as a result of monitoring incoming presentation connections in a receiving browsing context, run the following sub-steps.
      1. Remove presentationConnection from the set of presentation controllers.
      2. Populate the presentation controllers monitor with the set of presentation controllers.
   4. Fire an event named close, that uses the PresentationConnectionCloseEvent interface, with the reason attribute initialized to closeReason and the message attribute initialized to closeMessage, at presentationConnection. The event must not bubble and must not be cancelable.

When a controlling user agent is to terminate a presentation in a controlling browsing context using connection, it MUST run the following steps:

1. If the presentation connection state of connection is not connected or connecting, then abort these steps.
2. Otherwise, for each known connection in the set of controlled presentations in the controlling user agent:
   1. If the presentation identifier of known connection and connection are equal, and the presentation connection state of known connection is connected or connecting, then queue a task to run the following steps:
      1. Set the presentation connection state of known connection to terminated.
      2. Fire an event named terminate at known connection.
3. Send a termination request for the presentation to its receiving user agent using an implementation specific mechanism.

When any of the following occur, the receiving user agent MUST terminate a presentation in a receiving browsing context:

1. The receiving user agent is to unload a document corresponding to the receiving browsing context, e.g. in response to a request to navigate that context to a new resource.
2. The user requests to terminate the presentation via the receiving user agent.
   Note

   This could happen by an explicit user action, or as a policy of the user agent. For example, the receiving user agent could be configured to terminate presentations whose PresentationConnection objects are all closed for 30 minutes.

3. A controlling user agent sends a termination request to the receiving user agent for that presentation.

When a receiving user agent is to terminate a presentation in a receiving browsing context, it MUST run the following steps:

1. Let P be the presentation to be terminated, let allControllers be the set of presentation controllers that were created for P, and connectedControllers an empty list.
2. For each connection in allControllers, run the following steps:
   1. If the presentation connection state of connection is connected, then add connection to connectedControllers.
   2. Set the presentation connection state of connection to terminated.
3. If there is a receiving browsing context for P, and it has a document for P that is not unloaded, unload a document corresponding to that browsing context, remove that browsing context from the user interface and discard it.
4. For each connection in connectedControllers, queue a task to send a termination confirmation for P using an implementation specific mechanism to the controlling user agent that owns the destination browsing context for connection.
   Note

   Only one termination confirmation needs to be sent per controlling user agent.

When a receiving user agent is to send a termination confirmation for a presentation P, and that confirmation was received by a controlling user agent, the controlling user agent MUST run the following steps:

1. For each connection in the set of controlled presentations that was connected to P, queue a task to run the following steps:
   1. If the presentation connection state of connection is not connected or connecting, then abort the following steps.
   2. Set the presentation connection state of connection to terminated.
   3. Fire an event named terminate at connection.

The following are the event handlers (and their corresponding event handler event types) that must be supported, as event handler IDL attributes, by objects implementing the PresentationConnection interface:

When the user agent is to create a receiving browsing context, it MUST run the following steps:

Input

D, a presentation display chosen by the user

presentationUrl, the presentation request URL

presentationId, the presentation identifier

1. Create a new top-level browsing context C, set to display content on D.
2. Set the session history of C to be the empty list.
3. Set the sandboxed modals flag and the sandboxed auxiliary navigation browsing context flag on C.
4. If the receiving user agent implements [PERMISSIONS], set the permission state of all permission descriptor types for C to "denied".
5. Create a new empty cookie store for C.
6. Create a new empty store for C to hold HTTP authentication states.
7. Create a new empty storage for session storage areas and local storage areas for C.
8. If the receiving user agent implements [INDEXEDDB], create a new empty storage for IndexedDB databases for C.
9. If the receiving user agent implements [SERVICE-WORKERS], create a new empty list of registered service worker registrations and a new empty set of Cache objects for C.
10. Navigate C to presentationUrl.
11. Start monitoring incoming presentation connections for C with presentationId and presentationUrl.

All child navigables created by the presented document, i.e. that have the receiving browsing context as their top-level browsing context, MUST also have restrictions 2-4 above. In addition, they MUST have the sandboxed top-level navigation without user activation browsing context flag set. All of these browsing contexts MUST also share the same browsing state (storage) for features 5-10 listed above.

When the top-level browsing context attempts to navigate to a new resource and runs the steps to navigate, it MUST follow step 1 to determine if it is allowed to navigate. In addition, it MUST NOT be allowed to navigate itself to a new resource, except by navigating to a fragment identifier or by reloading its document.

If the top-level-browsing context was not allowed to navigate, it SHOULD NOT offer to open the resource in a new top-level browsing context, but otherwise SHOULD be consistent with the steps to navigate.

Window clients and worker clients associated with the receiving browsing context and its descendant navigables must not be exposed to service workers associated with each other.

When the receiving browsing context is terminated, any service workers associated with it and the browsing contexts in its descendant navigables MUST be unregistered and terminated. Any browsing state associated with the receiving browsing context and the browsing contexts in its descendant navigables, including session history, the cookie store, any HTTP authentication state, any databases, the session storage areas, the local storage areas, the list of registered service worker registrations and the Cache objects MUST be discarded and not used for any other browsing context.

The receiving user agent SHOULD fetch resources in a receiving browsing context with an HTTP Accept-Language header that reflects the language preferences of the controlling user agent (i.e., with the same Accept-Language that the controlling user agent would have sent). This will help the receiving user agent render the presentation with fonts and locale-specific attributes that reflect the user's preferences.

When the receiving user agent is to start monitoring incoming presentation connections in a receiving browsing context from controlling browsing contexts, it MUST listen to and accept incoming connection requests from a controlling browsing context using an implementation specific mechanism. When a new connection request is received from a controlling browsing context, the receiving user agent MUST run the following steps:

Input

I, the presentation identifier passed by the controlling browsing context with the incoming connection request

presentationId, the presentation identifier used to create the receiving browsing context

presentationUrl, the presentation request URL used to create the receiving browsing context

1. If presentationId and I are not equal, refuse the connection and abort all remaining steps.
2. Create a new PresentationConnection S.
3. Set the presentation identifier of S to I.
4. Set the presentation URL of S to presentationUrl.
5. Establish the connection between the controlling and receiving browsing contexts using an implementation specific mechanism.
6. If connection establishment completes successfully, set the presentation connection state of S to connected. Otherwise, set the presentation connection state of S to closed and abort all remaining steps.
7. Add S to the set of presentation controllers.
8. If the presentation controllers monitor is null, run the following steps in parallel.
   1. Let the presentation controllers monitor be a new PresentationConnectionList constructed in the JavaScript realm of the PresentationReceiver object of the receiving browsing context.
   2. Populate the presentation controllers monitor with the set of presentation controllers.
   3. If the presentation controllers promise is not null, resolve the presentation controllers promise with the presentation controllers monitor.
   4. Abort all remaining steps.
9. Otherwise, run the following steps in parallel.
   1. Populate the presentation controllers monitor with the set of presentation controllers.
   2. Queue a task to fire an event named connectionavailable, that uses the PresentationConnectionAvailableEvent interface, with the connection attribute initialized to S, at the presentation controllers monitor. The event must not bubble and must not be cancelable.

The following are the event handlers (and their corresponding event handler event types) that must be supported, as event handler IDL attributes, by objects implementing the PresentationConnectionList interface: