Attachment 399644 Details for Bug 211888 – Patch

[patch] Patch

bug-211888-20200518161734.patch (text/plain), 54.22 KB, created by Sergio Villar Senin on 2020-05-18 07:17:36 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Sergio Villar Senin

Created: 2020-05-18 07:17:36 PDT

Size: 54.22 KB

patch

obsolete

>Subversion Revision: 261690
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 0e86b6611c1e373c8afb3db66b2ad781969ad70e..959f682fc8cb00aadb895b879c5f00633b6597af 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,65 @@
>+2020-05-14  Sergio Villar Senin  <svillar@igalia.com>
>+
>+        [WebXR] Implement requestSession()
>+        https://bugs.webkit.org/show_bug.cgi?id=211888
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This patch adds a preliminar implementation of the requestSession()
>+        API used to get a WebXRSession from the UA. It includes a fairly good
>+        amount of checks to verify that the request can be satisfied given the
>+        device's enabled features per session modes. The specs also describe how
>+        to request persmission for some actions using the Permissions API which
>+        WebKit does not currently implement. That should be done in a follow up
>+        patch perhaps using a similar approach to other APIs as Geolocation for
>+        example.
>+
>+        In order to get some of the requestSession() tests passing the session
>+        finalization (shutdown) had to be implemented too.
>+
>+        Several tests where unskipped for WPE port as they're now passing.
>+
>+        * Modules/webxr/WebXRRenderState.cpp:
>+        (WebCore::WebXRRenderState::create): Pass XRSessionMode as argument
>+        instead of a WebXRSession.
>+        * Modules/webxr/WebXRRenderState.h: Ditto.
>+        * Modules/webxr/WebXRSession.cpp:
>+        (WebCore::WebXRSession::create): Added.
>+        (WebCore::WebXRSession::WebXRSession): Added.
>+        (WebCore::WebXRSession::renderState const):
>+        (WebCore::WebXRSession::inputSources const):
>+        (WebCore::WebXRSession::shutdown): Shutdown process called on session end.
>+        (WebCore::WebXRSession::end): Implemented session ending.
>+        * Modules/webxr/WebXRSession.h: Added create() and private constructor. Fixed some naming.
>+        * Modules/webxr/WebXRSystem.cpp:
>+        (WebCore::WebXRSystem::DummyInlineDevice::DummyInlineDevice): Contructor for the
>+        dummy inline device.
>+        (WebCore::WebXRSystem::ensureImmersiveXRDeviceIsSelected): Use a counter instead of a boolean
>+        to track testing devices as there might be more than 1.
>+        (WebCore::WebXRSystem::obtainCurrentDevice): Implemented from specs text.
>+        (WebCore::WebXRSystem::immersiveSessionRequestIsAllowedForGlobalObject const): Ditto.
>+        (WebCore::WebXRSystem::inlineSessionRequestIsAllowedForGlobalObject const): Ditto.
>+        (WebCore::WebXRSystem::resolveRequestedFeatures const): Ditto.
>+        (WebCore::WebXRSystem::isXRPermissionGranted const): Ditto.
>+        (WebCore::WebXRSystem::requestSession): Ditto.
>+        (WebCore::WebXRSystem::registerSimulatedXRDeviceForTesting): Use a counter instead of a bool.
>+        (WebCore::WebXRSystem::unregisterSimulatedXRDeviceForTesting): Ditto.
>+        (WebCore::WebXRSystem::sessionEnded): Added, used by sessions to notify the XRSystem.
>+        * Modules/webxr/WebXRSystem.h:
>+        * Modules/webxr/WebXRSystem.idl: Call requestSession with Document.
>+        * dom/TaskSource.h: Added a WebXR task source.
>+        * platform/xr/PlatformXR.h: Specs state that devices have a list of enabled features per session
>+        mode so store them in a hashmap instead of in a Vector.
>+        (PlatformXR::Device::supports const): Use the new Hashmap of session modes.
>+        (PlatformXR::Device::setEnabledFeatures): Ditto.
>+        (PlatformXR::Device::enabledFeatures const): Ditto.
>+        (PlatformXR::Device::setSupportedModes): Deleted.
>+        * platform/xr/openxr/PlatformXR.cpp:
>+        (PlatformXR::Instance::Impl::collectSupportedSessionModes): Return session modes if any.
>+        (PlatformXR::Instance::enumerateImmersiveXRDevices): Fill in features per session mode.
>+        * testing/WebXRTest.cpp:
>+        (WebCore::WebXRTest::simulateDeviceConnection): Fill in features per session mode.
>+
> 2020-05-14  Sergio Villar Senin  <svillar@igalia.com>
> 
>         Unreviewed build fix.
>diff --git a/Source/WebCore/Modules/webxr/WebXRInputSourceArray.h b/Source/WebCore/Modules/webxr/WebXRInputSourceArray.h
>index f421f029e64cb08a2bb9b6a65685da0d5987d025..5458b3579001e7aeeb44cf86cd081cdf03b2ba0c 100644
>--- a/Source/WebCore/Modules/webxr/WebXRInputSourceArray.h
>+++ b/Source/WebCore/Modules/webxr/WebXRInputSourceArray.h
>@@ -39,6 +39,9 @@ class WebXRInputSourceArray : public RefCounted<WebXRInputSourceArray> {
> public:
>     unsigned length() const;
>     WebXRInputSource* item(unsigned) const;
>+
>+private:
>+    WebXRInputSourceArray();
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/Modules/webxr/WebXRRenderState.cpp b/Source/WebCore/Modules/webxr/WebXRRenderState.cpp
>index 06789f819271e91565269da3f3b961d33d9976ae..c0f895b2b1c59676bdcf5835c08f4bb06e0847c0 100644
>--- a/Source/WebCore/Modules/webxr/WebXRRenderState.cpp
>+++ b/Source/WebCore/Modules/webxr/WebXRRenderState.cpp
>@@ -37,26 +37,11 @@ namespace WebCore {
> 
> WTF_MAKE_ISO_ALLOCATED_IMPL(WebXRRenderState);
> 
>-Ref<WebXRRenderState> WebXRRenderState::create(const WebXRSession& session)
>+Ref<WebXRRenderState> WebXRRenderState::create(XRSessionMode mode)
> {
>-    // When an XRRenderState object is created for an XRSession session, the user agent MUST initialize the render state by running the following steps:
>-    //   1. Let state be the newly created XRRenderState object.
>-
>-    //   2. Initialize stateâs depthNear to 0.1.
>-    //   3. Initialize stateâs depthFar to 1000.0.
>-    // (Default-initialized in the XRRenderState class definition.)
>-
>-    //   4. If session is an immersive session, initialize stateâs inlineVerticalFieldOfView to null.
>-    //   5. Else initialize stateâs inlineVerticalFieldOfView to PI * 0.5.
>-    // FIXME: "immersive session" support
>-    UNUSED_PARAM(session);
>-    Optional<double> inlineVerticalFieldOfView { piOverTwoDouble };
>-
>-    //   6. Initialize stateâs baseLayer to null.
>-    //   7. Initialize stateâs outputContext to null.
>-    // (Initialized to null by default.)
>-
>-    return adoptRef(*new WebXRRenderState(WTFMove(inlineVerticalFieldOfView)));
>+    // https://immersive-web.github.io/webxr/#initialize-the-render-state
>+    // depthNear, depthFar and baseLayer are initialized in the class definition
>+    return adoptRef(*new WebXRRenderState(mode == XRSessionMode::Inline ? makeOptional(piOverTwoDouble) : WTF::nullopt));
> }
> 
> WebXRRenderState::WebXRRenderState(Optional<double>&& inlineVerticalFieldOfView)
>diff --git a/Source/WebCore/Modules/webxr/WebXRRenderState.h b/Source/WebCore/Modules/webxr/WebXRRenderState.h
>index 3f292ac1d681a469876018189a87a96f1edbac7d..95e9656b122bb33ac4c689e0aa82076ef47c8ce2 100644
>--- a/Source/WebCore/Modules/webxr/WebXRRenderState.h
>+++ b/Source/WebCore/Modules/webxr/WebXRRenderState.h
>@@ -27,6 +27,7 @@
> 
> #if ENABLE(WEBXR)
> 
>+#include "XRSessionMode.h"
> #include <wtf/IsoMalloc.h>
> #include <wtf/Optional.h>
> #include <wtf/Ref.h>
>@@ -37,12 +38,11 @@ namespace WebCore {
> 
> class WebXRWebGLLayer;
> struct XRRenderStateInit;
>-class WebXRSession;
> 
> class WebXRRenderState : public RefCounted<WebXRRenderState> {
>     WTF_MAKE_ISO_ALLOCATED(WebXRRenderState);
> public:
>-    static Ref<WebXRRenderState> create(const WebXRSession&);
>+    static Ref<WebXRRenderState> create(XRSessionMode);
>     ~WebXRRenderState();
> 
>     double depthNear() const;
>@@ -51,14 +51,15 @@ public:
>     RefPtr<WebXRWebGLLayer> baseLayer() const;
> 
> private:
>-    WebXRRenderState(Optional<double>&&);
>-    WebXRRenderState(const XRRenderStateInit&);
>+    explicit WebXRRenderState(Optional<double>&& fieldOfView);
>+    explicit WebXRRenderState(const XRRenderStateInit&);
> 
>+    // https://immersive-web.github.io/webxr/#initialize-the-render-state
>     struct {
>-        double near { 0.1 };
>-        double far { 1000 };
>+        double near { 0.1 }; // in meters
>+        double far { 1000 }; // in meters
>     } m_depth;
>-    Optional<double> m_inlineVerticalFieldOfView;
>+    Optional<double> m_inlineVerticalFieldOfView; // in radians
>     RefPtr<WebXRWebGLLayer> m_baseLayer;
> };
> 
>diff --git a/Source/WebCore/Modules/webxr/WebXRSession.cpp b/Source/WebCore/Modules/webxr/WebXRSession.cpp
>index ed3562f2e3f6c8d88943b09138f7668702157a2f..a4358372d79196cfda5b6262925d661eff27b083 100644
>--- a/Source/WebCore/Modules/webxr/WebXRSession.cpp
>+++ b/Source/WebCore/Modules/webxr/WebXRSession.cpp
>@@ -28,12 +28,31 @@
> 
> #if ENABLE(WEBXR)
> 
>+#include "WebXRSystem.h"
> #include <wtf/IsoMallocInlines.h>
> 
> namespace WebCore {
> 
> WTF_MAKE_ISO_ALLOCATED_IMPL(WebXRSession);
> 
>+Ref<WebXRSession> WebXRSession::create(Document& document, Ref<WebXRSystem>&& system, XRSessionMode mode, WeakPtr<PlatformXR::Device>&& device)
>+{
>+    return adoptRef(*new WebXRSession(document, WTFMove(system), mode, WTFMove(device)));
>+}
>+
>+WebXRSession::WebXRSession(Document& document, Ref<WebXRSystem>&& system, XRSessionMode mode, WeakPtr<PlatformXR::Device>&& device)
>+    : ActiveDOMObject(&document)
>+    , m_xrSystem(WTFMove(system))
>+    , m_mode(mode)
>+    , m_device(WTFMove(device))
>+    , m_activeRenderState(WebXRRenderState::create(mode))
>+{
>+    // TODO: If no other features of the user agent have done so already,
>+    // perform the necessary platform-specific steps to initialize the deviceâs
>+    // tracking and rendering capabilities, including showing any necessary
>+    // instructions to the user.
>+}
>+
> WebXRSession::~WebXRSession() = default;
> 
> XREnvironmentBlendMode WebXRSession::environmentBlendMode() const
>@@ -48,7 +67,7 @@ XRVisibilityState WebXRSession::visibilityState() const
> 
> const WebXRRenderState& WebXRSession::renderState() const
> {
>-    return *m_renderState;
>+    return *m_activeRenderState;
> }
> 
> const WebXRInputSourceArray& WebXRSession::inputSources() const
>@@ -73,8 +92,41 @@ void WebXRSession::cancelAnimationFrame(int)
> {
> }
> 
>-void WebXRSession::end(EndPromise&&)
>+// https://immersive-web.github.io/webxr/#shut-down-the-session
>+void WebXRSession::shutdown()
>+{
>+    // 1. Let session be the target XRSession object.
>+    // 2. Set session's ended value to true.
>+    m_ended = true;
>+
>+    // 3. If the active immersive session is equal to session, set the active immersive session to null.
>+    // 4. Remove session from the list of inline sessions.
>+    m_xrSystem->sessionEnded(this);
>+
>+    // TODO: complete the implementation
>+    // 5. Reject any outstanding promises returned by session with an InvalidStateError, except for any promises returned by end().
>+    // 6. If no other features of the user agent are actively using them, perform the necessary platform-specific steps to shut down the device's tracking and rendering capabilities. This MUST include:
>+    //  6.1. Releasing exclusive access to the XR device if session is an immersive session.
>+    //  6.2. Deallocating any graphics resources acquired by session for presentation to the XR device.
>+    //  6.3. Putting the XR device in a state such that a different source may be able to initiate a session with the same device if session is an immersive session.
>+    // 7. Queue a task that fires an XRSessionEvent named end on session.
>+}
>+
>+// https://immersive-web.github.io/webxr/#dom-xrsession-end
>+void WebXRSession::end(EndPromise&& promise)
> {
>+    // 1. Let promise be a new Promise.
>+    // 2. Shut down the target XRSession object.
>+    shutdown();
>+
>+    // 3. Queue a task to perform the following steps:
>+    queueTaskKeepingObjectAlive(*this, TaskSource::WebXR, [promise = WTFMove(promise)] () mutable {
>+        // 3.1 Wait until any platform-specific steps related to shutting down the session have completed.
>+        // 3.2 Resolve promise.
>+        promise.resolve();
>+    });
>+
>+    // 4. Return promise.
> }
> 
> const char* WebXRSession::activeDOMObjectName() const
>diff --git a/Source/WebCore/Modules/webxr/WebXRSession.h b/Source/WebCore/Modules/webxr/WebXRSession.h
>index f01150197b670de732e96f0e07b7c6960350eac4..8932a91274e6d0bd6bde6432635adc524376a54e 100644
>--- a/Source/WebCore/Modules/webxr/WebXRSession.h
>+++ b/Source/WebCore/Modules/webxr/WebXRSession.h
>@@ -35,6 +35,7 @@
> #include "WebXRSpace.h"
> #include "XREnvironmentBlendMode.h"
> #include "XRReferenceSpaceType.h"
>+#include "XRSessionMode.h"
> #include "XRVisibilityState.h"
> #include <wtf/Ref.h>
> #include <wtf/RefCounted.h>
>@@ -45,6 +46,7 @@ namespace WebCore {
> 
> class XRFrameRequestCallback;
> class WebXRReferenceSpace;
>+class WebXRSystem;
> struct XRRenderStateInit;
> 
> class WebXRSession final : public RefCounted<WebXRSession>, public EventTargetWithInlineData, public ActiveDOMObject {
>@@ -53,6 +55,7 @@ public:
>     using RequestReferenceSpacePromise = DOMPromiseDeferred<IDLInterface<WebXRReferenceSpace>>;
>     using EndPromise = DOMPromiseDeferred<void>;
> 
>+    static Ref<WebXRSession> create(Document&, Ref<WebXRSystem>&&, XRSessionMode, WeakPtr<PlatformXR::Device>&&);
>     virtual ~WebXRSession();
> 
>     using RefCounted<WebXRSession>::ref;
>@@ -74,6 +77,8 @@ public:
>     bool ended() const { return m_ended; }
> 
> private:
>+    WebXRSession(Document&, Ref<WebXRSystem>&&, XRSessionMode, WeakPtr<PlatformXR::Device>&&);
>+
>     // EventTarget
>     EventTargetInterface eventTargetInterface() const override { return WebXRSessionEventTargetInterfaceType; }
>     ScriptExecutionContext* scriptExecutionContext() const override { return ActiveDOMObject::scriptExecutionContext(); }
>@@ -84,11 +89,18 @@ private:
>     const char* activeDOMObjectName() const override;
>     void stop() override;
> 
>+    void shutdown();
>+
>     XREnvironmentBlendMode m_environmentBlendMode;
>     XRVisibilityState m_visibilityState;
>-    RefPtr<WebXRRenderState> m_renderState;
>     RefPtr<WebXRInputSourceArray> m_inputSources;
>     bool m_ended { false };
>+
>+    Ref<WebXRSystem> m_xrSystem;
>+    XRSessionMode m_mode;
>+    WeakPtr<PlatformXR::Device> m_device;
>+    RefPtr<WebXRRenderState> m_activeRenderState;
>+    RefPtr<WebXRRenderState> m_pendingRenderState;
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/Modules/webxr/WebXRSystem.cpp b/Source/WebCore/Modules/webxr/WebXRSystem.cpp
>index 98422ec0d9f4a14d05beb6a2fc3d8f025db368e5..10d01ab5bafbfd054414c1896e9a477a65dd0b92 100644
>--- a/Source/WebCore/Modules/webxr/WebXRSystem.cpp
>+++ b/Source/WebCore/Modules/webxr/WebXRSystem.cpp
>@@ -28,17 +28,32 @@
> 
> #if ENABLE(WEBXR)
> 
>+#include "DOMWindow.h"
> #include "Document.h"
> #include "FeaturePolicy.h"
>+#include "IDLTypes.h"
>+#include "JSWebXRSession.h"
>+#include "JSXRReferenceSpaceType.h"
> #include "PlatformXR.h"
> #include "RuntimeEnabledFeatures.h"
>+#include "SecurityOrigin.h"
>+#include "UserGestureIndicator.h"
> #include "WebXRSession.h"
>+#include "XRReferenceSpaceType.h"
>+#include "XRSessionInit.h"
>+#include <JavaScriptCore/JSGlobalObject.h>
> #include <wtf/IsoMallocInlines.h>
>+#include <wtf/Scope.h>
> 
> namespace WebCore {
> 
> WTF_MAKE_ISO_ALLOCATED_IMPL(WebXRSystem);
> 
>+WebXRSystem::DummyInlineDevice::DummyInlineDevice()
>+{
>+    setEnabledFeatures(XRSessionMode::Inline, { XRReferenceSpaceType::Viewer });
>+}
>+
> Ref<WebXRSystem> WebXRSystem::create(ScriptExecutionContext& scriptExecutionContext)
> {
>     return adoptRef(*new WebXRSystem(scriptExecutionContext));
>@@ -56,8 +71,7 @@ WebXRSystem::~WebXRSystem() = default;
> void WebXRSystem::ensureImmersiveXRDeviceIsSelected()
> {
>     // Don't ask platform code for XR devices, we're using simulated ones.
>-    // TODO: should be have a MockPlatformXR implementation instead ?
>-    if (UNLIKELY(m_testingMode))
>+    if (UNLIKELY(m_testingDevices))
>         return;
> 
>     if (m_activeImmersiveDevice)
>@@ -96,6 +110,20 @@ void WebXRSystem::ensureImmersiveXRDeviceIsSelected()
>     // TODO: 9. Queue a task to fire an event named devicechange on the context object.
> }
> 
>+
>+PlatformXR::Device* WebXRSystem::obtainCurrentDevice(XRSessionMode mode, const JSFeaturesArray& requiredFeatures, const JSFeaturesArray& optionalFeatures)
>+{
>+    if (mode == XRSessionMode::ImmersiveAr || mode == XRSessionMode::ImmersiveVr) {
>+        ensureImmersiveXRDeviceIsSelected();
>+        return m_activeImmersiveDevice.get();
>+    }
>+    if (!requiredFeatures.isEmpty() || !optionalFeatures.isEmpty())
>+        return m_inlineXRDevice.get();
>+
>+    return &m_defaultInlineDevice;
>+}
>+
>+
> // https://immersive-web.github.io/webxr/#dom-xrsystem-issessionsupported
> void WebXRSystem::isSessionSupported(XRSessionMode mode, IsSessionSupportedPromise&& promise)
> {
>@@ -106,7 +134,7 @@ void WebXRSystem::isSessionSupported(XRSessionMode mode, IsSessionSupportedPromi
>         return;
>     }
> 
>-    // 3. If the requesting documentâs origin is not allowed to use the "xr-spatial-tracking" feature policy,
>+    // 3. If the requesting document's origin is not allowed to use the "xr-spatial-tracking" feature policy,
>     //    reject promise with a "SecurityError" DOMException and return it.
>     auto document = downcast<Document>(scriptExecutionContext());
>     if (!isFeaturePolicyAllowedByDocumentAndAllOwners(FeaturePolicy::Type::XRSpatialTracking, *document, LogFeaturePolicyFailure::Yes)) {
>@@ -136,26 +164,269 @@ void WebXRSystem::isSessionSupported(XRSessionMode mode, IsSessionSupportedPromi
>     });
> }
> 
>-void WebXRSystem::requestSession(XRSessionMode, const XRSessionInit&, RequestSessionPromise&&)
>+// https://immersive-web.github.io/webxr/#immersive-session-request-is-allowed
>+bool WebXRSystem::immersiveSessionRequestIsAllowedForGlobalObject(DOMWindow& globalObject, Document& document) const
>+{
>+    // 1. If the request was not made while the global object has transient
>+    //    activation or when launching a web application, return false
>+    // TODO: add a check for "not launching a web application".
>+    if (!globalObject.hasTransientActivation())
>+        return false;
>+
>+    // 2. If the requesting document is not considered trustworthy, return false.
>+    // https://immersive-web.github.io/webxr/#trustworthy.
>+    if (&document != globalObject.document())
>+        return false;
>+
>+    // https://immersive-web.github.io/webxr/#active-and-focused
>+    if (!document.hasFocus() || !document.securityOrigin().isSameOriginAs(globalObject.document()->securityOrigin()))
>+        return false;
>+
>+    // 3. If user intent to begin an immersive session is not well understood,
>+    //    either via explicit consent or implicit consent, return false
>+    if (!UserGestureIndicator::processingUserGesture())
>+        return false;
>+
>+    return true;
>+}
>+
>+// https://immersive-web.github.io/webxr/#inline-session-request-is-allowed
>+bool WebXRSystem::inlineSessionRequestIsAllowedForGlobalObject(DOMWindow& globalObject, Document& document, const XRSessionInit& init) const
>+{
>+    // 1. If the session request contained any required features or optional features and the request was not made
>+    //    while the global object has transient activation or when launching a web application, return false.
>+    bool sessionRequestContainedAnyFeature = !init.optionalFeatures.isEmpty() || !init.requiredFeatures.isEmpty();
>+    if (sessionRequestContainedAnyFeature && !globalObject.hasTransientActivation() /* TODO: || !launching a web app */)
>+        return false;
>+
>+    // 2. If the requesting document is not responsible, return false.
>+    if (&document != globalObject.document())
>+        return false;
>+
>+    return true;
>+}
>+
>+
>+struct WebXRSystem::ResolvedRequestedFeatures {
>+    FeaturesArray granted;
>+    FeaturesArray consentRequired;
>+    FeaturesArray consentOptional;
>+};
>+
>+#define RETURN_FALSE_OR_CONTINUE(mustReturn) { \
>+    if (mustReturn) {\
>+        return false; \
>+    } \
>+    continue; \
>+}
>+
>+// https://immersive-web.github.io/webxr/#resolve-the-requested-features
>+Optional<WebXRSystem::ResolvedRequestedFeatures> WebXRSystem::resolveRequestedFeatures(XRSessionMode mode, const XRSessionInit& init, PlatformXR::Device* device, JSC::JSGlobalObject& globalObject) const
> {
>-    PlatformXR::Instance::singleton();
>+    // 1. Let consentRequired be an empty list of DOMString.
>+    // 2. Let consentOptional be an empty list of DOMString.
>+    ResolvedRequestedFeatures resolvedFeatures;
>+
>+    // 3. Let device be the result of obtaining the current device for mode, requiredFeatures, and optionalFeatures.
>+    // 4. Let granted be a list of DOMString initialized to device's list of enabled features for mode.
>+    if (device)
>+        resolvedFeatures.granted = device->enabledFeatures(mode);
>+
>+    // 5. If device is null or device's list of supported modes does not contain mode, run the following steps:
>+    //  5.1 Return the tuple (consentRequired, consentOptional, granted)
>+    if (!device || !device->supports(mode))
>+        return resolvedFeatures;
>+
>+    // 6. Add every feature descriptor in the default features table associated
>+    //    with mode to the indicated feature list if it is not already present.
>+    // https://immersive-web.github.io/webxr/#default-features
>+    auto requiredFeaturesWithDefaultFeatures = init.requiredFeatures;
>+    requiredFeaturesWithDefaultFeatures.append(convertEnumerationToJS(globalObject, XRReferenceSpaceType::Viewer));
>+    if (mode == XRSessionMode::ImmersiveAr || mode == XRSessionMode::ImmersiveVr)
>+        requiredFeaturesWithDefaultFeatures.append(convertEnumerationToJS(globalObject, XRReferenceSpaceType::Local));
>+
>+    // 7. For each feature in requiredFeatures|optionalFeatures perform the following steps:
>+    // 8. For each feature in optionalFeatures perform the following steps:
>+    // We're merging both loops in a single lambda. The only difference is that a failure on any required features
>+    // implies cancelling the whole process while failures in optional features are just skipped.
>+    enum class ParsingMode { Strict, Loose };
>+    auto parseFeatures = [&device, &globalObject, mode, &resolvedFeatures] (const JSFeaturesArray& sessionFeatures, ParsingMode parsingMode) -> bool {
>+        bool returnOnFailure = parsingMode == ParsingMode::Strict;
>+        for (const auto& sessionFeature : sessionFeatures) {
>+            // 1. If the feature is null, continue to the next entry.
>+            if (sessionFeature.isNull())
>+                continue;
>+
>+            // 2. If feature is not a valid feature descriptor, perform the following steps
>+            //   2.1. Let s be the result of calling ? ToString(feature).
>+            //   2.2. If s is not a valid feature descriptor or is undefined, (return null|continue to next entry).
>+            //   2.3. Set feature to s.
>+            auto feature = parseEnumeration<XRReferenceSpaceType>(globalObject, sessionFeature);
>+            if (!feature)
>+                RETURN_FALSE_OR_CONTINUE(returnOnFailure);
>+
>+            // 3. If feature is already in granted, continue to the next entry.
>+            if (resolvedFeatures.granted.contains(feature.value()))
>+                continue;
>+
>+            // 4. If the requesting document's origin is not allowed to use any feature policy required by feature
>+            //    as indicated by the feature requirements table, (return null|continue to next entry).
>+
>+            // 5. If session's XR device is not capable of supporting the functionality described by feature or the
>+            //    user agent has otherwise determined to reject the feature, (return null|continue to next entry).
>+            if (!device->enabledFeatures(mode).contains(feature.value()))
>+                RETURN_FALSE_OR_CONTINUE(returnOnFailure);
>+
>+            // 6. If the functionality described by feature requires explicit consent, append it to (consentRequired|consentOptional).
>+            // 7. Else append feature to granted.
>+            resolvedFeatures.granted.append(feature.value());
>+        }
>+        return true;
>+    };
>+
>+    if (!parseFeatures(requiredFeaturesWithDefaultFeatures, ParsingMode::Strict))
>+        return WTF::nullopt;
> 
>-    // When the requestSession(mode) method is invoked, the user agent MUST return a new Promise promise and run the following steps in parallel:
>-    //   1. Let immersive be true if mode is "immersive-vr" or "immersive-ar", and false otherwise.
>-    //   2. If immersive is true:
>-    //     1. If pending immersive session is true or active immersive session is not null, reject promise with an "InvalidStateError" DOMException and abort these steps.
>-    //     2. Else set pending immersive session to be true.
>-    //   3. Ensure an XR device is selected.
>-    //   4. If the XR device is null, reject promise with null.
>-    //   5. Else if the XR device's list of supported modes does not contain mode, reject promise with a "NotSupportedError" DOMException.
>-    //   6. Else If immersive is true and the algorithm is not triggered by user activation, reject promise with a "SecurityError" DOMException and abort these steps.
>-    //   7. If promise was rejected and immersive is true, set pending immersive session to false.
>-    //   8. If promise was rejected, abort these steps.
>-    //   9. Let session be a new XRSession object.
>-    //   10. Initialize the session with session and mode.
>-    //   11. If immersive is true, set the active immersive session to session, and set pending immersive session to false.
>-    //   12. Else append session to the list of inline sessions.
>-    //   13. Resolve promise with session.
>+    parseFeatures(init.optionalFeatures, ParsingMode::Loose);
>+    return resolvedFeatures;
>+}
>+
>+// https://immersive-web.github.io/webxr/#request-the-xr-permission
>+bool WebXRSystem::isXRPermissionGranted(XRSessionMode mode, const XRSessionInit& init, PlatformXR::Device* device, JSC::JSGlobalObject& globalObject) const
>+{
>+    // 1. Set status's granted to an empty FrozenArray.
>+    // 2. Let requiredFeatures be descriptor's requiredFeatures.
>+    // 3. Let optionalFeatures be descriptor's optionalFeatures.
>+    // 4. Let device be the result of obtaining the current device for mode, requiredFeatures, and optionalFeatures.
>+
>+    // 5. Let result be the result of resolving the requested features given requiredFeatures,optionalFeatures, and mode.
>+    auto resolvedFeatures = resolveRequestedFeatures(mode, init, device, globalObject);
>+
>+    // 6. If result is null, run the following steps:
>+    //  6.1. Set status's state to "denied".
>+    //  6.2. Abort these steps.
>+    if (!resolvedFeatures)
>+        return false;
>+
>+    // 7. Let (consentRequired, consentOptional, granted) be the fields of result.
>+    // 8. The user agent MAY at this point ask the user's permission for the calling algorithm to use any of the features
>+    //    in consentRequired and consentOptional. The results of these prompts should be included when determining if there
>+    //    is a clear signal of user intent for enabling these features.
>+    // 9. For each feature in consentRequired perform the following steps:
>+    //  9.1. The user agent MAY at this point ask the user's permission for the calling algorithm to use feature. The results
>+    //       of these prompts should be included when determining if there is a clear signal of user intent to enable feature.
>+    //  9.2. If a clear signal of user intent to enable feature has not been determined, set status's state to "denied" and
>+    //       abort these steps.
>+    //  9.3. If feature is not in granted, append feature to granted.
>+    // 10. For each feature in consentOptional perform the following steps:
>+    //  10.1. The user agent MAY at this point ask the user's permission for the calling algorithm to use feature. The results
>+    //        of these prompts should be included when determining if there is a clear signal of user intent to enable feature.
>+    //  10.2. If a clear signal of user intent to enable feature has not been determined, continue to the next entry.
>+    //  10.3. If feature is not in granted, append feature to granted.
>+    // 11. Set status's granted to granted.
>+    // 12. Set device's list of enabled features for mode to granted.
>+    // 13. Set status's state to "granted".
>+    return true;
>+}
>+
>+
>+// https://immersive-web.github.io/webxr/#dom-xrsystem-requestsession
>+void WebXRSystem::requestSession(Document& document, XRSessionMode mode, const XRSessionInit& init, RequestSessionPromise&& promise)
>+{
>+    // 1. Let promise be a new Promise.
>+    // 2. Let immersive be true if mode is an immersive session mode, and false otherwise.
>+    // 3. Let global object be the relevant Global object for the XRSystem on which this method was invoked.
>+    bool immersive = mode == XRSessionMode::ImmersiveAr || mode == XRSessionMode::ImmersiveVr;
>+    auto* globalObject = document.domWindow();
>+    if (!globalObject) {
>+        promise.reject(Exception { InvalidAccessError});
>+        return;
>+    }
>+
>+    // 4. Check whether the session request is allowed as follows:
>+    if (immersive) {
>+        if (!immersiveSessionRequestIsAllowedForGlobalObject(*globalObject, document)) {
>+            promise.reject(Exception { SecurityError });
>+            return;
>+        }
>+        if (m_pendingImmersiveSession || m_activeImmersiveSession) {
>+            promise.reject(Exception { InvalidStateError });
>+            return;
>+        }
>+        m_pendingImmersiveSession = true;
>+    } else {
>+        if (!inlineSessionRequestIsAllowedForGlobalObject(*globalObject, document, init)) {
>+            promise.reject(Exception { SecurityError });
>+            return;
>+        }
>+    }
>+
>+    // 5. Run the following steps in parallel:
>+    document.postTask([this, immersive, init, mode, promise = WTFMove(promise)] (auto& context) mutable {
>+        // 5.1 Let requiredFeatures be options' requiredFeatures.
>+        // 5.2 Let optionalFeatures be options' optionalFeatures.
>+        // 5.3 Set device to the result of obtaining the current device for mode, requiredFeatures, and optionalFeatures.
>+        auto* device = obtainCurrentDevice(mode, init.requiredFeatures, init.optionalFeatures);
>+
>+        // 5.4 Queue a task to perform the following steps:
>+        queueTaskKeepingObjectAlive(*this, TaskSource::WebXR, [this, &context, device = makeWeakPtr(device), immersive, init, mode, promise = WTFMove(promise)] () mutable {
>+            auto rejectPromiseWithNotSupportedError = makeScopeExit([&] () {
>+                promise.reject(Exception { NotSupportedError });
>+                m_pendingImmersiveSession = false;
>+            });
>+
>+            // 5.4.1 If device is null or device's list of supported modes does not contain mode, run the following steps:
>+            //  - Reject promise with a "NotSupportedError" DOMException.
>+            //  - If immersive is true, set pending immersive session to false.
>+            //  - Abort these steps.
>+            if (!device || !device->supports(mode))
>+                return;
>+
>+            auto* globalObject = context.execState();
>+            if (!globalObject)
>+                return;
>+
>+            // WebKit does not currently support the Permissions API. https://w3c.github.io/permissions/
>+            // However we do implement here the permission request algorithm without the
>+            // Permissions API bits as it handles, among others, the session features parsing. We also
>+            // do it here before creating the session as there is no need to do it on advance.
>+            // TODO: we just perform basic checks without asking any permission to the user so far. Maybe we should implement
>+            // a mechanism similar to what others do involving passing a message to the UI process.
>+
>+            // 5.4.4 Let descriptor be an XRPermissionDescriptor initialized with session, requiredFeatures, and optionalFeatures
>+            // 5.4.5 Let status be an XRPermissionStatus, initially null
>+            // 5.4.6 Request the xr permission with descriptor and status.
>+            // 5.4.7 If status' state is "denied" run the following steps: (same as above in 5.4.1)
>+            if (!isXRPermissionGranted(mode, init, device.get(), *globalObject))
>+                return;
>+
>+            // 5.4.2 Let session be a new XRSession object.
>+            // 5.4.3 Initialize the session with session, mode, and device.
>+            ASSERT(is<Document>(context.get()));
>+            auto session = WebXRSession::create(downcast<Document>(context), *this, mode, WTFMove(device));
>+
>+            // 5.4.8 Potentially set the active immersive session as follows:
>+            if (immersive) {
>+                m_activeImmersiveSession = session.copyRef();
>+                m_pendingImmersiveSession = false;
>+            } else
>+                m_listOfInlineSessions.append(session.copyRef());
>+
>+            // 5.4.9 Resolve promise with session.
>+            promise.resolve(session);
>+            rejectPromiseWithNotSupportedError.release();
>+
>+            // TODO:
>+            // 5.4.10 Queue a task to perform the following steps: NOTE: These steps ensure that initial inputsourceschange
>+            // events occur after the initial session is resolved.
>+            //     1. Set session's promise resolved flag to true.
>+            //     2. Let sources be any existing input sources attached to session.
>+            //     3. If sources is non-empty, perform the following steps:
>+            //        1. Set session's list of active XR input sources to sources.
>+            //        2. Fire an XRInputSourcesChangeEvent named inputsourceschange on session with added set to sources.
>+
>+        });
>+    });
> }
> 
> const char* WebXRSystem::activeDOMObjectName() const
>@@ -171,7 +442,7 @@ void WebXRSystem::registerSimulatedXRDeviceForTesting(const PlatformXR::Device&
> {
>     if (!RuntimeEnabledFeatures::sharedFeatures().webXREnabled())
>         return;
>-    m_testingMode = true;
>+    m_testingDevices++;
>     if (device.supports(PlatformXR::SessionMode::ImmersiveVr) || device.supports(PlatformXR::SessionMode::ImmersiveAr)) {
>         m_immersiveDevices.append(makeWeakPtr(device));
>         m_activeImmersiveDevice = m_immersiveDevices.last();
>@@ -185,14 +456,24 @@ void WebXRSystem::unregisterSimulatedXRDeviceForTesting(PlatformXR::Device* devi
>     if (!RuntimeEnabledFeatures::sharedFeatures().webXREnabled())
>         return;
>     ASSERT(m_immersiveDevices.contains(device));
>+    ASSERT(m_testingDevices);
>     m_immersiveDevices.removeFirst(device);
>     if (m_activeImmersiveDevice == device)
>         m_activeImmersiveDevice = nullptr;
>     if (m_inlineXRDevice == device)
>         m_inlineXRDevice = makeWeakPtr(m_defaultInlineDevice);
>-    m_testingMode = false;
>+    m_testingDevices--;
> }
> 
>+void WebXRSystem::sessionEnded(const WebXRSession* session)
>+{
>+    if (m_activeImmersiveSession == session)
>+        m_activeImmersiveSession = nullptr;
>+
>+    m_listOfInlineSessions.removeFirstMatching([session](auto& item) {
>+        return item.ptr() == session;
>+    });
>+}
> 
> } // namespace WebCore
> 
>diff --git a/Source/WebCore/Modules/webxr/WebXRSystem.h b/Source/WebCore/Modules/webxr/WebXRSystem.h
>index 2e9ce8469a759487b82656609a7926440eb71bab..1f93ccb41b51150042dfbf91018db3d278120be4 100644
>--- a/Source/WebCore/Modules/webxr/WebXRSystem.h
>+++ b/Source/WebCore/Modules/webxr/WebXRSystem.h
>@@ -33,13 +33,20 @@
> #include "JSDOMPromiseDeferred.h"
> #include "WebGLContextAttributes.h"
> #include "WebGLRenderingContextBase.h"
>+#include "XRReferenceSpaceType.h"
> #include "XRSessionMode.h"
> #include <wtf/IsoMalloc.h>
>+#include <wtf/Optional.h>
> #include <wtf/RefCounted.h>
> #include <wtf/WeakPtr.h>
> 
>+namespace JSC {
>+class JSGlobalObject;
>+}
>+
> namespace WebCore {
> 
>+class DOMWindow;
> class ScriptExecutionContext;
> class WebXRSession;
> struct XRSessionInit;
>@@ -57,12 +64,14 @@ public:
>     using RefCounted<WebXRSystem>::deref;
> 
>     void isSessionSupported(XRSessionMode, IsSessionSupportedPromise&&);
>-    void requestSession(XRSessionMode, const XRSessionInit&, RequestSessionPromise&&);
>+    void requestSession(Document&, XRSessionMode, const XRSessionInit&, RequestSessionPromise&&);
> 
>     // This is also needed by WebGLRenderingContextBase::makeXRCompatible() and HTMLCanvasElement::createContextWebGL().
>     void ensureImmersiveXRDeviceIsSelected();
>     bool hasActiveImmersiveXRDevice() { return !!m_activeImmersiveDevice; }
> 
>+    void sessionEnded(const WebXRSession*);
>+
>     // For testing purpouses only.
>     void registerSimulatedXRDeviceForTesting(const PlatformXR::Device&);
>     void unregisterSimulatedXRDeviceForTesting(PlatformXR::Device*);
>@@ -81,20 +90,30 @@ protected:
> private:
>     WebXRSystem(ScriptExecutionContext&);
> 
>+    using FeaturesArray = PlatformXR::Device::ListOfEnabledFeatures;
>+    using JSFeaturesArray = Vector<JSC::JSValue>;
>+    PlatformXR::Device* obtainCurrentDevice(XRSessionMode, const JSFeaturesArray& requiredFeatures, const JSFeaturesArray& optionalFeatures);
>+
>+    bool immersiveSessionRequestIsAllowedForGlobalObject(DOMWindow&, Document&) const;
>+    bool inlineSessionRequestIsAllowedForGlobalObject(DOMWindow&, Document&, const XRSessionInit&) const;
>+
>+    struct ResolvedRequestedFeatures;
>+    Optional<ResolvedRequestedFeatures> resolveRequestedFeatures(XRSessionMode, const XRSessionInit&, PlatformXR::Device*, JSC::JSGlobalObject&) const;
>+    bool isXRPermissionGranted(XRSessionMode, const XRSessionInit&, PlatformXR::Device*, JSC::JSGlobalObject&) const;
>+
>     // https://immersive-web.github.io/webxr/#default-inline-xr-device
>     class DummyInlineDevice final : public PlatformXR::Device {
>     public:
>-        DummyInlineDevice()
>-        {
>-            m_supportedModes.append(XRSessionMode::Inline);
>-        }
>+        DummyInlineDevice();
>     };
>     DummyInlineDevice m_defaultInlineDevice;
> 
>     bool m_immersiveXRDevicesHaveBeenEnumerated { false };
>-    bool m_testingMode { false };
>+    uint m_testingDevices { 0 };
> 
>-    WeakPtr<WebXRSession> m_activeImmersiveSession;
>+    bool m_pendingImmersiveSession { false };
>+    RefPtr<WebXRSession> m_activeImmersiveSession;
>+    Vector<Ref<WebXRSession>> m_listOfInlineSessions;
> 
>     WeakPtr<PlatformXR::Device> m_activeImmersiveDevice;
>     Vector<WeakPtr<PlatformXR::Device>> m_immersiveDevices;
>diff --git a/Source/WebCore/Modules/webxr/WebXRSystem.idl b/Source/WebCore/Modules/webxr/WebXRSystem.idl
>index cad27e327d6335a3a7076cf67ce9e4c3f07a5d7a..2c7c00830734f98cb2bfa66137e8e83828b94fe3 100644
>--- a/Source/WebCore/Modules/webxr/WebXRSystem.idl
>+++ b/Source/WebCore/Modules/webxr/WebXRSystem.idl
>@@ -33,7 +33,7 @@
> ] interface WebXRSystem : EventTarget {
>     // Methods
>     Promise<void> isSessionSupported(XRSessionMode mode);
>-    [NewObject] Promise<WebXRSession> requestSession(XRSessionMode mode, optional XRSessionInit options);
>+    [NewObject, CallWith=Document] Promise<WebXRSession> requestSession(XRSessionMode mode, optional XRSessionInit options);
> 
>     // Events
>     attribute EventHandler ondevicechange;
>diff --git a/Source/WebCore/dom/TaskSource.h b/Source/WebCore/dom/TaskSource.h
>index 8548eee0475eec0f266df778e60dc8540c4d09b3..2f794a1cba5f198ef682033561e9a95a8718cf44 100644
>--- a/Source/WebCore/dom/TaskSource.h
>+++ b/Source/WebCore/dom/TaskSource.h
>@@ -39,6 +39,7 @@ enum class TaskSource : uint8_t {
>     PostedMessageQueue,
>     UserInteraction,
>     WebGL,
>+    WebXR,
> 
>     // Internal to WebCore
>     InternalAsyncTask, // Safe to re-order or delay.
>diff --git a/Source/WebCore/platform/xr/PlatformXR.h b/Source/WebCore/platform/xr/PlatformXR.h
>index e02f09e71e330c367f179c92c2c4ec10931889d0..0b0413bcb587b9f14ab340cda4e49e9b06e94f5d 100644
>--- a/Source/WebCore/platform/xr/PlatformXR.h
>+++ b/Source/WebCore/platform/xr/PlatformXR.h
>@@ -19,12 +19,13 @@
> #pragma once
> 
> #include <memory>
>+#include <wtf/HashMap.h>
> #include <wtf/Vector.h>
> #include <wtf/WeakPtr.h>
> 
> namespace PlatformXR {
> 
>-enum class SessionMode {
>+enum class SessionMode : uint8_t {
>     Inline,
>     ImmersiveVr,
>     ImmersiveAr,
>@@ -48,18 +49,19 @@ public:
>     Device();
>     DeviceId id() const { return m_id; }
> 
>-    using ListOfSupportedModes = Vector<SessionMode>;
>     using ListOfEnabledFeatures = Vector<ReferenceSpaceType>;
>-
>-    bool supports(SessionMode mode) const { return m_supportedModes.contains(mode); }
>-    void setSupportedModes(const ListOfSupportedModes& modes) { m_supportedModes = modes; }
>-    void setEnabledFeatures(const ListOfEnabledFeatures& features) { m_enabledFeatures = features; }
>+    bool supports(SessionMode mode) const { return m_enabledFeaturesMap.contains(mode); }
>+    void setEnabledFeatures(SessionMode mode, const ListOfEnabledFeatures& features) { m_enabledFeaturesMap.set(mode, features); }
>+    ListOfEnabledFeatures enabledFeatures(SessionMode mode) const { return m_enabledFeaturesMap.get(mode); }
> 
>     inline bool operator==(const Device& other) const { return m_id == other.m_id; }
> 
> protected:
>-    ListOfSupportedModes m_supportedModes;
>-    ListOfEnabledFeatures m_enabledFeatures;
>+    // https://immersive-web.github.io/webxr/#xr-device-concept
>+    // Each XR device has a list of enabled features for each XRSessionMode in its list of supported modes,
>+    // which is a list of feature descriptors which MUST be initially an empty list.
>+    using EnabledFeaturesPerModeMap = WTF::HashMap<SessionMode, ListOfEnabledFeatures, WTF::IntHash<SessionMode>, WTF::StrongEnumHashTraits<SessionMode>>;
>+    EnabledFeaturesPerModeMap m_enabledFeaturesMap;
> 
> private:
>     DeviceId m_id;
>diff --git a/Source/WebCore/platform/xr/openxr/PlatformXR.cpp b/Source/WebCore/platform/xr/openxr/PlatformXR.cpp
>index a0a85d2113d71be232ae53fd7e3d95fa7d738182..4a647050f97e863e56f25928b55ad9f629a2a8cd 100644
>--- a/Source/WebCore/platform/xr/openxr/PlatformXR.cpp
>+++ b/Source/WebCore/platform/xr/openxr/PlatformXR.cpp
>@@ -24,6 +24,7 @@
> 
> #if USE_OPENXR
> #include <openxr/openxr.h>
>+#include <wtf/Optional.h>
> #include <wtf/text/StringConcatenateNumbers.h>
> #include <wtf/text/WTFString.h>
> #endif // USE_OPENXR
>@@ -67,7 +68,7 @@ public:
>     ~Impl();
> 
> #if USE_OPENXR
>-    void collectSupportedSessionModes(Device&, XrSystemId);
>+    Optional<Vector<SessionMode>> collectSupportedSessionModes(Device&, XrSystemId);
>     XrInstance m_instance { XR_NULL_HANDLE };
> #endif // USE_OPENXR
> };
>@@ -150,13 +151,13 @@ Instance::Impl::~Impl()
> 
> #if USE_OPENXR
> 
>-void Instance::Impl::collectSupportedSessionModes(Device& device, XrSystemId systemId)
>+Optional<Vector<SessionMode>> Instance::Impl::collectSupportedSessionModes(Device& device, XrSystemId systemId)
> {
>     uint32_t viewConfigurationCount;
>     XrResult result = xrEnumerateViewConfigurations(m_instance, systemId, 0, &viewConfigurationCount, nullptr);
>     if (result != XR_SUCCESS) {
>         WTFLogAlways("xrEnumerateViewConfigurations(): error %s\n", resultToString(result, m_instance).utf8().data());
>-        return;
>+        return WTF::nullopt;
>     }
> 
>     XrViewConfigurationType viewConfigurations[viewConfigurationCount];
>@@ -164,23 +165,23 @@ void Instance::Impl::collectSupportedSessionModes(Device& device, XrSystemId sys
>     if (result != XR_SUCCESS) {
>         WTFLogAlways("xrEnumerateViewConfigurations(): error %s\n", resultToString(result, m_instance).utf8().data());
>         WTFLogAlways("xrEnumerateViewConfigurations(): error %s\n", resultToString(result, m_instance).utf8().data());
>-        return;
>+        return WTF::nullopt;
>     }
> 
>-    Device::ListOfSupportedModes supportedModes;
>+    Vector<SessionMode> supportedModes;
>     for (uint32_t i = 0; i < viewConfigurationCount; ++i) {
>         auto viewConfigurationProperties = createStructure<XrViewConfigurationProperties, XR_TYPE_VIEW_CONFIGURATION_PROPERTIES>();
>         result = xrGetViewConfigurationProperties(m_instance, systemId, viewConfigurations[i], &viewConfigurationProperties);
>         if (result != XR_SUCCESS) {
>             WTFLogAlways("xrGetViewConfigurationProperties(): error %s\n", resultToString(result, m_instance).utf8().data());
>-            return;
>+            return WTF::nullopt;
>         }
>         if (viewConfigurationProperties.viewConfigurationType == XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO)
>             supportedModes.append(SessionMode::ImmersiveAr);
>         else if (viewConfigurationProperties.viewConfigurationType == XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO)
>             supportedModes.append(SessionMode::ImmersiveVr);
>     }
>-    device.setSupportedModes(supportedModes);
>+    return supportedModes;
> }
> 
> #endif // USE_OPENXR
>@@ -218,7 +219,14 @@ void Instance::enumerateImmersiveXRDevices()
>     }
> 
>     auto device = makeUnique<Device>();
>-    m_impl->collectSupportedSessionModes(*device, systemId);
>+    auto sessionModes = m_impl->collectSupportedSessionModes(*device, systemId);
>+    if (sessionModes) {
>+        for (auto& mode : sessionModes.value()) {
>+            // TODO: fill in features
>+            device->setEnabledFeatures(mode, { });
>+        }
>+    }
>+
>     m_immersiveXRDevices.append(WTFMove(device));
> #endif // USE_OPENXR
> }
>diff --git a/Source/WebCore/testing/WebXRTest.cpp b/Source/WebCore/testing/WebXRTest.cpp
>index b20a43372b24ff7dfc6ea5baa79f5ca56ec55228..b4167da002f3be696d9a95f44e33d4170cdf6780 100644
>--- a/Source/WebCore/testing/WebXRTest.cpp
>+++ b/Source/WebCore/testing/WebXRTest.cpp
>@@ -54,13 +54,14 @@ void WebXRTest::simulateDeviceConnection(ScriptExecutionContext& context, const
>             simulatedDevice.views().append(view.releaseReturnValue());
>         }
> 
>+        Vector<XRReferenceSpaceType> features;
>         if (init.supportedFeatures) {
>-            Vector<XRReferenceSpaceType> features;
>-            for (auto& feature : init.supportedFeatures.value()) {
>-                if (auto referenceSpaceType = parseEnumeration<XRReferenceSpaceType>(*context.execState(), feature))
>-                    features.append(referenceSpaceType.value());
>+            if (auto* globalObject = context.execState()) {
>+                for (auto& feature : init.supportedFeatures.value()) {
>+                    if (auto referenceSpaceType = parseEnumeration<XRReferenceSpaceType>(*globalObject, feature))
>+                        features.append(referenceSpaceType.value());
>+                }
>             }
>-            simulatedDevice.setEnabledFeatures(features);
>         }
> 
>         if (init.boundsCoordinates) {
>@@ -87,7 +88,9 @@ void WebXRTest::simulateDeviceConnection(ScriptExecutionContext& context, const
>             if (init.supportsImmersive)
>                 supportedModes.append(XRSessionMode::ImmersiveVr);
>         }
>-        simulatedDevice.setSupportedModes(supportedModes);
>+
>+        for (auto& mode : supportedModes)
>+            simulatedDevice.setEnabledFeatures(mode, features);
> 
>         m_context->registerSimulatedXRDeviceForTesting(simulatedDevice);
> 
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index 84a2f6dfc7afff8a6dd30d3f0fa5d4fb26aa0269..53e8313e1fa951e6d9f6b1e6e52e440c37e647b0 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,13 @@
>+2020-05-14  Sergio Villar Senin  <svillar@igalia.com>
>+
>+        [WebXR] Implement requestSession()
>+        https://bugs.webkit.org/show_bug.cgi?id=211888
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * platform/wpe/TestExpectations: Added several previously skipped tests
>+        that are now passing.
>+
> 2020-05-14  Diego Pino Garcia  <dpino@igalia.com>
> 
>         [GTK] Gardening, update expectations after r261609
>diff --git a/LayoutTests/imported/w3c/ChangeLog b/LayoutTests/imported/w3c/ChangeLog
>index 90bc20a2994a3316d30f44d63d8b12acef877f52..f7fffa686a3f8593eb7a8383dc57dba461bcb9b2 100644
>--- a/LayoutTests/imported/w3c/ChangeLog
>+++ b/LayoutTests/imported/w3c/ChangeLog
>@@ -1,3 +1,19 @@
>+2020-05-14  Sergio Villar Senin  <svillar@igalia.com>
>+
>+        [WebXR] Implement requestSession()
>+        https://bugs.webkit.org/show_bug.cgi?id=211888
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * web-platform-tests/webxr/xrDevice_requestSession_immersive.https-expected.txt: Added.
>+        * web-platform-tests/webxr/xrDevice_requestSession_immersive_no_gesture.https-expected.txt: Added.
>+        * web-platform-tests/webxr/xrDevice_requestSession_immersive_unsupported.https-expected.txt: Added.
>+        * web-platform-tests/webxr/xrDevice_requestSession_no_mode.https-expected.txt: Added.
>+        * web-platform-tests/webxr/xrDevice_requestSession_non_immersive_no_gesture.https-expected.txt: Added.
>+        * web-platform-tests/webxr/xrDevice_requestSession_optionalFeatures.https-expected.txt: Added.
>+        * web-platform-tests/webxr/xrDevice_requestSession_requiredFeatures_unknown.https-expected.txt: Added.
>+        * web-platform-tests/webxr/xrSession_features_deviceSupport.https-expected.txt: Added.
>+
> 2020-05-12  Alexey Shvayka  <shvaikalesh@gmail.com>
> 
>         Implement @isConstructor bytecode intrinsic and bytecode for that
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_immersive.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_immersive.https-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..d6d97b294904877623a9166ddbc5a0f64e2f4382
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_immersive.https-expected.txt
>@@ -0,0 +1,5 @@
>+
>+PASS Tests requestSession resolves when supported 
>+PASS Tests requestSession accepts XRSessionInit dictionary 
>+PASS Tests requestSession ignores unknown optionalFeatures 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_immersive_no_gesture.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_immersive_no_gesture.https-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..27963fa9a7c6424daf962a7cd3b355e534116fd7
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_immersive_no_gesture.https-expected.txt
>@@ -0,0 +1,3 @@
>+
>+PASS Requesting immersive session outside of a user gesture rejects 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_immersive_unsupported.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_immersive_unsupported.https-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..4d9036799a5674a235ccc698a84b7f8a629bd4d0
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_immersive_unsupported.https-expected.txt
>@@ -0,0 +1,3 @@
>+
>+PASS Requesting an immersive session when unsupported rejects 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_no_mode.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_no_mode.https-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..f0fd1b6afdcb4deeb7a54f3a63c1c50ecb7a63ba
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_no_mode.https-expected.txt
>@@ -0,0 +1,3 @@
>+
>+PASS Requesting a session with no mode rejects 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_non_immersive_no_gesture.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_non_immersive_no_gesture.https-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..f3c296e808c528670c745ff078e215d2960bb7b2
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_non_immersive_no_gesture.https-expected.txt
>@@ -0,0 +1,3 @@
>+
>+PASS Requesting non-immersive session outside of a user gesture succeeds 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_optionalFeatures.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_optionalFeatures.https-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..da2f225349a28600c8f735f914f7ea5da761f469
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_optionalFeatures.https-expected.txt
>@@ -0,0 +1,6 @@
>+
>+PASS Tests requestSession accepts XRSessionInit dictionary 
>+PASS Tests requestSession accepts XRSessionInit dictionary with empty feature lists 
>+PASS Tests requestSession ignores unknown strings in optionalFeatures 
>+PASS Tests requestSession ignores unknown objects in optionalFeatures 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_requiredFeatures_unknown.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_requiredFeatures_unknown.https-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..38a28a896fc13d236c4b6e5194e6c6368b9ace7f
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_requiredFeatures_unknown.https-expected.txt
>@@ -0,0 +1,3 @@
>+
>+PASS Tests requestSession rejects for unknown requiredFeatures 
>+
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/webxr/xrSession_features_deviceSupport.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/webxr/xrSession_features_deviceSupport.https-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..2f7ea46e0cf745e69f5d462005be1f757418418d
>--- /dev/null
>+++ b/LayoutTests/imported/w3c/web-platform-tests/webxr/xrSession_features_deviceSupport.https-expected.txt
>@@ -0,0 +1,3 @@
>+
>+PASS Immersive XRSession requests with no supported device should reject 
>+
>diff --git a/LayoutTests/platform/wpe/TestExpectations b/LayoutTests/platform/wpe/TestExpectations
>index 1e5b76afa71ea5bd851505f1bf8bdf7bfb73496c..acd64aa666b9189ad1f1b670b746cb0f61a49bf4 100644
>--- a/LayoutTests/platform/wpe/TestExpectations
>+++ b/LayoutTests/platform/wpe/TestExpectations
>@@ -1022,6 +1022,14 @@ webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/idlharness.https.windo
> webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/xrDevice_isSessionSupported_inline.https.html [ Pass ]
> webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/xrDevice_isSessionSupported_immersive.https.html [ Pass ]
> webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/xrDevice_isSessionSupported_immersive_unsupported.https.html [ Pass ]
>+webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_immersive.https.html [ Pass ]
>+webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_immersive_no_gesture.https.html [ Pass ]
>+webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_immersive_unsupported.https.html [ Pass ]
>+webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_no_mode.https.html [ Pass ]
>+webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_non_immersive_no_gesture.https.html [ Pass ]
>+webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_optionalFeatures.https.html [ Pass ]
>+webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/xrDevice_requestSession_requiredFeatures_unknown.https.html [ Pass ]
>+webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/xrSession_features_deviceSupport.https.html [ Pass ]
> 
> # Passing since r259006.
> imported/w3c/web-platform-tests/css/css-grid/alignment/self-baseline/grid-self-baseline-changes-grid-area-size-010.html

Actions: View | Formatted Diff | Diff

Attachments on bug 211888: 399350 | 399644 | 399656