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:

    // https://immersive-web.github.io/webxr/#initialize-the-render-state

    //   1. Let state be the newly created XRRenderState object.

    // depthNear, depthFar and baseLayer are initialized in the class definition

    return adoptRef(*new WebXRRenderState(mode == XRSessionMode::Inline ? makeOptional(piOverTwoDouble) : WTF::nullopt));

    //   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)));

    static Ref<WebXRRenderState> create(const WebXRSession&);

    static Ref<WebXRRenderState> create(XRSessionMode);

    WebXRRenderState(Optional<double>&&);

    explicit WebXRRenderState(Optional<double>&& fieldOfView);

    WebXRRenderState(const XRRenderStateInit&);

    explicit WebXRRenderState(const XRRenderStateInit&);

        double near { 0.1 };

        double near { 0.1 }; // in meters

        double far { 1000 };

        double far { 1000 }; // in meters

    Optional<double> m_inlineVerticalFieldOfView;

    Optional<double> m_inlineVerticalFieldOfView; // in radians

    return *m_renderState;

    return *m_activeRenderState;

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)

    // TODO: should be have a MockPlatformXR implementation instead ?

    if (UNLIKELY(m_testingDevices))

    if (UNLIKELY(m_testingMode))

    // 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,

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:

    parseFeatures(init.optionalFeatures, ParsingMode::Loose);

    //   1. Let immersive be true if mode is "immersive-vr" or "immersive-ar", and false otherwise.

    return resolvedFeatures;

    //   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.

// https://immersive-web.github.io/webxr/#request-the-xr-permission

    //   3. Ensure an XR device is selected.

bool WebXRSystem::isXRPermissionGranted(XRSessionMode mode, const XRSessionInit& init, PlatformXR::Device* device, JSC::JSGlobalObject& globalObject) const

    //   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.

    // 1. Set status's granted to an empty FrozenArray.

    //   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.

    // 2. Let requiredFeatures be descriptor's requiredFeatures.

    //   7. If promise was rejected and immersive is true, set pending immersive session to false.

    // 3. Let optionalFeatures be descriptor's optionalFeatures.

    //   8. If promise was rejected, abort these steps.

    // 4. Let device be the result of obtaining the current device for mode, requiredFeatures, and optionalFeatures.

    //   9. Let session be a new XRSession object.

    //   10. Initialize the session with session and mode.

    // 5. Let result be the result of resolving the requested features given requiredFeatures,optionalFeatures, and mode.

    //   11. If immersive is true, set the active immersive session to session, and set pending immersive session to false.

    auto resolvedFeatures = resolveRequestedFeatures(mode, init, device, globalObject);

    //   12. Else append session to the list of inline sessions.

    //   13. Resolve promise with session.

    // 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.

        });

    });

    m_testingMode = true;

    m_testingDevices++;

    m_testingMode = false;

    m_testingDevices--;

    void requestSession(XRSessionMode, const XRSessionInit&, RequestSessionPromise&&);

    void requestSession(Document&, XRSessionMode, const XRSessionInit&, RequestSessionPromise&&);

        DummyInlineDevice()

        DummyInlineDevice();

        {

            m_supportedModes.append(XRSessionMode::Inline);

        }

    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;

    [NewObject] Promise<WebXRSession> requestSession(XRSessionMode mode, optional XRSessionInit options);

    [NewObject, CallWith=Document] Promise<WebXRSession> requestSession(XRSessionMode mode, optional XRSessionInit options);

enum class SessionMode {

enum class SessionMode : uint8_t {

    bool supports(SessionMode mode) const { return m_enabledFeaturesMap.contains(mode); }

    bool supports(SessionMode mode) const { return m_supportedModes.contains(mode); }

    void setEnabledFeatures(SessionMode mode, const ListOfEnabledFeatures& features) { m_enabledFeaturesMap.set(mode, features); }

    void setSupportedModes(const ListOfSupportedModes& modes) { m_supportedModes = modes; }

    ListOfEnabledFeatures enabledFeatures(SessionMode mode) const { return m_enabledFeaturesMap.get(mode); }

    void setEnabledFeatures(const ListOfEnabledFeatures& features) { m_enabledFeatures = features; }

    ListOfSupportedModes m_supportedModes;

    // https://immersive-web.github.io/webxr/#xr-device-concept

    ListOfEnabledFeatures m_enabledFeatures;

    // 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;

    void collectSupportedSessionModes(Device&, XrSystemId);

    Optional<Vector<SessionMode>> collectSupportedSessionModes(Device&, XrSystemId);

void Instance::Impl::collectSupportedSessionModes(Device& device, XrSystemId systemId)

Optional<Vector<SessionMode>> Instance::Impl::collectSupportedSessionModes(Device& device, XrSystemId systemId)

        return;

        return WTF::nullopt;

        return;

        return WTF::nullopt;

    Device::ListOfSupportedModes supportedModes;

    Vector<SessionMode> supportedModes;

            return;

            return WTF::nullopt;

    device.setSupportedModes(supportedModes);

    return supportedModes;

    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, { });

        }

    }

            Vector<XRReferenceSpaceType> features;

            if (auto* globalObject = context.execState()) {

            for (auto& feature : init.supportedFeatures.value()) {

                for (auto& feature : init.supportedFeatures.value()) {

                if (auto referenceSpaceType = parseEnumeration<XRReferenceSpaceType>(*context.execState(), feature))

                    if (auto referenceSpaceType = parseEnumeration<XRReferenceSpaceType>(*globalObject, feature))

                    features.append(referenceSpaceType.value());

                        features.append(referenceSpaceType.value());

                }

        simulatedDevice.setSupportedModes(supportedModes);

        for (auto& mode : supportedModes)

            simulatedDevice.setEnabledFeatures(mode, features);