Changeset 262299 in webkit

Timestamp:

May 29, 2020 9:36:52 AM (4 years ago)

Author:

svillar@igalia.com

Message:

[WebXR] Implement XRSession::requestReferenceSpace()
​https://bugs.webkit.org/show_bug.cgi?id=212407

Reviewed by Youenn Fablet.

LayoutTests/imported/w3c:

Added expectations.

• web-platform-tests/webxr/webGLCanvasContext_create_xrcompatible.https-expected.txt: Added.
• web-platform-tests/webxr/webGLCanvasContext_makecompatible_contextlost.https-expected.txt: Added.
• web-platform-tests/webxr/xrSession_requestReferenceSpace.https-expected.txt: Added.

Source/WebCore:

This patch implements the requestReferenceSpace() method of the XRSession which is used to
create reference spaces. A reference space establishes a space where pose data will be defined
and thus is mandatory to retrieve that pose information.

There are still some bits that have to implementated in follow up patches using platform code.

• Modules/webxr/WebXRBoundedReferenceSpace.cpp:

(WebCore::WebXRBoundedReferenceSpace::create): Added.
(WebCore::WebXRBoundedReferenceSpace::WebXRBoundedReferenceSpace): Ditto.

• Modules/webxr/WebXRBoundedReferenceSpace.h:
• Modules/webxr/WebXRReferenceSpace.cpp:

(WebCore::WebXRReferenceSpace::create): Added.
(WebCore::WebXRReferenceSpace::WebXRReferenceSpace): Ditto.
(WebCore::WebXRReferenceSpace::getOffsetReferenceSpace): Use the create() method.

• Modules/webxr/WebXRReferenceSpace.h:
• Modules/webxr/WebXRSession.cpp:

(WebCore::WebXRSession::referenceSpaceIsSupported const): New method to check whether a reference.
space is supported by session and device.
(WebCore::WebXRSession::requestReferenceSpace): New method that creates reference spaces for pose data.

• Modules/webxr/WebXRSession.h:
• Modules/webxr/WebXRSpace.cpp:

(WebCore::WebXRSpace::WebXRSpace): Store a reference to the session creating the space.

• Modules/webxr/WebXRSpace.h:

LayoutTests:

• platform/wpe/TestExpectations: Unskipped 3 more tests that are working now.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/imported/w3c/ChangeLog (modified) (1 diff)
• LayoutTests/imported/w3c/web-platform-tests/webxr/webGLCanvasContext_create_xrcompatible.https-expected.txt (added)
• LayoutTests/imported/w3c/web-platform-tests/webxr/webGLCanvasContext_makecompatible_contextlost.https-expected.txt (added)
• LayoutTests/imported/w3c/web-platform-tests/webxr/xrSession_requestReferenceSpace.https-expected.txt (added)
• LayoutTests/platform/wpe/TestExpectations (modified) (2 diffs)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/Modules/webxr/WebXRBoundedReferenceSpace.cpp (modified) (1 diff)
• Source/WebCore/Modules/webxr/WebXRBoundedReferenceSpace.h (modified) (3 diffs)
• Source/WebCore/Modules/webxr/WebXRReferenceSpace.cpp (modified) (2 diffs)
• Source/WebCore/Modules/webxr/WebXRReferenceSpace.h (modified) (2 diffs)
• Source/WebCore/Modules/webxr/WebXRSession.cpp (modified) (2 diffs)
• Source/WebCore/Modules/webxr/WebXRSession.h (modified) (2 diffs)
• Source/WebCore/Modules/webxr/WebXRSpace.cpp (modified) (2 diffs)
• Source/WebCore/Modules/webxr/WebXRSpace.h (modified) (2 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2020-05-27  Sergio Villar Senin  <svillar@igalia.com>
+
+        [WebXR] Implement XRSession::requestReferenceSpace()
+        https://bugs.webkit.org/show_bug.cgi?id=212407
+
+        Reviewed by Youenn Fablet.
+
+        * platform/wpe/TestExpectations: Unskipped 3 more tests that are working now.
+
 2020-05-29  Diego Pino Garcia  <dpino@igalia.com>
 

trunk/LayoutTests/imported/w3c/ChangeLog

@@ +1 @@
+2020-05-27  Sergio Villar Senin  <svillar@igalia.com>
+
+        [WebXR] Implement XRSession::requestReferenceSpace()
+        https://bugs.webkit.org/show_bug.cgi?id=212407
+
+        Reviewed by Youenn Fablet.
+
+        Added expectations.
+
+        * web-platform-tests/webxr/webGLCanvasContext_create_xrcompatible.https-expected.txt: Added.
+        * web-platform-tests/webxr/webGLCanvasContext_makecompatible_contextlost.https-expected.txt: Added.
+        * web-platform-tests/webxr/xrSession_requestReferenceSpace.https-expected.txt: Added.
+
 2020-05-29  Javier Fernandez  <jfernandez@igalia.com>
 

trunk/LayoutTests/platform/wpe/TestExpectations

@@ -968 +968 @@
 # WebXR
 webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/idlharness.https.window.html [ Pass ]
+webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/webGLCanvasContext_create_xrcompatible.https.html [ Pass ]
+webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/webGLCanvasContext_makecompatible_contextlost.https.html [ Pass ]
 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 ]
@@ -982 +984 @@
 webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/xrSession_features_deviceSupport.https.html [ Pass ]
 webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/xrSession_requestAnimationFrame_callback_calls.https.html [ Pass ]
+webkit.org/b/209859 imported/w3c/web-platform-tests/webxr/xrSession_requestReferenceSpace.https.html [ Pass ]
 
 # Passing since r259532.

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2020-05-27  Sergio Villar Senin  <svillar@igalia.com>
+
+        [WebXR] Implement XRSession::requestReferenceSpace()
+        https://bugs.webkit.org/show_bug.cgi?id=212407
+
+        Reviewed by Youenn Fablet.
+
+        This patch implements the requestReferenceSpace() method of the XRSession which is used to
+        create reference spaces. A reference space establishes a space where pose data will be defined
+        and thus is mandatory to retrieve that pose information.
+
+        There are still some bits that have to implementated in follow up patches using platform code.
+
+        * Modules/webxr/WebXRBoundedReferenceSpace.cpp:
+        (WebCore::WebXRBoundedReferenceSpace::create): Added.
+        (WebCore::WebXRBoundedReferenceSpace::WebXRBoundedReferenceSpace): Ditto.
+        * Modules/webxr/WebXRBoundedReferenceSpace.h:
+        * Modules/webxr/WebXRReferenceSpace.cpp:
+        (WebCore::WebXRReferenceSpace::create): Added.
+        (WebCore::WebXRReferenceSpace::WebXRReferenceSpace): Ditto.
+        (WebCore::WebXRReferenceSpace::getOffsetReferenceSpace): Use the create() method.
+        * Modules/webxr/WebXRReferenceSpace.h:
+        * Modules/webxr/WebXRSession.cpp:
+        (WebCore::WebXRSession::referenceSpaceIsSupported const): New method to check whether a reference.
+        space is supported by session and device.
+        (WebCore::WebXRSession::requestReferenceSpace): New method that creates reference spaces for pose data.
+        * Modules/webxr/WebXRSession.h:
+        * Modules/webxr/WebXRSpace.cpp:
+        (WebCore::WebXRSpace::WebXRSpace): Store a reference to the session creating the space.
+        * Modules/webxr/WebXRSpace.h:
+
 2020-05-29  Simon Fraser  <simon.fraser@apple.com>
 

trunk/Source/WebCore/Modules/webxr/WebXRBoundedReferenceSpace.cpp

@@ -29 +29 @@
 #if ENABLE(WEBXR)
 
+#include "DOMPointReadOnly.h"
+#include <wtf/IsoMallocInlines.h>
+
 namespace WebCore {
+
+WTF_MAKE_ISO_ALLOCATED_IMPL(WebXRBoundedReferenceSpace);
+
+Ref<WebXRBoundedReferenceSpace> WebXRBoundedReferenceSpace::create(Document& document, Ref<WebXRSession>&& session, XRReferenceSpaceType type)
+{
+    return adoptRef(*new WebXRBoundedReferenceSpace(document, WTFMove(session), type));
+}
+
+WebXRBoundedReferenceSpace::WebXRBoundedReferenceSpace(Document& document, Ref<WebXRSession>&& session, XRReferenceSpaceType type)
+    : WebXRReferenceSpace(document, WTFMove(session), type)
+{
+}
+
+WebXRBoundedReferenceSpace::~WebXRBoundedReferenceSpace() = default;
 
 const Vector<Ref<DOMPointReadOnly>>& WebXRBoundedReferenceSpace::boundsGeometry() const

trunk/Source/WebCore/Modules/webxr/WebXRBoundedReferenceSpace.h

@@ -27 +27 @@
 
 #include "WebXRReferenceSpace.h"
+#include <wtf/IsoMalloc.h>
 #include <wtf/Ref.h>
 #include <wtf/Vector.h>
@@ -37 +38 @@
 
 class WebXRBoundedReferenceSpace : public WebXRReferenceSpace {
+    WTF_MAKE_ISO_ALLOCATED(WebXRBoundedReferenceSpace);
 public:
+    static Ref<WebXRBoundedReferenceSpace> create(Document&, Ref<WebXRSession>&&, XRReferenceSpaceType);
+
     virtual ~WebXRBoundedReferenceSpace();
 
@@ -43 +47 @@
 
 private:
+    WebXRBoundedReferenceSpace(Document&, Ref<WebXRSession>&&, XRReferenceSpaceType);
+
     Vector<Ref<DOMPointReadOnly>> m_boundsGeometry;
 };

trunk/Source/WebCore/Modules/webxr/WebXRReferenceSpace.cpp

@@ -29 +29 @@
 #if ENABLE(WEBXR)
 
+#include "Document.h"
+#include "WebXRSession.h"
+#include <wtf/IsoMallocInlines.h>
+
 namespace WebCore {
 
-WebXRReferenceSpace::WebXRReferenceSpace(ScriptExecutionContext& context)
-    : WebXRSpace(context)
+WTF_MAKE_ISO_ALLOCATED_IMPL(WebXRReferenceSpace);
+
+Ref<WebXRReferenceSpace> WebXRReferenceSpace::create(Document& document, Ref<WebXRSession>&& session, XRReferenceSpaceType type)
+{
+    return adoptRef(*new WebXRReferenceSpace(document, WTFMove(session), type));
+}
+
+WebXRReferenceSpace::WebXRReferenceSpace(Document& document, Ref<WebXRSession>&& session, XRReferenceSpaceType type)
+    : WebXRSpace(document, WTFMove(session))
+    , m_type(type)
 {
 }
@@ -38 +50 @@
 WebXRReferenceSpace::~WebXRReferenceSpace() = default;
 
-Ref<WebXRReferenceSpace> WebXRReferenceSpace::getOffsetReferenceSpace(const WebXRRigidTransform&)
+RefPtr<WebXRReferenceSpace> WebXRReferenceSpace::getOffsetReferenceSpace(const WebXRRigidTransform&)
 {
-    return adoptRef(*new WebXRReferenceSpace(*scriptExecutionContext()));
+    if (!scriptExecutionContext())
+        return nullptr;
+    ASSERT(is<Document>(scriptExecutionContext()));
+    return create(downcast<Document>(*scriptExecutionContext()), m_session.copyRef(), m_type);
 }
 

trunk/Source/WebCore/Modules/webxr/WebXRReferenceSpace.h

@@ -29 +29 @@
 
 #include "WebXRSpace.h"
-
+#include "XRReferenceSpaceType.h"
+#include <wtf/IsoMalloc.h>
 #include <wtf/Ref.h>
 
@@ -35 +36 @@
 
 class WebXRRigidTransform;
+class WebXRSession;
 
 class WebXRReferenceSpace : public WebXRSpace {
+    WTF_MAKE_ISO_ALLOCATED(WebXRReferenceSpace);
 public:
+    static Ref<WebXRReferenceSpace> create(Document&, Ref<WebXRSession>&&, XRReferenceSpaceType);
+
     virtual ~WebXRReferenceSpace();
 
-    Ref<WebXRReferenceSpace> getOffsetReferenceSpace(const WebXRRigidTransform&);
+    RefPtr<WebXRReferenceSpace> getOffsetReferenceSpace(const WebXRRigidTransform&);
 
-private:
-    WebXRReferenceSpace(ScriptExecutionContext&);
+protected:
+    WebXRReferenceSpace(Document&, Ref<WebXRSession>&&, XRReferenceSpaceType);
+
+    XRReferenceSpaceType m_type;
 };
 

trunk/Source/WebCore/Modules/webxr/WebXRSession.cpp

@@ -29 +29 @@
 #if ENABLE(WEBXR)
 
+#include "JSWebXRReferenceSpace.h"
+#include "WebXRBoundedReferenceSpace.h"
 #include "WebXRFrame.h"
 #include "WebXRSystem.h"
@@ -84 +86 @@
 }
 
-void WebXRSession::requestReferenceSpace(const XRReferenceSpaceType&, RequestReferenceSpacePromise&&)
-{
+// https://immersive-web.github.io/webxr/#reference-space-is-supported
+bool WebXRSession::referenceSpaceIsSupported(XRReferenceSpaceType type) const
+{
+    // 1. If type is not contained in session’s XR device's list of enabled features for mode return false.
+    if (!m_device->enabledFeatures(m_mode).contains(type))
+        return false;
+
+    // 2. If type is viewer, return true.
+    if (type == XRReferenceSpaceType::Viewer)
+        return true;
+
+    bool isImmersiveSession = m_mode == XRSessionMode::ImmersiveAr || m_mode == XRSessionMode::ImmersiveVr;
+    if (type == XRReferenceSpaceType::Local || type == XRReferenceSpaceType::LocalFloor) {
+        // 3. If type is local or local-floor, and session is an immersive session, return true.
+        if (isImmersiveSession)
+            return true;
+
+        // 4. If type is local or local-floor, and the XR device supports reporting orientation data, return true.
+        // TODO: add API to PlatformXR::Device
+        return true;
+    }
+
+
+    // 5. If type is bounded-floor and session is an immersive session, return the result of whether bounded
+    //    reference spaces are supported by the XR device.
+    // https://immersive-web.github.io/webxr/#bounded-reference-spaces-are-supported
+    // TODO: add API to PlatformXR::Device
+    if (type == XRReferenceSpaceType::BoundedFloor && isImmersiveSession)
+        return true;
+
+    // 6. If type is unbounded, session is an immersive session, and the XR device supports stable tracking
+    //    near the user over an unlimited distance, return true.
+    // TODO: add API to PlatformXR::Device to check stable tracking over unlimited distance.
+    if (type == XRReferenceSpaceType::Unbounded && isImmersiveSession)
+        return true;
+
+    // 7. Return false.
+    return false;
+}
+
+// https://immersive-web.github.io/webxr/#dom-xrsession-requestreferencespace
+void WebXRSession::requestReferenceSpace(XRReferenceSpaceType type, RequestReferenceSpacePromise&& promise)
+{
+    if (!scriptExecutionContext()) {
+        promise.reject(Exception { InvalidStateError });
+        return;
+    }
+    // 1. Let promise be a new Promise.
+    // 2. Run the following steps in parallel:
+    scriptExecutionContext()->postTask([this, promise = WTFMove(promise), type] (auto& context) mutable {
+        //  2.1. Create a reference space, referenceSpace, with the XRReferenceSpaceType type.
+        //  2.2. If referenceSpace is null, reject promise with a NotSupportedError and abort these steps.
+        if (!referenceSpaceIsSupported(type)) {
+            promise.reject(Exception { NotSupportedError });
+            return;
+        }
+
+        // https://immersive-web.github.io/webxr/#create-a-reference-space
+        RefPtr<WebXRReferenceSpace> referenceSpace;
+        ASSERT(is<Document>(context));
+        if (type == XRReferenceSpaceType::BoundedFloor)
+            referenceSpace = WebXRBoundedReferenceSpace::create(downcast<Document>(context), makeRef(*this), type);
+        else
+            referenceSpace = WebXRReferenceSpace::create(downcast<Document>(context), makeRef(*this), type);
+
+        //  2.3. Resolve promise with referenceSpace.
+        // 3. Return promise.
+        promise.resolve(referenceSpace.releaseNonNull());
+    });
 }
 

trunk/Source/WebCore/Modules/webxr/WebXRSession.h

@@ -70 +70 @@
 
     void updateRenderState(const XRRenderStateInit&);
-    void requestReferenceSpace(const XRReferenceSpaceType&, RequestReferenceSpacePromise&&);
+    void requestReferenceSpace(XRReferenceSpaceType, RequestReferenceSpacePromise&&);
 
     XRFrameRequestCallback::Id requestAnimationFrame(Ref<XRFrameRequestCallback>&&);
@@ -97 +97 @@
     void scheduleAnimation();
 
+    bool referenceSpaceIsSupported(XRReferenceSpaceType) const;
+
     XREnvironmentBlendMode m_environmentBlendMode;
     XRVisibilityState m_visibilityState;

trunk/Source/WebCore/Modules/webxr/WebXRSpace.cpp

@@ -29 +29 @@
 #if ENABLE(WEBXR)
 
+#include "Document.h"
+#include "WebXRSession.h"
 #include <wtf/IsoMallocInlines.h>
 
@@ -35 +37 @@
 WTF_MAKE_ISO_ALLOCATED_IMPL(WebXRSpace);
 
-WebXRSpace::WebXRSpace(ScriptExecutionContext& context)
-    : ContextDestructionObserver(&context)
+WebXRSpace::WebXRSpace(Document& document, Ref<WebXRSession>&& session)
+    : ContextDestructionObserver(&document)
+    , m_session(WTFMove(session))
 {
+    ASSERT(context);
 }
 

trunk/Source/WebCore/Modules/webxr/WebXRSpace.h

@@ -34 +34 @@
 namespace WebCore {
 
+class Document;
 class ScriptExecutionContext;
+class WebXRSession;
 
 class WebXRSpace : public RefCounted<WebXRSpace>, public EventTargetWithInlineData, public ContextDestructionObserver {
@@ -45 +47 @@
 
 protected:
-    WebXRSpace(ScriptExecutionContext&);
+    WebXRSpace(Document&, Ref<WebXRSession>&&);
 
     // EventTarget
     ScriptExecutionContext* scriptExecutionContext() const override { return ContextDestructionObserver::scriptExecutionContext(); }
+
+    Ref<WebXRSession> m_session;
 
 private: