Bug 1693189 [wpt PR 27654] - WebXR depth: add WebXR test API extension for depth API & write WPTs, a=testonly

Automatic update from web-platform-tests
WebXR depth: add WebXR test API extension for depth API & write WPTs (#27654)

WebXR Test API - extensions for depth:
https://github.com/immersive-web/webxr-test-api/pull/74

Spec:
https://immersive-web.github.io/depth-sensing/

Change-Id: Iad124c43d8abb5c19ff24d4857ec2714b5211163
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2693691
Commit-Queue: Piotr Bialecki <bialpio@chromium.org>
Reviewed-by: Alexander Cooper <alcooper@chromium.org>
Cr-Commit-Position: refs/heads/master@{#855069}

Co-authored-by: Piotr Bialecki <bialpio@chromium.org>
--

wpt-commits: 600217b448f36f7a8828b38fbc494e978618d170
wpt-pr: 27654

testing/web-platform/tests/resources/chromium/webxr-test.js

@@ -337,6 +337,7 @@ class MockRuntime {
     'dom-overlay': vrMojom.XRSessionFeature.DOM_OVERLAY,
     'light-estimation': vrMojom.XRSessionFeature.LIGHT_ESTIMATION,
     'anchors': vrMojom.XRSessionFeature.ANCHORS,
+    'depth-sensing': vrMojom.XRSessionFeature.DEPTH,
   };
 
   static sessionModeToMojoMap = {
@@ -387,6 +388,9 @@ class MockRuntime {
     // Anchor creation callback (initially null, can be set by tests).
     this.anchor_creation_callback_ = null;
 
+    this.depthSensingData_ = null;
+    this.depthSensingDataDirty_ = false;
+
     let supportedModes = [];
     if (fakeDeviceInit.supportedModes) {
       supportedModes = fakeDeviceInit.supportedModes.slice();
@@ -433,6 +437,10 @@ class MockRuntime {
       this.world_ = fakeDeviceInit.world;
     }
 
+    if (fakeDeviceInit.depthSensingData) {
+      this.setDepthSensingData(fakeDeviceInit.depthSensingData);
+    }
+
     this.defaultFramebufferScale_ = default_framebuffer_scale;
     this.enviromentBlendMode_ = this._convertBlendModeToEnum(fakeDeviceInit.environmentBlendMode);
     this.interactionMode_ = this._convertInteractionModeToEnum(fakeDeviceInit.interactionMode);
@@ -675,6 +683,32 @@ class MockRuntime {
     }
   }
 
+  setDepthSensingData(depthSensingData) {
+    for(const key of ["depthData", "normDepthBufferFromNormView", "rawValueToMeters", "width", "height"]) {
+      if(!(key in depthSensingData)) {
+        throw new TypeError("Required key not present. Key: " + key);
+      }
+    }
+
+    if(depthSensingData.depthData != null) {
+      // Create new object w/ properties based on the depthSensingData, but
+      // convert the FakeXRRigidTransformInit into a transformation matrix object.
+      this.depthSensingData_ = Object.assign({},
+        depthSensingData, {
+          normDepthBufferFromNormView: composeGFXTransform(depthSensingData.normDepthBufferFromNormView),
+        });
+    } else {
+      throw new TypeError("`depthData` is not set");
+    }
+
+    this.depthSensingDataDirty_ = true;
+  }
+
+  clearDepthSensingData() {
+    this.depthSensingData_ = null;
+    this.depthSensingDataDirty_ = true;
+  }
+
   // Helper methods
   getNonImmersiveDisplayInfo() {
     const displayInfo = this.getImmersiveDisplayInfo();
@@ -857,6 +891,8 @@ class MockRuntime {
 
         this._calculateAnchorInformation(frameData);
 
+        this._calculateDepthInformation(frameData);
+
         this._injectAdditionalFrameData(options, frameData);
 
         resolve({frameData});
@@ -1119,6 +1155,8 @@ class MockRuntime {
           }
         }
 
+        this.enabledFeatures_ = enabled_features;
+
         return Promise.resolve({
           session: {
             submitFrameSink: submit_frame_sink,
@@ -1129,7 +1167,12 @@ class MockRuntime {
             deviceConfig: {
               usesInputEventing: false,
               defaultFramebufferScale: this.defaultFramebufferScale_,
-              supportsViewportScaling: true
+              supportsViewportScaling: true,
+              depthConfiguration:
+                enabled_features.includes(vrMojom.XRSessionFeature.DEPTH) ? {
+                  depthUsage: vrMojom.XRDepthUsage.kCPUOptimized,
+                  depthDataFormat: vrMojom.XRDepthDataFormat.kLuminanceAlpha,
+                } : null,
             },
             enviromentBlendMode: this.enviromentBlendMode_,
             interactionMode: this.interactionMode_
@@ -1142,8 +1185,16 @@ class MockRuntime {
   }
 
   runtimeSupportsSession(options) {
+    let result = this.supportedModes_.includes(options.mode);
+
+    if (options.requiredFeatures.includes(vrMojom.XRSessionFeature.DEPTH)
+    || options.optionalFeatures.includes(vrMojom.XRSessionFeature.DEPTH)) {
+      result &= options.depthOptions.usagePreferences.includes(vrMojom.XRDepthUsage.kCPUOptimized);
+      result &= options.depthOptions.dataFormatPreferences.includes(vrMojom.XRDepthDataFormat.kLuminanceAlpha);
+    }
+
     return Promise.resolve({
-      supportsSession: this.supportedModes_.includes(options.mode)
+      supportsSession: result,
     });
   }
 
@@ -1199,6 +1250,43 @@ class MockRuntime {
     }
   }
 
+  // Private functions - depth sensing implementation:
+
+  // Modifies passed in frameData to add anchor information.
+  _calculateDepthInformation(frameData) {
+    if (!this.supportedModes_.includes(vrMojom.XRSessionMode.kImmersiveAr)) {
+      return;
+    }
+
+    if (!this.enabledFeatures_.includes(vrMojom.XRSessionFeature.DEPTH)) {
+      return;
+    }
+
+    // If we don't have a current depth data, we'll return null
+    // (i.e. no data is not a valid data, so it cannot be "StillValid").
+    if (this.depthSensingData_ == null) {
+      frameData.depthData = null;
+      return;
+    }
+
+    if(!this.depthSensingDataDirty_) {
+      frameData.depthData = { dataStillValid: {}};
+      return;
+    }
+
+    frameData.depthData = {
+      updatedDepthData: {
+        timeDelta: frameData.timeDelta,
+        normTextureFromNormView: this.depthSensingData_.normDepthBufferFromNormView,
+        rawValueToMeters: this.depthSensingData_.rawValueToMeters,
+        size: { width: this.depthSensingData_.width, height: this.depthSensingData_.height },
+        pixelData: { bytes: this.depthSensingData_.depthData }
+      }
+    };
+
+    this.depthSensingDataDirty_ = false;
+  }
+
   // Private functions - hit test implementation:
 
   // Returns a Promise<bool> that signifies whether hit test source creation should succeed.

testing/web-platform/tests/webxr/depth-sensing/cpu/depth_sensing_cpu_dataUnavailable.https.html

@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../../resources/webxr_util.js"></script>
+<script src="../../resources/webxr_test_asserts.js"></script>
+<script src="../../resources/webxr_test_constants.js"></script>
+<script src="../../resources/webxr_test_constants_fake_depth.js"></script>
+<script src="../dataUnavailableTests.js"></script>
+
+<script>
+
+const fakeDeviceInitParams = {
+  supportedModes: ["immersive-ar"],
+  views: VALID_VIEWS,
+  supportedFeatures: ALL_FEATURES,
+  depthSensingData: DEPTH_SENSING_DATA,
+};
+
+xr_session_promise_test("Ensures depth data is not available when cleared in the controller, `cpu-optimized`",
+  dataUnavailableTestFunctionGenerator(/*isCpuOptimized=*/true),
+  fakeDeviceInitParams,
+  'immersive-ar', {
+    requiredFeatures: ['depth-sensing'],
+    depthSensing: VALID_DEPTH_CONFIG_CPU_USAGE,
+  });
+
+</script>

testing/web-platform/tests/webxr/depth-sensing/cpu/depth_sensing_cpu_inactiveFrame.https.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../../resources/webxr_util.js"></script>
+<script src="../../resources/webxr_test_asserts.js"></script>
+<script src="../../resources/webxr_test_constants.js"></script>
+<script src="../../resources/webxr_test_constants_fake_depth.js"></script>
+<script src="../inactiveFrameTests.js"></script>
+
+<script>
+
+const fakeDeviceInitParams = {
+  supportedModes: ["immersive-ar"],
+  views: VALID_VIEWS,
+  supportedFeatures: ALL_FEATURES,
+};
+
+xr_session_promise_test("Ensures getDepthInformation() throws when not run in an active frame, `cpu-optimized`",
+  inactiveFrameTestFunctionGenerator(/*isCpuOptimized=*/true),
+  fakeDeviceInitParams,
+  'immersive-ar', {
+    requiredFeatures: ['depth-sensing'],
+    depthSensing: VALID_DEPTH_CONFIG_CPU_USAGE,
+  });
+
+</script>

testing/web-platform/tests/webxr/depth-sensing/cpu/depth_sensing_cpu_incorrectUsage.https.html

@@ -0,0 +1,48 @@
+<!DOCTYPE html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../../resources/webxr_util.js"></script>
+<script src="../../resources/webxr_test_asserts.js"></script>
+<script src="../../resources/webxr_test_constants.js"></script>
+<script src="../../resources/webxr_test_constants_fake_depth.js"></script>
+<script src="../incorrectUsageTests.js"></script>
+
+<script>
+
+const fakeDeviceInitParams = {
+  supportedModes: ["immersive-ar"],
+  views: VALID_VIEWS,
+  supportedFeatures: ALL_FEATURES,
+};
+
+const incorrectUsagetestFunctionTryGetWebGLOnCpu = function (session, controller, t, sessionObjects) {
+  return session.requestReferenceSpace('viewer').then((viewerSpace) => {
+    let done = false;
+
+    const glBinding = new XRWebGLBinding(session, sessionObjects.gl);
+
+    session.requestAnimationFrame((time, frame) => {
+      const pose = frame.getViewerPose(viewerSpace);
+      for(const view of pose.views) {
+        t.step(() => {
+          assert_throws_dom("InvalidStateError", () => glBinding.getDepthInformation(view),
+                            "XRWebGLBinding.getDepthInformation() should throw when depth sensing is in `cpu-optimized` usage mode");
+        });
+      }
+
+      done = true;
+    });
+
+    return t.step_wait(() => done);
+  });
+};
+
+xr_session_promise_test("Ensures XRWebGLDepthInformation is not obtainable in `cpu-optimized` usage mode",
+  incorrectUsagetestFunctionTryGetWebGLOnCpu,
+  fakeDeviceInitParams,
+  'immersive-ar', {
+    requiredFeatures: ['depth-sensing'],
+    depthSensing: VALID_DEPTH_CONFIG_CPU_USAGE,
+  });
+
+</script>

testing/web-platform/tests/webxr/depth-sensing/cpu/depth_sensing_cpu_luminance_alpha_dataValid.https.html

@@ -0,0 +1,106 @@
+<!DOCTYPE html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../../resources/webxr_util.js"></script>
+<script src="../../resources/webxr_math_utils.js"></script>
+<script src="../../resources/webxr_test_asserts.js"></script>
+<script src="../../resources/webxr_test_constants.js"></script>
+<script src="../../resources/webxr_test_constants_fake_depth.js"></script>
+
+<script>
+
+const fakeDeviceInitParams = {
+  supportedModes: ["immersive-ar"],
+  views: VALID_VIEWS,
+  supportedFeatures: ALL_FEATURES,
+  depthSensingData: DEPTH_SENSING_DATA,
+};
+
+const assert_depth_valid_at = function(depthInformation, row, column, deltaRow, deltaColumn) {
+  // column and row correspond to the depth buffer coordinates,
+  // *not* to normalized view coordinates the getDepthInMeters() expects.
+
+  const expectedValue = getExpectedValueAt(column, row);
+
+  // 1. Normalize:
+  let x = (column + deltaColumn) / depthInformation.width;
+  let y = (row + deltaRow) / depthInformation.height;
+
+  // 2. Apply the transform that changes the origin and axes:
+  x = 1.0 - x;
+  y = 1.0 - y;
+
+  const depthValue = depthInformation.getDepthInMeters(x, y);
+  assert_approx_equals(depthValue, expectedValue, FLOAT_EPSILON,
+                        "Depth value at (" + column + "," + row + "), deltas=(" + deltaColumn + ", " + deltaRow + "), "
+                        + "coordinates (" + x + "," + y + ") must match!");
+}
+
+const assert_depth_valid = function(depthInformation) {
+  for(let row = 0; row < depthInformation.height; row++) {
+    for(let column = 0; column < depthInformation.width; column++) {
+      // middle of the pixel:
+      assert_depth_valid_at(depthInformation, row, column, 0.5, 0.5);
+
+      // corners of the pixel:
+      assert_depth_valid_at(depthInformation, row, column, FLOAT_EPSILON, FLOAT_EPSILON);
+      assert_depth_valid_at(depthInformation, row, column, FLOAT_EPSILON, 1 - FLOAT_EPSILON);
+      assert_depth_valid_at(depthInformation, row, column, 1 - FLOAT_EPSILON, FLOAT_EPSILON);
+      assert_depth_valid_at(depthInformation, row, column, 1 - FLOAT_EPSILON, 1 - FLOAT_EPSILON);
+    }
+  }
+
+  // Verify out-of-bounds accesses throw:
+  assert_throws_js(RangeError,
+                   () => depthInformation.getDepthInMeters(-FLOAT_EPSILON, 0.0),
+                   "getDepthInMeters() should throw when run with invalid indices - negative x");
+  assert_throws_js(RangeError,
+                   () => depthInformation.getDepthInMeters(0.0, -FLOAT_EPSILON),
+                   "getDepthInMeters() should throw when run with invalid indices - negative y");
+  assert_throws_js(RangeError,
+                   () => depthInformation.getDepthInMeters(1+FLOAT_EPSILON, 0.0),
+                   "getDepthInMeters() should throw when run with invalid indices - too big x");
+  assert_throws_js(RangeError,
+                   () => depthInformation.getDepthInMeters(0.0, 1+FLOAT_EPSILON),
+                   "getDepthInMeters() should throw when run with invalid indices - too big y");
+};
+
+const testCpuOptimizedLuminanceAlpha = function(session, fakeDeviceController, t) {
+  return session.requestReferenceSpace('viewer').then((viewerSpace) => {
+    let done = false;
+
+    const rafCallback = function(time, frame) {
+      const pose = frame.getViewerPose(viewerSpace);
+      if(pose) {
+        for(const view of pose.views) {
+          const depthInformation = frame.getDepthInformation(view);
+
+          t.step(() => {
+            assert_not_equals(depthInformation, null, "XRCPUDepthInformation must not be null!");
+            assert_approx_equals(depthInformation.width, DEPTH_SENSING_DATA.width, FLOAT_EPSILON);
+            assert_approx_equals(depthInformation.height, DEPTH_SENSING_DATA.height, FLOAT_EPSILON);
+            assert_approx_equals(depthInformation.rawValueToMeters, DEPTH_SENSING_DATA.rawValueToMeters, FLOAT_EPSILON);
+            assert_transform_approx_equals(depthInformation.normDepthBufferFromNormView, DEPTH_SENSING_DATA.normDepthBufferFromNormView);
+            assert_depth_valid(depthInformation);
+          });
+        }
+      }
+
+      done = true;
+    };
+
+    session.requestAnimationFrame(rafCallback);
+
+    return t.step_wait(() => done);
+  });
+};
+
+xr_session_promise_test("Ensures depth data is returned and values match expectation, cpu-optimized, luminance-alpha.",
+  testCpuOptimizedLuminanceAlpha,
+  fakeDeviceInitParams,
+  'immersive-ar', {
+    'requiredFeatures': ['depth-sensing'],
+    depthSensing: VALID_DEPTH_CONFIG_CPU_USAGE,
+  });
+
+</script>

testing/web-platform/tests/webxr/depth-sensing/cpu/depth_sensing_cpu_staleView.https.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../../resources/webxr_util.js"></script>
+<script src="../../resources/webxr_test_asserts.js"></script>
+<script src="../../resources/webxr_test_constants.js"></script>
+<script src="../../resources/webxr_test_constants_fake_depth.js"></script>
+<script src="../staleViewsTests.js"></script>
+
+<script>
+
+const fakeDeviceInitParams = {
+  supportedModes: ["immersive-ar"],
+  views: VALID_VIEWS,
+  supportedFeatures: ALL_FEATURES,
+};
+
+xr_session_promise_test("Ensures getDepthInformation() throws when run with stale XRView, `cpu-optimized`",
+  staleViewsTestFunctionGenerator(/*isCpuOptimized=*/true),
+  fakeDeviceInitParams,
+  'immersive-ar', {
+    requiredFeatures: ['depth-sensing'],
+    depthSensing: VALID_DEPTH_CONFIG_CPU_USAGE,
+  });
+
+</script>

testing/web-platform/tests/webxr/depth-sensing/dataUnavailableTests.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const TestStates = Object.freeze({
+  "ShouldSucceedScheduleRAF": 1,
+  "ShouldFailScheduleRAF": 2,
+  "ShouldSucceedTestDone": 3,
+});
+
+const dataUnavailableTestFunctionGenerator = function(isCpuOptimized) {
+  return (session, controller, t, sessionObjects) => {
+    let state = TestStates.ShouldSucceedScheduleRAF;
+
+    return session.requestReferenceSpace('viewer').then((viewerSpace) => {
+      let done = false;
+
+      const glBinding = new XRWebGLBinding(session, sessionObjects.gl);
+
+      const rafCb = function(time, frame) {
+        const pose = frame.getViewerPose(viewerSpace);
+        for(const view of pose.views) {
+          const depthInformation = isCpuOptimized ? frame.getDepthInformation(view)
+                                                  : glBinding.getDepthInformation(view);
+
+          if (state == TestStates.ShouldSucceedScheduleRAF
+          || state == TestStates.ShouldSucceedTestDone) {
+            t.step(() => {
+              assert_not_equals(depthInformation, null);
+            });
+          } else {
+            t.step(() => {
+              assert_equals(depthInformation, null);
+            });
+          }
+        }
+
+        switch(state) {
+          case TestStates.ShouldSucceedScheduleRAF:
+            controller.clearDepthSensingData();
+            state = TestStates.ShouldFailScheduleRAF;
+            session.requestAnimationFrame(rafCb);
+            break;
+          case TestStates.ShouldFailScheduleRAF:
+            controller.setDepthSensingData(DEPTH_SENSING_DATA);
+            state = TestStates.ShouldSucceedTestDone;
+            session.requestAnimationFrame(rafCb);
+            break;
+          case TestStates.ShouldSucceedTestDone:
+            done = true;
+            break;
+        }
+      };
+
+      session.requestAnimationFrame(rafCb);
+
+      return t.step_wait(() => done);
+    });
+  };
+};

testing/web-platform/tests/webxr/depth-sensing/depth_sensing_notEnabled.https.html

@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script src="../resources/webxr_util.js"></script>
+<script src="../resources/webxr_test_constants.js"></script>
+
+<script>
+
+const testFunctionCpu = function (session, controller, t) {
+  return session.requestReferenceSpace('viewer').then((viewerSpace) => {
+    let done = false;
+
+    session.requestAnimationFrame((time, frame) => {
+      const pose = frame.getViewerPose(viewerSpace);
+      for(const view of pose.views) {
+        assert_throws_dom("NotSupportedError", () => frame.getDepthInformation(view),
+                          "getDepthInformation() should throw when depth sensing is disabled");
+      }
+
+      done = true;
+    });
+
+    return t.step_wait(() => done);
+  });
+};
+
+const testFunctionGpu = function (session, controller, t, sessionObjects) {
+  return session.requestReferenceSpace('viewer').then((viewerSpace) => {
+    let done = false;
+
+    const glBinding = new XRWebGLBinding(session, sessionObjects.gl);
+
+    session.requestAnimationFrame((time, frame) => {
+      const pose = frame.getViewerPose(viewerSpace);
+      for(const view of pose.views) {
+        t.step(() => {
+          assert_throws_dom("NotSupportedError", () => glBinding.getDepthInformation(view),
+                            "getDepthInformation() should throw when depth sensing is disabled");
+        });
+      }
+
+      done = true;
+    });
+
+    return t.step_wait(() => done);
+  });
+};
+
+xr_session_promise_test(
+  "XRFrame.getDepthInformation() rejects if depth sensing is not enabled on a session",
+  testFunctionCpu,
+  IMMERSIVE_AR_DEVICE,
+  'immersive-ar');
+
+xr_session_promise_test(
+  "XRWebGLBinding.getDepthInformation() rejects if depth sensing is not enabled on a session",
+  testFunctionGpu,
+  IMMERSIVE_AR_DEVICE,
+  'immersive-ar');
+
+</script>

testing/web-platform/tests/webxr/depth-sensing/gpu/depth_sensing_gpu_dataUnavailable.https.html

@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../../resources/webxr_util.js"></script>
+<script src="../../resources/webxr_test_asserts.js"></script>
+<script src="../../resources/webxr_test_constants.js"></script>
+<script src="../../resources/webxr_test_constants_fake_depth.js"></script>
+<script src="../dataUnavailableTests.js"></script>
+
+<script>
+
+const fakeDeviceInitParams = {
+  supportedModes: ["immersive-ar"],
+  views: VALID_VIEWS,
+  supportedFeatures: ALL_FEATURES,
+  depthSensingData: DEPTH_SENSING_DATA,
+};
+
+xr_session_promise_test("Ensures depth data is not available when cleared in the controller, `gpu-optimized`",
+  dataUnavailableTestFunctionGenerator(/*isCpuOptimized=*/false),
+  fakeDeviceInitParams,
+  'immersive-ar', {
+    requiredFeatures: ['depth-sensing'],
+    depthSensing: VALID_DEPTH_CONFIG_GPU_USAGE,
+  });
+
+</script>

testing/web-platform/tests/webxr/depth-sensing/gpu/depth_sensing_gpu_inactiveFrame.https.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../../resources/webxr_util.js"></script>
+<script src="../../resources/webxr_test_asserts.js"></script>
+<script src="../../resources/webxr_test_constants.js"></script>
+<script src="../../resources/webxr_test_constants_fake_depth.js"></script>
+<script src="../inactiveFrameTests.js"></script>
+
+<script>
+
+const fakeDeviceInitParams = {
+  supportedModes: ["immersive-ar"],
+  views: VALID_VIEWS,
+  supportedFeatures: ALL_FEATURES,
+};
+
+xr_session_promise_test("Ensures getDepthInformation() throws when not run in an active frame, `gpu-optimized`",
+  testFunctionGenerator(/*isCpuOptimized=*/false),
+  fakeDeviceInitParams,
+  'immersive-ar', {
+    requiredFeatures: ['depth-sensing'],
+    depthSensing: VALID_DEPTH_CONFIG_GPU_USAGE,
+  });
+
+</script>

testing/web-platform/tests/webxr/depth-sensing/gpu/depth_sensing_gpu_incorrectUsage.https.html

@@ -0,0 +1,46 @@
+<!DOCTYPE html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../../resources/webxr_util.js"></script>
+<script src="../../resources/webxr_test_asserts.js"></script>
+<script src="../../resources/webxr_test_constants.js"></script>
+<script src="../../resources/webxr_test_constants_fake_depth.js"></script>
+<script src="../incorrectUsageTests.js"></script>
+
+<script>
+
+const fakeDeviceInitParams = {
+  supportedModes: ["immersive-ar"],
+  views: VALID_VIEWS,
+  supportedFeatures: ALL_FEATURES,
+};
+
+const incorrectUsageTestFunctionTryGetCpuOnGpu = function (session, controller, t, sessionObjects) {
+  return session.requestReferenceSpace('viewer').then((viewerSpace) => {
+    let done = false;
+
+    session.requestAnimationFrame((time, frame) => {
+      const pose = frame.getViewerPose(viewerSpace);
+      for(const view of pose.views) {
+        t.step(() => {
+          assert_throws_dom("InvalidStateError", () => frame.getDepthInformation(view),
+                            "XRFrame.getDepthInformation() should throw when depth sensing is in `gpu-optimized` usage mode");
+        });
+      }
+
+      done = true;
+    });
+
+    return t.step_wait(() => done);
+  });
+};
+
+xr_session_promise_test("Ensures XRCPUDepthInformation is not obtainable in `gpu-optimized` usage mode",
+  incorrectUsageTestFunctionTryGetCpuOnGpu,
+  fakeDeviceInitParams,
+  'immersive-ar', {
+    requiredFeatures: ['depth-sensing'],
+    depthSensing: VALID_DEPTH_CONFIG_GPU_USAGE,
+  });
+
+</script>

testing/web-platform/tests/webxr/depth-sensing/gpu/depth_sensing_gpu_staleView.https.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="../../resources/webxr_util.js"></script>
+<script src="../../resources/webxr_test_asserts.js"></script>
+<script src="../../resources/webxr_test_constants.js"></script>
+<script src="../../resources/webxr_test_constants_fake_depth.js"></script>
+<script src="../staleViewsTests.js"></script>
+
+<script>
+
+const fakeDeviceInitParams = {
+  supportedModes: ["immersive-ar"],
+  views: VALID_VIEWS,
+  supportedFeatures: ALL_FEATURES,
+};
+
+xr_session_promise_test("Ensures getDepthInformation() throws when not run with stale XRView, `gpu-optimized`",
+  staleViewsTestFunctionGenerator(/*isCpuOptimized=*/false),
+  fakeDeviceInitParams,
+  'immersive-ar', {
+    requiredFeatures: ['depth-sensing'],
+    depthSensing: VALID_DEPTH_CONFIG_GPU_USAGE,
+  });
+
+</script>

testing/web-platform/tests/webxr/depth-sensing/inactiveFrameTests.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const inactiveFrameTestFunctionGenerator = function(isCpuOptimized) {
+  return (session, controller, t, sessionObjects) => {
+    return session.requestReferenceSpace('viewer').then((viewerSpace) => {
+      let callbacksKickedOff = false;
+      let callbackCounter = 0;
+
+      const glBinding = new XRWebGLBinding(session, sessionObjects.gl);
+
+      const rafCb = function(time, frame) {
+        const pose = frame.getViewerPose(viewerSpace);
+        for(const view of pose.views) {
+          const callback = () => {
+            t.step(() => {
+              assert_throws_dom("InvalidStateError",
+                                () => isCpuOptimized ? frame.getDepthInformation(view)
+                                                     : glBinding.getDepthInformation(view),
+                                "getDepthInformation() should throw when ran outside RAF");
+            });
+            callbackCounter--;
+          }
+
+          t.step_timeout(callback, 10);
+          callbackCounter++;
+        }
+
+        callbacksKickedOff = true;
+      };
+
+      session.requestAnimationFrame(rafCb);
+
+      return t.step_wait(() => callbacksKickedOff && (callbackCounter == 0));
+    });
+  };
+};

testing/web-platform/tests/webxr/depth-sensing/staleViewsTests.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const staleViewsTestFunctionGenerator = function(isCpuOptimized) {
+  return (session, controller, t, sessionObjects) => {
+    let done = false;
+
+    const staleViews = new Set();
+
+    return session.requestReferenceSpace('viewer').then((viewerSpace) => {
+      const glBinding = new XRWebGLBinding(session, sessionObjects.gl);
+
+      const secondRafCb = function(time, frame) {
+        for(const view of staleViews) {
+          t.step(() => {
+            assert_throws_dom("InvalidStateError",
+                                () => isCpuOptimized ? frame.getDepthInformation(view)
+                                                     : glBinding.getDepthInformation(view),
+                                "getDepthInformation() should throw when run with stale XRView");
+          });
+        }
+
+        done = true;
+      };
+
+      const firstRafCb = function(time, frame) {
+        const pose = frame.getViewerPose(viewerSpace);
+        for(const view of pose.views) {
+          staleViews.add(view);
+        }
+
+        session.requestAnimationFrame(secondRafCb);
+      };
+
+      session.requestAnimationFrame(firstRafCb);
+
+      return t.step_wait(() => done);
+    });
+  };
+};

testing/web-platform/tests/webxr/resources/webxr_test_constants.js

@@ -125,6 +125,7 @@ const ALL_FEATURES = [
   'dom-overlay',
   'light-estimation',
   'anchors',
+  'depth-sensing',
 ];
 
 const TRACKED_IMMERSIVE_DEVICE = {

testing/web-platform/tests/webxr/resources/webxr_test_constants_fake_depth.js

@@ -0,0 +1,78 @@
+'use strict';
+
+// This file introduces constants used to mock depth data for depth sensing API.
+
+const convertDepthBufferToArrayBuffer = function (data, desiredFormat) {
+  if(desiredFormat == "luminance-alpha") {
+    const result = new ArrayBuffer(data.length * 2);  // each entry has 2 bytes
+    const view = new Uint16Array(result);
+
+    for(let i = 0; i < data.length; ++i) {
+      view[i] = data[i];
+    }
+
+    return new Uint8Array(result);
+  } else if(desiredFormat == "float32") {
+    const result = new ArrayBuffer(data.length * 4);  // each entry has 4 bytes
+    const view = new Float32Array(result);
+
+    for(let i = 0; i < data.length; ++i) {
+      view[i] = data[i];
+    }
+
+    return new Uint8Array(result);
+  } else {
+    throw new Error("Unrecognized data format!");
+  }
+}
+
+// Let's assume that the depth values are in cm, Xcm = x * 1/100m
+const RAW_VALUE_TO_METERS = 1/100;
+
+const createDepthSensingData = function() {
+  const depthSensingBufferHeight = 5;
+  const depthSensingBufferWidth = 7;
+  const depthSensingBuffer = [
+    1,  1,  1,   1,   1,    1,    1,  // first row
+    1,  2,  3,   4,   5,    6,    7,
+    1,  4,  9,  16,  25,   36,   49,
+    1,  8, 27,  64, 125,  216,  343,
+    1, 16, 81, 256, 625, 1296, 2401,
+  ];  // depthSensingBuffer value at column c, row r is Math.pow(c+1, r).
+
+  // Let's assume that the origin of the depth buffer is in the bottom right
+  // corner, with X's growing to the left and Y's growing upwards.
+  // This corresponds to the origin at 2401 in the above matrix, with X axis
+  // growing from 2401 towards 1296, and Y axis growing from 2401 towards 343.
+  // This corresponds to a rotation around Z axis by 180 degrees, with origin at [1,1].
+  const depthSensingBufferFromViewerTransform = {
+    position: [1, 1, 0],
+    orientation: [0, 0, 1, 0],
+  };
+
+  return {
+    depthData: convertDepthBufferToArrayBuffer(depthSensingBuffer, "luminance-alpha"),
+    width: depthSensingBufferWidth,
+    height: depthSensingBufferHeight,
+    normDepthBufferFromNormView: depthSensingBufferFromViewerTransform,
+    rawValueToMeters: RAW_VALUE_TO_METERS,
+  };
+};
+
+const DEPTH_SENSING_DATA = createDepthSensingData();
+
+// Returns expected depth value at |column|, |row| coordinates, expressed
+// in depth buffer's coordinate system.
+const getExpectedValueAt = function(column, row) {
+  return Math.pow(column+1, row) * RAW_VALUE_TO_METERS;
+};
+
+const VALID_DEPTH_CONFIG_CPU_USAGE = {
+  usagePreference: ['cpu-optimized'],
+  dataFormatPreference: ['luminance-alpha', 'float32'],
+};
+
+const VALID_DEPTH_CONFIG_GPU_USAGE = {
+  usagePreference: ['gpu-optimized'],
+  dataFormatPreference: ['luminance-alpha', 'float32'],
+};

testing/web-platform/tests/webxr/resources/webxr_util.js

@@ -18,7 +18,7 @@ function xr_promise_test(name, func, properties, glContextType, glContextPropert
     // Perform any required test setup:
     xr_debug(name, 'setup');
 
-    assert_implements(navigator.xr, 'missing navigator.xr');
+    assert_implements(navigator.xr, 'missing navigator.xr - ensure test is run in a secure context.');
 
     // Only set up once.
     if (!navigator.xr.test) {
@@ -88,7 +88,8 @@ function requestSkipAnimationFrame(session, callback) {
 // Calls the passed in test function with the session, the controller for the
 // device, and the test object.
 function xr_session_promise_test(
-    name, func, fakeDeviceInit, sessionMode, sessionInit, properties, glcontextPropertiesParam, gllayerPropertiesParam) {
+    name, func, fakeDeviceInit, sessionMode, sessionInit, properties,
+    glcontextPropertiesParam, gllayerPropertiesParam) {
   const glcontextProperties = (glcontextPropertiesParam) ? glcontextPropertiesParam : {};
   const gllayerProperties = (gllayerPropertiesParam) ? gllayerPropertiesParam : {};
 
@@ -133,7 +134,11 @@ function xr_session_promise_test(
                         });
                         sessionObjects.glLayer = glLayer;
                         xr_debug(name, 'session.visibilityState=' + session.visibilityState);
+                        try {
                           resolve(func(session, testDeviceController, t, sessionObjects));
+                        } catch(err) {
+                          reject("Test function failed with: " + err);
+                        }
                       })
                       .catch((err) => {
                         xr_debug(name, 'error: ' + err);