Revert "Move XR LayoutTests over to be WPTs"

This reverts commit f4c510e1.

Reason for revert:

Findit (https://goo.gl/kROfz5) identified CL at revision 585064 as the
culprit for failures in the build cycles as shown on:
https://findit-for-me.appspot.com/waterfall/culprit?key=ag9zfmZpbmRpdC1mb3ItbWVyRAsSDVdmU3VzcGVjdGVkQ0wiMWNocm9taXVtL2Y0YzUxMGUxY2IyY2NkYzBjZTA3YjA2MGJlOWFkNTJmOGVkYTVjYjgM

Sample Failed Build: https://ci.chromium.org/buildbot/chromium.webkit/WebKit%20Linux%20Trusty%20Leak/23378

Sample Failed Step: webkit_layout_tests

Original change's description:
> Move XR LayoutTests over to be WPTs
> 
> Moving as many of the WebXR LayoutTests as possible over to be
> WebPlatformTests. All the tests that have been moved test some
> aspect of the spec (https://immersive-web.github.io/webxr/) in
> a platform agnostic way.
> 
> Bug: 863557, 844772
> Change-Id: I203b4c59be0daa0ca624fb0281fc33035f1be8a1
> Reviewed-on: https://chromium-review.googlesource.com/1171857
> Reviewed-by: Brandon Jones <bajones@chromium.org>
> Reviewed-by: Brian Sheedy <bsheedy@chromium.org>
> Commit-Queue: Anna Offenwanger <offenwanger@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#585064}

Change-Id: Ief847c4b554eea132e2b3d5ea0431c1acf6c34c2
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 863557, 844772
Reviewed-on: https://chromium-review.googlesource.com/1185383
Cr-Commit-Position: refs/heads/master@{#585155}

third_party/WebKit/LayoutTests/external/wpt/resources/chromium/webxr-test.js

@@ -9,11 +9,7 @@ class ChromeXRTest {
   }
 
   simulateDeviceConnection(init_params) {
-    return Promise.resolve(this.mockVRService_.addRuntime(init_params));
-  }
-
-  simulateDeviceDisconnection(device) {
-    this.mockVRService_.removeRuntime(device);
+    return Promise.resolve(this.mockVRService_.addDevice(init_params));
   }
 
   simulateUserActivation(callback) {
@@ -34,12 +30,10 @@ class ChromeXRTest {
 }
 
 // Mocking class definitions
-
-// Mock service implements both the VRService and XRDevice mojo interfaces.
 class MockVRService {
   constructor() {
     this.bindingSet_ = new mojo.BindingSet(device.mojom.VRService);
-    this.runtimes_ = [];
+    this.devices_ = [];
 
     this.interceptor_ =
         new MojoInterfaceInterceptor(device.mojom.VRService.name);
@@ -49,87 +43,31 @@ class MockVRService {
   }
 
   // Test methods
-  addRuntime(fakeDeviceInit) {
-    let runtime = new MockRuntime(fakeDeviceInit, this);
-    this.runtimes_.push(runtime);
+  addDevice(fakeDeviceInit) {
+    let device = new MockDevice(fakeDeviceInit, this);
+    this.devices_.push(device);
 
     if (this.client_) {
       this.client_.onDeviceChanged();
     }
 
-    return runtime;
-  }
-
-  removeRuntime(runtime) {
-    // We have no way of distinguishing between devices, so just clear the
-    // entire list for now.
-    // TODO(http://crbug.com/873409) We also have no way right now to disconnect
-    // devices.
-    this.runtimes_ = [];
+    return device;
   }
 
   // VRService implementation.
   requestDevice() {
-    if (this.runtimes_.length > 0) {
-      let devicePtr = new device.mojom.XRDevicePtr();
-      new mojo.Binding(
-          device.mojom.XRDevice, this, mojo.makeRequest(devicePtr));
-
-      return Promise.resolve({device: devicePtr});
-    } else {
-      return Promise.resolve({device: null});
-    }
+    return Promise.resolve(
+        {device: this.devices_[0] ? this.devices_[0].getDevicePtr() : null});
   }
 
   setClient(client) {
     this.client_ = client;
   }
-
-  // XRDevice implementation.
-  requestSession(sessionOptions, was_activation) {
-    let requests = [];
-    // Request a session from all the runtimes.
-    for (let i = 0; i < this.runtimes_.length; i++) {
-      requests[i] = this.runtimes_[i].requestRuntimeSession(sessionOptions);
-    }
-
-    return Promise.all(requests).then((results) => {
-      // Find and return the first successful result.
-      for (let i = 0; i < results.length; i++) {
-        if (results[i].session) {
-          return results[i];
-        }
-      }
-
-      // If there were no successful results, returns a null session.
-      return {session: null};
-    });
-  }
-
-  supportsSession(sessionOptions) {
-    let requests = [];
-    // Check supports on all the runtimes.
-    for (let i = 0; i < this.runtimes_.length; i++) {
-      requests[i] = this.runtimes_[i].runtimeSupportsSession(sessionOptions);
-    }
-
-    return Promise.all(requests).then((results) => {
-      // Find and return the first successful result.
-      for (let i = 0; i < results.length; i++) {
-        if (results[i].supportsSession) {
-          return results[i];
-        }
-      }
-
-      // If there were no successful results, returns false.
-      return {supportsSession: false};
-    });
-  };
 }
 
-// Implements XRFrameDataProvider and XRPresentationProvider. Maintains a mock
-// for XRPresentationProvider.
-class MockRuntime {
+// Implements both XRDevice and VRMagicWindowProvider. Maintains a mock for
+// XRPresentationProvider.
+class MockDevice {
   constructor(fakeDeviceInit, service) {
     this.sessionClient_ = new device.mojom.XRSessionClientPtr();
     this.presentation_provider_ = new MockXRPresentationProvider();
@@ -148,6 +86,13 @@ class MockRuntime {
     }
   }
 
+  // Functions for setup.
+  getDevicePtr() {
+    let devicePtr = new device.mojom.XRDevicePtr();
+    new mojo.Binding(device.mojom.XRDevice, this, mojo.makeRequest(devicePtr));
+    return devicePtr;
+  }
+
   // Test methods.
   setXRPresentationFrameData(poseMatrix, views) {
     if (poseMatrix == null) {
@@ -328,10 +273,9 @@ class MockRuntime {
     // do not have any use for this data at present.
   }
 
-
-  // Utility function
-  requestRuntimeSession(sessionOptions) {
-    return this.runtimeSupportsSession(sessionOptions).then((result) => {
+  // XRDevice implementation.
+  requestSession(sessionOptions, was_activation) {
+    return this.supportsSession(sessionOptions).then((result) => {
       // The JavaScript bindings convert c_style_names to camelCase names.
       let options = new device.mojom.XRPresentationTransportOptions();
       options.transportMethod =
@@ -376,7 +320,7 @@ class MockRuntime {
     });
   }
 
-  runtimeSupportsSession(options) {
+  supportsSession(options) {
     return Promise.resolve({
       supportsSession:
           !options.immersive || this.displayInfo_.capabilities.canPresent

third_party/WebKit/LayoutTests/external/wpt/webxr/navigator_xr_requestDevice.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-
-  <script>
-    xr_promise_test("navigator.xr.requestDevice returns a device", (t) => {
-      return XRTest.simulateDeviceConnection({ supportsImmersive: true })
-        .then( (controller) => { return navigator.xr.requestDevice() })
-        .then( (device) => {
-          t.step(() => {
-            assert_true(device != null);
-            assert_true(device instanceof XRDevice);
-          });
-        });
-    });
-  </script>
-</body>

third_party/WebKit/LayoutTests/external/wpt/webxr/navigator_xr_requestDevice_no_device.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-
-  <script>
-    promise_test( (t) => {
-      return promise_rejects(t, 'NotFoundError', navigator.xr.requestDevice());
-    }, "navigator.xr.requestDevice properly rejects when there are 0 devices");
-  </script>
-</body>

third_party/WebKit/LayoutTests/external/wpt/webxr/resources/webxr_util.js

@@ -7,7 +7,7 @@
 //
 //   --enable-blink-features=MojoJS,MojoJSTest
 
-function xr_promise_test(name, func, properties) {
+function xr_promise_test(func, name, properties) {
   promise_test(async (t) => {
     // Perform any required test setup:
 
@@ -20,74 +20,6 @@ function xr_promise_test(name, func, properties) {
   }, name, properties);
 }
 
-// A test function which runs through the common steps of requesting a session.
-// Calls the passed in test function with the session, the controller for the
-// device, and the test object.
-// Requires a webglCanvas on the page.
-function xr_session_promise_test(
-    name, func, fakeDeviceInit, sessionOptions, properties) {
-  let testDevice;
-  let testDeviceController;
-  let testSession;
-
-  const webglCanvas = document.getElementsByTagName('canvas')[0];
-  if (!webglCanvas) {
-    promise_test(async (t) => {
-      Promise.reject('xr_session_promise_test requires a canvas on the page!');
-    }, name, properties);
-  }
-  let gl = webglCanvas.getContext('webgl', {alpha: false, antialias: false});
-
-  xr_promise_test(
-      name,
-      (t) =>
-          XRTest.simulateDeviceConnection(fakeDeviceInit)
-              .then((controller) => {
-                testDeviceController = controller;
-                return navigator.xr.requestDevice();
-              })
-              .then((device) => {
-                testDevice = device;
-                return gl.setCompatibleXRDevice(device);
-              })
-              .then(() => new Promise((resolve, reject) => {
-                      // Perform the session request in a user gesture.
-                      XRTest.simulateUserActivation(() => {
-                        testDevice.requestSession(sessionOptions)
-                            .then((session) => {
-                              testSession = session;
-                              // Session must have a baseLayer or frame requests
-                              // will be ignored.
-                              session.baseLayer = new XRWebGLLayer(session, gl);
-                              resolve(func(session, testDeviceController, t));
-                            })
-                            .catch((err) => {
-                              reject(
-                                  'Session with params ' +
-                                  JSON.stringify(sessionOptions) +
-                                  ' was rejected on device ' +
-                                  JSON.stringify(fakeDeviceInit) +
-                                  ' with error: ' + err);
-                            });
-                      });
-                    }))
-              .then(() => {
-                // Cleanup system state.
-                testSession.end().catch(() => {});
-                XRTest.simulateDeviceDisconnection(testDevice);
-              }),
-      properties);
-}
-
-// A utility function to create an output context as required by non-immersive
-// sessions.
-// https://immersive-web.github.io/webxr/#xrsessioncreationoptions-interface
-function getOutputContext() {
-  let outputCanvas = document.createElement('canvas');
-  document.body.appendChild(outputCanvas);
-  return outputCanvas.getContext('xrpresent');
-}
-
 // This functions calls a callback with each API object as specified
 // by https://immersive-web.github.io/webxr/spec/latest/, allowing
 // checks to be made on all ojects.
@@ -127,13 +59,8 @@ let loadChromiumResources = Promise.resolve().then(() => {
 
   let chain = Promise.resolve();
   ['/gen/layout_test_data/mojo/public/js/mojo_bindings.js',
-   '/gen/mojo/public/mojom/base/time.mojom.js',
-   '/gen/gpu/ipc/common/mailbox_holder.mojom.js',
-   '/gen/gpu/ipc/common/sync_token.mojom.js',
-   '/gen/ui/display/mojo/display.mojom.js',
    '/gen/ui/gfx/geometry/mojo/geometry.mojom.js',
-   '/gen/ui/gfx/mojo/gpu_fence_handle.mojom.js',
-   '/gen/ui/gfx/mojo/transform.mojom.js',
+   '/gen/mojo/public/mojom/base/time.mojom.js',
    '/gen/device/vr/public/mojom/vr_service.mojom.js',
    '/resources/chromium/webxr-test.js', '/resources/testdriver.js',
    '/resources/testdriver-vendor.js',

third_party/WebKit/LayoutTests/external/wpt/webxr/webGLCanvasContext_create_with_xrdevice.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <canvas id="webgl-canvas"></canvas>
-  <script>
-    xr_promise_test("webglCanvasContext can be created with an XRDevice",
-      (t) => {
-        return XRTest.simulateDeviceConnection({ supportsImmersive:true })
-          .then( (controller) => { return navigator.xr.requestDevice() })
-          .then( (device) => {
-            webglCanvas = document.getElementById('webgl-canvas');
-            gl = webglCanvas.getContext('webgl', {compatibleXRDevice: device});
-            assert_equals(gl.getContextAttributes().compatibleXRDevice, device);
-
-            // Check that an offscreen context behaves no different.
-            let offscreenCanvas = document.createElement('canvas');
-            let offscreenGl = webglCanvas.getContext(
-              'webgl', {compatibleXRDevice: device});
-            assert_equals(
-              offscreenGl.getContextAttributes().compatibleXRDevice, device);
-          });
-      });
-
-  </script>
-</body>

third_party/WebKit/LayoutTests/external/wpt/webxr/webGLCanvasContext_setdevice_contextlost.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <canvas id="webgl-canvas"></canvas>
-  <script>
-
-    xr_promise_test(
-      "A lost webglCanvasContext should not be able to set device",
-     (t) => {
-      return XRTest.simulateDeviceConnection({ supportsImmersive:true })
-        .then( (controller) => { return navigator.xr.requestDevice() })
-        .then( (device) => {
-          webglCanvas = document.getElementById('webgl-canvas');
-          gl = webglCanvas.getContext('webgl', {compatibleXRDevice: device});
-          gl.getExtension('WEBGL_lose_context').loseContext();
-          return promise_rejects(t, 'InvalidStateError',
-              gl.setCompatibleXRDevice(device));
-        });
-    });
-
-  </script>
-</body>

third_party/WebKit/LayoutTests/external/wpt/webxr/xrDevice_requestSession_immersive.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <canvas></canvas>
-  <script>
-    xr_session_promise_test(
-      "Tests requestSession resolves when supported",
-      (session) => {
-        assert_not_equals(session, null);
-      }, { supportsImmersive:true }, { immersive: true });
-  </script>
-</body>
\ No newline at end of file

third_party/WebKit/LayoutTests/external/wpt/webxr/xrDevice_requestSession_immersive_no_gesture.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <script>
-    xr_promise_test(
-      "Requesting immersive session outside of a user gesture rejects",
-      (t) => {
-        return XRTest.simulateDeviceConnection({ supportsImmersive:true })
-          .then( (controller) => { return navigator.xr.requestDevice() })
-          .then( (device) => promise_rejects(
-            t, 'SecurityError', device.requestSession({ immersive: true })));
-      });
-  </script>
-</body>

third_party/WebKit/LayoutTests/external/wpt/webxr/xrDevice_requestSession_immersive_unsupported.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <script>
-    xr_promise_test(
-      "Requesting an immersive session when unsupported rejects",
-      (t) => {
-        return XRTest.simulateDeviceConnection({ supportsImmersive:false })
-          .then( (controller) => { return navigator.xr.requestDevice() })
-          .then( (magicWindowOnlyDevice) => new Promise((resolve) => {
-            XRTest.simulateUserActivation( () => {
-              resolve(promise_rejects(
-                t,
-                "NotSupportedError",
-                magicWindowOnlyDevice.requestSession({ immersive: true })
-              ))
-            });
-          }));
-      });
-  </script>
-</body>

third_party/WebKit/LayoutTests/external/wpt/webxr/xrDevice_requestSession_non_immersive_no_gesture.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <script>
-    xr_promise_test(
-      "Requesting non-immersive session outside of a user gesture succeeds",
-      (t) => {
-        return XRTest.simulateDeviceConnection({ supportsImmersive:false })
-          .then( (controller) => { return navigator.xr.requestDevice(); })
-          .then( (device) => device.requestSession({
-            immersive: false,
-            outputContext: getOutputContext()
-          }))
-          .then( (session) => { assert_not_equals(session, null); });
-      });
-  </script>
-</body>

third_party/WebKit/LayoutTests/external/wpt/webxr/xrDevice_supportsSession_immersive.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <script>
-    xr_promise_test(
-      "supportsSession resolves when immersive options supported",
-      () => {
-        return XRTest.simulateDeviceConnection({ supportsImmersive:true })
-          .then( (controller) => { return navigator.xr.requestDevice() })
-          .then( (device) => device.supportsSession({ immersive: true }));
-      });
-  </script>
-</body>

third_party/WebKit/LayoutTests/external/wpt/webxr/xrDevice_supportsSession_immersive_unsupported.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <script>
-    xr_promise_test(
-      "supportsSession rejects when options not supported",
-      (t) => {
-      return XRTest.simulateDeviceConnection({ supportsImmersive:false })
-        .then( (controller) => { return navigator.xr.requestDevice() })
-        .then( (device) => {
-          return promise_rejects(
-            t,
-            "NotSupportedError",
-            device.supportsSession({ immersive: true })
-          );
-        });
-    });
-  </script>
-</body>

third_party/WebKit/LayoutTests/external/wpt/webxr/xrDevice_supportsSession_non_immersive.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <script>
-    xr_promise_test(
-      "supportsSession resolves when non-immersive options supported",
-      (t) => {
-      return XRTest.simulateDeviceConnection({ supportsImmersive:true })
-        .then( (controller) => { return navigator.xr.requestDevice() })
-        .then( (device) => {
-          // Non-immersive sessions without a outputContext should not be supported.
-          promise_rejects(t, 'NotSupportedError', device.supportsSession());
-
-          // Non-immersive sessions with an outputContext should be supported.
-          return device.supportsSession({
-              outputContext: getOutputContext()
-          });
-        });
-    });
-  </script>
-</body>

third_party/WebKit/LayoutTests/external/wpt/webxr/xrSession_cancelAnimationFrame.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <canvas></canvas>
-
-  <script>
-    let immersiveTestName = "XRSession requestAnimationFrame callbacks can be "
-      + "unregistered with cancelAnimationFrame for immersive sessions";
-    let nonImmersiveTestName = "XRSession requestAnimationFrame callbacks can be "
-      + "unregistered with cancelAnimationFrame for non-immersive sessions";
-
-    let fakeDeviceInitParams = { supportsImmersive:true };
-
-    let immersiveSessionOptions = { immersive: true };
-    let nonImmersiveSessionOptions = { outputContext: getOutputContext() };
-
-    let testFunction = (session) => new Promise((resolve, reject) => {
-
-      // Schedule and immediately cancel animation frame
-      session.cancelAnimationFrame(session.requestAnimationFrame(
-        (time, vrFrame) => { reject("Cancelled frame callback was called"); }));
-
-      let counter = 0;
-      let handle;
-      function onFrame(time, vrFrame) {
-        // Cancel the second animation frame.
-        if (handle != 0) {
-          session.cancelAnimationFrame(handle);
-          handle = 0;
-        }
-
-        // Run a few more animation frames to be sure that the cancelled frame isn't
-        // going to call.
-        counter++;
-        if (counter >= 4) {
-          // Ok, we're done here.
-          resolve();
-        } else {
-          session.requestAnimationFrame(onFrame);
-        }
-      }
-
-      // Schedule two animation frame and cancel one during on animation frame.
-      session.requestAnimationFrame(onFrame);
-      handle = session.requestAnimationFrame(
-        (time, vrFrame) => { reject("Cancelled frame callback was called"); });
-    });
-
-    xr_session_promise_test(immersiveTestName, testFunction,
-      fakeDeviceInitParams, immersiveSessionOptions);
-    xr_session_promise_test(nonImmersiveTestName, testFunction,
-      fakeDeviceInitParams, nonImmersiveSessionOptions);
-
-  </script>
-</body>
-

third_party/WebKit/LayoutTests/external/wpt/webxr/xrSession_cancelAnimationFrame_invalidhandle.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <canvas></canvas>
-  <script>
-    let immersiveTestName = "XRSession cancelAnimationFrame does not have unexpected "
-      + "behavior when given invalid handles on immersive testSession";
-    let nonImmersiveTestName = "XRSession cancelAnimationFrame does not have unexpected "
-      + "behavior when given invalid handles on non-immersive testSession";
-
-    let fakeDeviceInitParams = { supportsImmersive:true };
-
-    let immersiveSessionOptions = { immersive: true };
-    let nonImmersiveSessionOptions = { outputContext: getOutputContext() };
-
-    let testFunction = (testSession) => new Promise((resolve) => {
-      let counter = 0;
-
-      function onFrame(time, vrFrame) {
-        if(counter <= 10) {
-          testSession.requestAnimationFrame(onFrame);
-        } else {
-          resolve();
-        }
-        counter++;
-      }
-
-      let handle = testSession.requestAnimationFrame(onFrame);
-      testSession.cancelAnimationFrame(0);
-      testSession.cancelAnimationFrame(-1);
-      testSession.cancelAnimationFrame(handle + 1);
-      testSession.cancelAnimationFrame(handle - 1);
-      testSession.cancelAnimationFrame(0.5);
-      testSession.cancelAnimationFrame(null);
-    });
-
-    xr_session_promise_test(
-      immersiveTestName, testFunction, fakeDeviceInitParams, immersiveSessionOptions);
-    xr_session_promise_test(
-      nonImmersiveTestName, testFunction, fakeDeviceInitParams, nonImmersiveSessionOptions);
-
-  </script>
-</body>

third_party/WebKit/LayoutTests/external/wpt/webxr/xrSession_device.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <canvas></canvas>
-
-  <script>
-    xr_promise_test("Requested session has device set",
-     (t) => {
-      return XRTest.simulateDeviceConnection({ supportsImmersive:true })
-        .then( (controller) => { return navigator.xr.requestDevice() })
-        .then( (device) => new Promise((resolve) => {
-          XRTest.simulateUserActivation( () => {
-            resolve(device.requestSession({ immersive: true }).then( (session) => {
-              assert_true(session.immersive);
-              assert_equals(session.device, device);
-            }));
-          });
-        }));
-    });
-  </script>
-</body>
-

third_party/WebKit/LayoutTests/external/wpt/webxr/xrSession_end.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <canvas></canvas>
-
-  <script>
-    const immersivetestName = "end event fires when immersive session ends";
-    const nonimmersiveTestName = "end event fires when non-immersive session ends";
-    let watcherDone = new Event("watcherdone");
-    const fakeDeviceInitParams = { supportsImmersive:true };
-
-    const immersiveSessionOptions = { immersive: true };
-    const nonImmersiveSessionOptions = { outputContext: getOutputContext() };
-
-    let testFunction = function(session, testDeviceController, t) {
-      let eventWatcher = new EventWatcher(t, session, ["end", "watcherdone"]);
-      let eventPromise = eventWatcher.wait_for(["end", "watcherdone"]);
-
-      function onSessionEnd(event) {
-        t.step( () => {
-          assert_equals(event.session, session);
-          session.dispatchEvent(watcherDone);
-        });
-      }
-      session.addEventListener("end", onSessionEnd, false);
-      session.end();
-
-      return eventPromise;
-    };
-
-    xr_session_promise_test(immersivetestName, testFunction,
-      fakeDeviceInitParams, immersiveSessionOptions);
-    xr_session_promise_test(nonimmersiveTestName, testFunction,
-      fakeDeviceInitParams, nonImmersiveSessionOptions);
-  </script>
-</body>
\ No newline at end of file

third_party/WebKit/LayoutTests/external/wpt/webxr/xrSession_exclusive_requestAnimationFrame.https.html

+<!DOCTYPE html>
+<body>
+  <script src=/resources/testharness.js></script>
+  <script src=/resources/testharnessreport.js></script>
+  <script src="resources/webxr_util.js"></script>
+  <canvas id="webgl-canvas"></canvas>
+
+  <script>
+
+  const identityMatrix = new Float32Array([
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]);
+
+  const rightFakeXRViewInit =
+    {eye:"right", projectionMatrix: identityMatrix, viewMatrix: identityMatrix};
+
+  const leftFakeXRViewInit =
+    {eye:"left", projectionMatrix: identityMatrix, viewMatrix: identityMatrix};
+
+  const immersiveFakeXRDeviceInit = { supportsImmersive:true };
+
+  const webglCanvas = document.getElementById('webgl-canvas');
+  let gl = webglCanvas.getContext('webgl', { alpha: false, antialias: false });
+
+  let testDevice;
+  let testDeviceController;
+  let testSession;
+
+  xr_promise_test(
+    (t) => XRTest.simulateDeviceConnection(immersiveFakeXRDeviceInit)
+      .then((controller) => {
+        testDeviceController = controller;
+        return navigator.xr.requestDevice();
+      })
+      .then((device) => {
+        testDevice = device;
+        return gl.setCompatibleXRDevice(device);
+      })
+      .then(() => new Promise((resolve, reject) => {
+          // Perform the session request in a user gesture.
+          XRTest.simulateUserActivation(() => {
+            testDevice.requestSession({ immersive: true })
+              .then((session) => {
+                testSession = session;
+                return session.requestFrameOfReference('eye-level');
+              })
+              .then((frameOfRef) => {
+                // Session must have a baseLayer or frame requests will be ignored.
+                testSession.baseLayer = new XRWebGLLayer(testSession, gl);
+
+                function onFrame(time, xrFrame) {
+                  assert_true(xrFrame instanceof XRFrame);
+
+                  assert_not_equals(xrFrame.views, null);
+                  assert_equals(xrFrame.views.length, 2);
+
+                  let devicePose = xrFrame.getDevicePose(frameOfRef);
+
+                  assert_not_equals(devicePose, null);
+                  for(let i = 0; i < identityMatrix.length; i++) {
+                    assert_equals(devicePose.poseModelMatrix[i], identityMatrix[i]);
+                  }
+
+                  assert_not_equals(devicePose.getViewMatrix(xrFrame.views[0]), null);
+                  assert_equals(devicePose.getViewMatrix(xrFrame.views[0]).length, 16);
+                  assert_not_equals(devicePose.getViewMatrix(xrFrame.views[1]), null);
+                  assert_equals(devicePose.getViewMatrix(xrFrame.views[1]).length, 16);
+
+                  // Test does not complete until the returned promise resolves.
+                  resolve();
+                }
+
+                testDeviceController.setXRPresentationFrameData(
+                  identityMatrix,
+                  [rightFakeXRViewInit, leftFakeXRViewInit]
+                );
+
+                testSession.requestAnimationFrame(onFrame);
+              }).catch((err) => {
+                reject("Session was rejected with error: "+err);
+              });
+          });
+        })
+      ),
+    "RequestAnimationFrame resolves with good data"
+  );
+  </script>
+</body>

third_party/WebKit/LayoutTests/external/wpt/webxr/xrSession_prevent_multiple_exclusive.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <canvas></canvas>
-
-  <script>
-    xr_promise_test(
-      "Test prevention of multiple simultaneous immersive sessions",
-      (t) => {
-      return XRTest.simulateDeviceConnection({ supportsImmersive:true })
-        .then( (controller) => { return navigator.xr.requestDevice() })
-        .then( (device) => new Promise((resolve) => {
-          XRTest.simulateUserActivation( () => {
-            resolve(device.requestSession({ immersive: true })
-              .then( (session) => new Promise((resolve) => {
-                XRTest.simulateUserActivation( () => {
-                  // Requesting a second immersive session from a device that already
-                  // has an active immersive session should fail. Immersive sessions
-                  // should take up the users entire view, and therefore it should
-                  // be impossible for a user to be engaged with more than one.
-                  resolve(promise_rejects(
-                    t,
-                    "InvalidStateError",
-                    device.requestSession({ immersive: true })
-                  ).then( () => {
-                      // End the immersive session and try again. Now the immersive
-                      // session creation should succeed.
-                      return session.end().then( () => new Promise((resolve) => {
-                        XRTest.simulateUserActivation( () => {
-                          resolve(device.requestSession({ immersive: true }));
-                        });
-                      }));
-                    }));
-                });
-            })));
-          });
-        }));
-    });
-
-  </script>
-</body>

third_party/WebKit/LayoutTests/external/wpt/webxr/xrSession_requestAnimationFrame_callback_calls.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <canvas></canvas>
-
-  <script>
-    let immersiveTestName = "XRSession requestAnimationFrame calls the " +
-      "provided callback for an immersive session";
-    let nonImmersiveTestName = "XRSession requestAnimationFrame calls the " +
-      "provided callback a non-immersive session";
-
-    let fakeDeviceInitParams = { supportsImmersive:true };
-
-    let immersiveSessionOptions = { immersive: true };
-    let nonImmersiveSessionOptions = { outputContext: getOutputContext() };
-
-    let testFunction = (testSession) => new Promise((resolve) => {
-      function onFrame(time, xrFrame) {
-        assert_true(xrFrame instanceof XRFrame);
-        // Test does not complete until the returned promise resolves.
-        resolve();
-      }
-
-      testSession.requestAnimationFrame(onFrame);
-    });
-
-    xr_session_promise_test(immersiveTestName, testFunction,
-      fakeDeviceInitParams, immersiveSessionOptions);
-    xr_session_promise_test(nonImmersiveTestName, testFunction,
-      fakeDeviceInitParams, nonImmersiveSessionOptions);
-
-  </script>
-</body>
\ No newline at end of file

third_party/WebKit/LayoutTests/external/wpt/webxr/xrSession_requestAnimationFrame_data_valid.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <canvas></canvas>
-
-  <script>
-    const testName = "RequestAnimationFrame resolves with good data";
-
-    const identityMatrix = new Float32Array([
-      1, 0, 0, 0,
-      0, 1, 0, 0,
-      0, 0, 1, 0,
-      0, 0, 0, 1
-    ]);
-
-    const rightFakeXRViewInit = {
-      eye:"right",
-      projectionMatrix: identityMatrix,
-      viewMatrix: identityMatrix
-    };
-
-    const leftFakeXRViewInit = {
-      eye:"left",
-      projectionMatrix: identityMatrix,
-      viewMatrix: identityMatrix
-    };
-
-    const fakeDeviceInitOptions = { supportsImmersive:true };
-    const sessionOptions = { immersive:true };
-
-    let testSession;
-
-    let testFunction = function(session, testDeviceController) {
-      testSession = session;
-      return session.requestFrameOfReference('eye-level')
-        .then((frameOfRef) => new Promise((resolve) => {
-
-          function onFrame(time, xrFrame) {
-            assert_true(xrFrame instanceof XRFrame);
-
-            assert_not_equals(xrFrame.views, null);
-            assert_equals(xrFrame.views.length, 2);
-
-            let devicePose = xrFrame.getDevicePose(frameOfRef);
-
-            assert_not_equals(devicePose, null);
-            for(let i = 0; i < identityMatrix.length; i++) {
-              assert_equals(devicePose.poseModelMatrix[i], identityMatrix[i]);
-            }
-
-            assert_not_equals(devicePose.getViewMatrix(xrFrame.views[0]), null);
-            assert_equals(devicePose.getViewMatrix(xrFrame.views[0]).length, 16);
-            assert_not_equals(devicePose.getViewMatrix(xrFrame.views[1]), null);
-            assert_equals(devicePose.getViewMatrix(xrFrame.views[1]).length, 16);
-
-            // Test does not complete until the returned promise resolves.
-            resolve();
-          }
-
-          testDeviceController.setXRPresentationFrameData(
-            identityMatrix,
-            [rightFakeXRViewInit, leftFakeXRViewInit]
-          );
-
-          testSession.requestAnimationFrame(onFrame);
-        })
-      );
-    }
-
-    xr_session_promise_test(
-      testName, testFunction, fakeDeviceInitOptions, sessionOptions);
-  </script>
-</body>

third_party/WebKit/LayoutTests/external/wpt/webxr/xrSession_requestAnimationFrame_getDevicePose.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <canvas></canvas>
-
-  <script>
-
-    let immersiveTestName =
-      "XRFrame getDevicePose updates on the next frame for immersive sessions";
-    let nonImmersiveTestName =
-      "XRFrame getDevicePose updates on the next frame for non-immersive sessions";
-
-    let fakeDeviceInitParams = { supportsImmersive: true };
-
-    let immersiveSessionOptions = { immersive: true };
-    let nonImmersiveSessionOptions = { outputContext: getOutputContext() };
-
-    // Valid matrices for  when we don't care about specific values
-    const validPoseMatrix = [0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1];
-    const validProjectionMatrix = [1, 0, 0, 0, 0, 1, 0, 0, 3, 2, -1, -1, 0, 0, -0.2, 0];
-    const validViewMatrix = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 4, 3, 2, 1];
-
-    let testFunction = function(session, fakeDeviceController, t) {
-      return session.requestFrameOfReference("eye-level")
-        .then((frameOfRef) => new Promise((resolve, reject) => {
-          let counter = 0;
-          function onFrame(time, vrFrame) {
-            session.requestAnimationFrame(onFrame);
-            if (counter == 0) {
-              t.step( () => {
-                // Expecting to not get a pose since none has been supplied
-                assert_equals(vrFrame.getDevicePose(frameOfRef), null);
-
-                fakeDeviceController.setXRPresentationFrameData(
-                  validPoseMatrix, [{
-                    eye:"left",
-                    projectionMatrix: validProjectionMatrix,
-                    viewMatrix: validViewMatrix
-                  }, {
-                    eye:"right",
-                    projectionMatrix: validProjectionMatrix,
-                    viewMatrix: validViewMatrix
-                  }]);
-
-                // Check that pose does not update pose within the same frame.
-                assert_equals(vrFrame.getDevicePose(frameOfRef), null);
-              });
-            } else {
-              t.step( () => {
-                let pose = vrFrame.getDevicePose(frameOfRef);
-                assert_not_equals(pose, null);
-
-                let poseMatrix = pose.poseModelMatrix;
-                assert_not_equals(poseMatrix, null);
-
-                for(let i = 0; i < poseMatrix.length; i++) {
-                  assert_equals(poseMatrix[i], validPoseMatrix[i]);
-                }
-              });
-
-              // Finished.
-              resolve();
-            }
-            counter++;
-          }
-
-          session.requestAnimationFrame(onFrame);
-        }));
-    };
-
-    xr_session_promise_test(immersiveTestName, testFunction,
-      fakeDeviceInitParams, immersiveSessionOptions);
-    xr_session_promise_test(nonImmersiveTestName, testFunction,
-      fakeDeviceInitParams, nonImmersiveSessionOptions);
-
-  </script>
-</body>

third_party/WebKit/LayoutTests/external/wpt/webxr/xrSession_requestFrameOfReference.https.html

-<!DOCTYPE html>
-<body>
-  <script src=/resources/testharness.js></script>
-  <script src=/resources/testharnessreport.js></script>
-  <script src="resources/webxr_util.js"></script>
-  <canvas></canvas>
-  <script>
-
-    let immersiveTestName =
-      "Immersive XRSession requestFrameOfReference returns expected objects";
-    let nonImmersiveTestName =
-      "Non-immersive XRSession requestFrameOfReference returns expected objects";
-
-    let fakeDeviceInitParams = { supportsImmersive: true };
-
-    let immersiveSessionOptions = { immersive: true };
-    let nonImmersiveSessionOptions = { outputContext: getOutputContext() };
-
-    let testFunction = function(session, fakeDeviceController, t) {
-      return promise_rejects(t, new TypeError(), session.requestFrameOfReference("foo"))
-        .then(() => Promise.all([
-          session.requestFrameOfReference("head-model").then( (frameOfRef) => {
-            assert_true(frameOfRef instanceof XRCoordinateSystem,
-              "head-model frameOfRef is not correct type.");
-            assert_true(frameOfRef instanceof XRFrameOfReference,
-              "head-model frameOfRef is not correct type.");
-          }),
-          session.requestFrameOfReference("eye-level").then( (frameOfRef) => {
-            assert_true(frameOfRef instanceof XRCoordinateSystem,
-              "eye-level frameOfRef is not correct type.");
-            assert_true(frameOfRef instanceof XRFrameOfReference,
-              "eye-level frameOfRef is not correct type.");
-          }),
-          session.requestFrameOfReference("stage").then( (frameOfRef) => {
-            assert_true(frameOfRef instanceof XRCoordinateSystem,
-              "stage frameOfRef is not correct type.");
-            assert_true(frameOfRef instanceof XRFrameOfReference,
-              "stage frameOfRef is not correct type.");
-          })
-      ]));
-    };
-
-    xr_session_promise_test(
-      immersiveTestName, testFunction, fakeDeviceInitParams, immersiveSessionOptions);
-    xr_session_promise_test(
-      nonImmersiveTestName, testFunction, fakeDeviceInitParams, nonImmersiveSessionOptions);
-
-  </script>
-</body>
\ No newline at end of file

third_party/WebKit/LayoutTests/vr/resources/vr-test-utils.js

 'use strict';
 
 MockVRService.prototype.setListeningForActivate = function(client) {
-  for (let i = 0; i < this.runtimes_.length; i++) {
-    this.runtimes_[i].displayClient_ = client;
+  for (let i = 0; i < this.devices_.length; i++) {
+    this.devices_[i].displayClient_ = client;
   }
 };
 
-MockVRService.prototype.getImmersiveVRDisplayInfo = function() {
-  return Promise.resolve(
-      {info: this.runtimes_[0] ? this.runtimes_[0].displayInfo_ : null});
-};
 
-MockRuntime.prototype.setPose = function(pose) {
+MockDevice.prototype.setPose = function(pose) {
   if (pose == null) {
     this.pose_ = null;
   } else {
@@ -34,10 +30,14 @@ MockRuntime.prototype.setPose = function(pose) {
   }
 };
 
-MockRuntime.prototype.forceActivate = function(reason) {
+MockDevice.prototype.forceActivate = function(reason) {
   this.displayClient_.onActivate(reason);
 };
 
+MockDevice.prototype.getImmersiveVRDisplayInfo = function() {
+  return Promise.resolve({info: this.displayInfo_});
+};
+
 function vr_test(func, vrDisplays, name, properties) {
   let chain = Promise.resolve();
   let firstDeviceController;

third_party/WebKit/LayoutTests/xr/events_session_end.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<canvas id="webgl-canvas"></canvas>
+
+<script>
+
+let testName = "Test end fires when session ends";
+
+let watcherDone = new Event("watcherdone");
+
+let fakeDeviceInitParams = { supportsImmersive:true };
+
+let requestSessionOptions = [
+  { immersive: true },
+  { outputContext: getOutputContext() }
+];
+
+let testFunction = function(session, t) {
+  let eventWatcher = new EventWatcher(t, session, ["end", "watcherdone"]);
+  let eventPromise = eventWatcher.wait_for(["end", "watcherdone"]);
+
+  function onSessionEnd(event) {
+    t.step( () => {
+      assert_equals(event.session, session);
+      session.dispatchEvent(watcherDone);
+    });
+  }
+  session.addEventListener("end", onSessionEnd, false);
+  session.end();
+
+  return eventPromise;
+};
+
+xr_session_promise_test(
+  testFunction, fakeDeviceInitParams, requestSessionOptions, testName);
+
+</script>

third_party/WebKit/LayoutTests/xr/exclusive_requestFrame_called.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<canvas id="webgl-canvas"></canvas>
+
+<script>
+let testName = "XRSession requestAnimationFrame properly calls the provided "
+  + "callback";
+
+let fakeDeviceInitParams = { supportsImmersive:true };
+
+let requestSessionOptions = [
+  { immersive: true },
+  { outputContext: getOutputContext() }
+];
+
+let testFunction = (session) => new Promise((resolve) => {
+  // Session must have a baseLayer or frame requests will be ignored.
+  session.baseLayer = new XRWebGLLayer(session, gl);
+
+  function onFrame(time, xrFrame) {
+    assert_true(xrFrame instanceof XRFrame);
+    // Test does not complete until the returned promise resolves.
+    resolve();
+  }
+
+  session.requestAnimationFrame(onFrame);
+});
+
+xr_session_promise_test(
+  testFunction, fakeDeviceInitParams, requestSessionOptions, testName);
+
+</script>

third_party/WebKit/LayoutTests/xr/exclusive_requestFrame_invalidhandle.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<canvas id="webgl-canvas"></canvas>
+
+<script>
+let testName = "XRSession cancelAnimationFrame does not have unexpected "
+  + "behavior when given invalid handles";
+
+let fakeDeviceInitParams = { supportsImmersive:true };
+
+let requestSessionOptions = [
+  { immersive: true },
+  { outputContext: getOutputContext() }
+];
+
+let testFunction = (session) => new Promise((resolve) => {
+  // Session must have a baseLayer or frame requests will be ignored.
+  session.baseLayer = new XRWebGLLayer(session, gl);
+
+  let counter = 0;
+
+  function onFrame(time, vrFrame) {
+    // Intentionally session.requestAnimationFrame at the beginning, ensuring that
+    // there's an outstanding callback when the test completes. This is to make
+    // sure it doesn't cause any unexpected behavior like it did with
+    // crbug.com/679401
+    session.requestAnimationFrame(onFrame);
+    if (counter > 10) {
+      resolve();
+    }
+    counter++;
+  }
+
+  let handle = session.requestAnimationFrame(onFrame);
+  session.cancelAnimationFrame(0);
+  session.cancelAnimationFrame(-1);
+  session.cancelAnimationFrame(handle + 1);
+  session.cancelAnimationFrame(handle - 1);
+  session.cancelAnimationFrame(0.5);
+  session.cancelAnimationFrame(null);
+});
+
+xr_session_promise_test(
+  testFunction, fakeDeviceInitParams, requestSessionOptions, testName);
+
+</script>

third_party/WebKit/LayoutTests/xr/exclusive_requestFrame_unregister.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<canvas id="webgl-canvas"></canvas>
+
+<script>
+let testName = "XRSession requestAnimationFrame callbacks can be unregistered "
+  + "with cancelAnimationFrame";
+
+let fakeDeviceInitParams = { supportsImmersive:true };
+
+let requestSessionOptions = [
+  { immersive: true },
+  { outputContext: getOutputContext() }
+];
+
+let testFunction = (session) => new Promise((resolve, reject) => {
+  // Session must have a baseLayer or frame requests will be ignored.
+  session.baseLayer = new XRWebGLLayer(session, gl);
+
+  function onFrameBad(time, vrFrame) {
+    reject("Unregistered callback was called");
+  }
+
+  let counter = 0;
+  let handle2 = 0;
+  function onFrameGood(time, vrFrame) {
+    counter++;
+    if (counter >= 4) {
+      resolve();
+      // Intentionally don't return immediately so that session.requestAnimationFrame
+      // gets called again to make sure it doesn't cause unexpected behavior
+      // like in crbug.com/679401
+    }
+    session.requestAnimationFrame(onFrameGood);
+
+    if (handle2 != 0) {
+      // The first time we enter this callback the callback associated with
+      // handle2 will have already been queued to execute immediately after
+      // this callback returns. Ensure that cancelAnimationFrame works even in that
+      // scenario.
+      session.cancelAnimationFrame(handle2);
+      handle2 = 0;
+    }
+  }
+
+  let handle = session.requestAnimationFrame(onFrameBad);
+  session.cancelAnimationFrame(handle);
+  session.requestAnimationFrame(onFrameGood);
+  handle2 = session.requestAnimationFrame(onFrameBad);
+});
+
+xr_session_promise_test(
+  testFunction, fakeDeviceInitParams, requestSessionOptions, testName);
+
+</script>

third_party/WebKit/LayoutTests/xr/getDevicePose_oneframeupdate.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<script src="../xr/resources/test-constants.js"></script>
+<canvas id="webgl-canvas"></canvas>
+
+<script>
+
+let testName = "XRFrame getDevicePose updates on the next frame";
+
+let fakeDeviceInitParams = { supportsImmersive: true };
+
+let requestSessionOptions =  [
+  { immersive: true },
+  { outputContext: getOutputContext() }
+];
+
+let testFunction = function(session, t, fakeDeviceController) {
+  // Session must have a baseLayer or else frame requests will be ignored.
+  session.baseLayer = new XRWebGLLayer(session, gl);
+
+  return session.requestFrameOfReference("eye-level")
+    .then((frameOfRef) => new Promise((resolve, reject) => {
+      let counter = 0;
+      function onFrame(time, vrFrame) {
+        session.requestAnimationFrame(onFrame);
+        if (counter == 0) {
+          t.step( () => {
+            // Expecting to not get a pose since none has been supplied
+            assert_equals(vrFrame.getDevicePose(frameOfRef), null);
+
+            // Need to have a valid pose or input event's don't process.
+            fakeDeviceController.setXRPresentationFrameData(
+              VALID_POSE_MATRIX, [{
+                eye:"left",
+                projectionMatrix: VALID_PROJECTION_MATRIX,
+                viewMatrix: VALID_VIEW_MATRIX
+              }, {
+                eye:"right",
+                projectionMatrix: VALID_PROJECTION_MATRIX,
+                viewMatrix: VALID_VIEW_MATRIX
+              }]);
+
+            // Check that pose does not update pose within the same frame.
+            assert_equals(vrFrame.getDevicePose(frameOfRef), null);
+          });
+        } else {
+          t.step( () => {
+            // Check that pose was updated.
+            let pose = vrFrame.getDevicePose(frameOfRef);
+            assert_not_equals(pose, null);
+
+            let poseMatrix = pose.poseModelMatrix;
+            assert_not_equals(poseMatrix, null);
+
+            assert_matrices_approx_equal(poseMatrix, VALID_POSE_MATRIX);
+          });
+
+          // Finished.
+          resolve();
+        }
+        counter++;
+      }
+
+      session.requestAnimationFrame(onFrame);
+    }));
+};
+
+xr_session_promise_test(
+  testFunction, fakeDeviceInitParams, requestSessionOptions, testName);
+
+</script>

third_party/WebKit/LayoutTests/xr/requestDevice_with_device.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<script src="../xr/resources/test-constants.js"></script>
+<script>
+
+promise_test((t) => {
+  return XRTest.simulateDeviceConnection({ supportsImmersive: true })
+    .then( (controller) => { return navigator.xr.requestDevice() })
+    .then( (device) => {
+      t.step(() => {
+        assert_true(device != null);
+        assert_true(device instanceof XRDevice);
+      });
+    });
+}, "navigator.xr.requestDevice properly returns a single device");
+
+</script>

third_party/WebKit/LayoutTests/xr/requestDevice_without_device.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<script src="../xr/resources/test-constants.js"></script>
+<script>
+
+promise_test( (t) => {
+  return promise_rejects(t, 'NotFoundError', navigator.xr.requestDevice());
+}, "navigator.xr.requestDevice properly rejects when there are 0 devices");
+
+</script>

third_party/WebKit/LayoutTests/xr/resources/xr-internal-device-mocking.js

@@ -4,9 +4,9 @@
  * for interal tests. The main mocked objects are found in
  * ../external/wpt/resources/chromium/webxr-test.js. */
 
-MockRuntime.prototype.base_getFrameData = MockRuntime.prototype.getFrameData;
+MockDevice.prototype.base_getFrameData = MockDevice.prototype.getFrameData;
 
-MockRuntime.prototype.getFrameData = function() {
+MockDevice.prototype.getFrameData = function() {
   return this.base_getFrameData().then((result) => {
     if (result.frameData && result.frameData.pose && this.input_sources_) {
       let input_states = [];
@@ -21,7 +21,7 @@ MockRuntime.prototype.getFrameData = function() {
   });
 };
 
-MockRuntime.prototype.addInputSource = function(source) {
+MockDevice.prototype.addInputSource = function(source) {
   if (!this.input_sources_) {
     this.input_sources_ = [];
     this.next_input_source_index_ = 1;
@@ -32,7 +32,7 @@ MockRuntime.prototype.addInputSource = function(source) {
   this.input_sources_.push(source);
 };
 
-MockRuntime.prototype.removeInputSource = function(source) {
+MockDevice.prototype.removeInputSource = function(source) {
   if (!this.input_sources_)
     return;
 
@@ -44,11 +44,11 @@ MockRuntime.prototype.removeInputSource = function(source) {
   }
 };
 
-MockRuntime.prototype.setHitTestResults = function(results) {
+MockDevice.prototype.setHitTestResults = function(results) {
   this.hittest_results_ = results;
 };
 
-MockRuntime.prototype.requestHitTest = function(ray) {
+MockDevice.prototype.requestHitTest = function(ray) {
   var hit_results = this.hittest_results_;
   if (!hit_results) {
     var hit = new device.mojom.XRHitResult();
@@ -58,13 +58,13 @@ MockRuntime.prototype.requestHitTest = function(ray) {
   return Promise.resolve(hit_results);
 };
 
-MockRuntime.prototype.setResetPose = function(to) {
+MockDevice.prototype.setResetPose = function(to) {
   if (this.pose_) {
     this.pose_.poseReset = to;
   }
 };
 
-MockRuntime.prototype.setStageTransform = function(value) {
+MockDevice.prototype.setStageTransform = function(value) {
   if (value) {
     if (!this.displayInfo_.stageParameters) {
       this.displayInfo_.stageParameters = {
@@ -82,11 +82,11 @@ MockRuntime.prototype.setStageTransform = function(value) {
   this.sessionClient_.onChanged(this.displayInfo_);
 };
 
-MockRuntime.prototype.getSubmitFrameCount = function() {
+MockDevice.prototype.getSubmitFrameCount = function() {
   return this.presentation_provider_.submit_frame_count_;
 };
 
-MockRuntime.prototype.getMissingFrameCount = function() {
+MockDevice.prototype.getMissingFrameCount = function() {
   return this.presentation_provider_.missing_frame_count_;
 };
 

third_party/WebKit/LayoutTests/xr/webGLCanvasContext_create_with_xr_device.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<script src="../xr/resources/test-constants.js"></script>
+<canvas id="webgl-canvas"></canvas>
+
+<script>
+
+
+promise_test( (t) => {
+  return XRTest.simulateDeviceConnection({ supportsImmersive:true })
+    .then( (controller) => { return navigator.xr.requestDevice() })
+    .then( (device) => {
+      webglCanvas = document.getElementById('webgl-canvas');
+      gl = webglCanvas.getContext('webgl', {compatibleXRDevice: device});
+      assert_equals(gl.getContextAttributes().compatibleXRDevice, device);
+
+      // Check that an offscreen context behaves no different.
+      let offscreenCanvas = document.createElement('canvas');
+      let offscreenGl = webglCanvas.getContext('webgl', {compatibleXRDevice: device});
+      assert_equals(offscreenGl.getContextAttributes().compatibleXRDevice, device);
+    });
+}, "A webglCanvasContext created with an XRDevice has that device set");
+
+</script>

third_party/WebKit/LayoutTests/xr/webGLCanvasContext_set_device_lost_context.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<script src="../xr/resources/test-constants.js"></script>
+<canvas id="webgl-canvas"></canvas>
+
+<script>
+
+promise_test( (t) => {
+  return XRTest.simulateDeviceConnection({ supportsImmersive:true })
+    .then( (controller) => { return navigator.xr.requestDevice() })
+    .then( (device) => {
+      webglCanvas = document.getElementById('webgl-canvas');
+      gl = webglCanvas.getContext('webgl', {compatibleXRDevice: device});
+      gl.getExtension('WEBGL_lose_context').loseContext();
+      return promise_rejects(t, 'InvalidStateError',
+          gl.setCompatibleXRDevice(device));
+    });
+}, "A lost webglCanvasContext should not be able to set device");
+
+</script>

third_party/WebKit/LayoutTests/xr/xrDevice_requestSession_exclusive_no_gesture.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<script src="../xr/resources/test-constants.js"></script>
+<canvas id="webgl-canvas"></canvas>
+
+<script>
+
+promise_test( (t) => {
+  return XRTest.simulateDeviceConnection({ supportsImmersive:true })
+    .then( (controller) => { return navigator.xr.requestDevice() })
+    .then( (device) => promise_rejects(
+      t, 'SecurityError', device.requestSession({ immersive: true })));
+}, "request immersive session outside of a user gesture rejects");
+</script>

third_party/WebKit/LayoutTests/xr/xrDevice_requestSession_exclusive_supported.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<script src="../xr/resources/test-constants.js"></script>
+<canvas id="webgl-canvas"></canvas>
+
+<script>
+
+
+xr_session_promise_test( (session) => {
+  assert_not_equals(session, null);
+}, { supportsImmersive:true }, [{ immersive: true }],
+"requestSession for an immersive session with a user gesture resolves");
+</script>

third_party/WebKit/LayoutTests/xr/xrDevice_requestSession_exclusive_unsupported.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<script src="../xr/resources/test-constants.js"></script>
+<canvas id="webgl-canvas"></canvas>
+
+<script>
+promise_test( (t) => {
+  return XRTest.simulateDeviceConnection({ supportsImmersive:false })
+    .then( (controller) => { return navigator.xr.requestDevice() })
+    .then( (magicWindowOnlyDevice) => new Promise((resolve) => {
+      runWithUserGesture( () => {
+        resolve(promise_rejects(
+          t,
+          "NotSupportedError",
+          magicWindowOnlyDevice.requestSession({ immersive: true })
+        ))
+      });
+    }));
+}, "requesting an immersive session on an unsupported device rejects");
+
+</script>

third_party/WebKit/LayoutTests/xr/xrDevice_supportsSession_exclusive_rejects.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<script src="../xr/resources/test-constants.js"></script>
+<script>
+
+
+promise_test( (t) => {
+  return XRTest.simulateDeviceConnection({ supportsImmersive:false })
+    .then( (controller) => { return navigator.xr.requestDevice() })
+    .then( (magicWindowOnlyDevice) => {
+      return promise_rejects(
+        t,
+        "NotSupportedError",
+        magicWindowOnlyDevice.supportsSession({ immersive: true })
+      );
+    });
+}, "supportsSession rejects when immersive session is not supported on device");
+
+</script>

third_party/WebKit/LayoutTests/xr/xrDevice_supportsSession_exclusive_resolves.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<script src="../xr/resources/test-constants.js"></script>
+<script>
+
+promise_test( () => {
+  return XRTest.simulateDeviceConnection({ supportsImmersive:true })
+    .then( (controller) => { return navigator.xr.requestDevice() })
+    .then( (device) => device.supportsSession({ immersive: true }));
+}, "supportsSession resolves when support immersive session is supported on device");
+
+</script>

third_party/WebKit/LayoutTests/xr/xrDevice_supportsSession_non_exclusive.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<script src="../xr/resources/test-constants.js"></script>
+<script>
+
+promise_test( (t) => {
+  return XRTest.simulateDeviceConnection({ supportsImmersive:true })
+    .then( (controller) => { return navigator.xr.requestDevice() })
+    .then( (device) => {
+      // Non-immersive sessions without a outputContext should not be supported.
+      promise_rejects(t, 'NotSupportedError', device.supportsSession());
+
+      // Non-immersive sessions with an outputContext should be supported.
+      return device.supportsSession({
+          outputContext: getOutputContext()
+      });
+    });
+}, "supportsSession properly identifies supported non-immersive sessions");
+
+</script>

third_party/WebKit/LayoutTests/xr/xrSession_exclusive.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<script src="../xr/resources/test-constants.js"></script>
+<canvas id="webgl-canvas"></canvas>
+
+<script>
+
+
+promise_test( (t) => {
+  return XRTest.simulateDeviceConnection({ supportsImmersive:true })
+    .then( (controller) => { return navigator.xr.requestDevice() })
+    .then( (device) => new Promise((resolve) => {
+      runWithUserGesture( () => {
+        resolve(device.requestSession({ immersive: true }).then( (session) => {
+          assert_true(session.immersive);
+          assert_equals(session.device, device);
+          assert_approx_equals(session.depthNear, 0.1, FLOAT_EPSILON);
+          assert_approx_equals(session.depthFar, 1000.0, FLOAT_EPSILON);
+        }));
+      });
+    }));
+}, "supportsSession returns expected immersive session");
+
+</script>

third_party/WebKit/LayoutTests/xr/xrSession_prevent_multiple_exclusive.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<script src="../xr/resources/test-constants.js"></script>
+<canvas id="webgl-canvas"></canvas>
+
+<script>
+
+
+promise_test( (t) => {
+  return XRTest.simulateDeviceConnection({ supportsImmersive:true })
+    .then( (controller) => { return navigator.xr.requestDevice() })
+    .then( (device) => new Promise((resolve) => {
+      runWithUserGesture( () => {
+        resolve(device.requestSession({ immersive: true })
+          .then( (session) => new Promise((resolve) => {
+            runWithUserGesture( () => {
+              // Requesting a second immersive session from a device that already
+              // has an active immersive session should fail. Immersive sessions
+              // should take up the users entire view, and therefore it should
+              // be impossible for a user to be engaged with more than one.
+              resolve(promise_rejects(
+                t,
+                "InvalidStateError",
+                device.requestSession({ immersive: true })
+              ).then( () => {
+                  // End the immersive session and try again. Now the immersive
+                  // session creation should succeed.
+                  return session.end().then( () => new Promise((resolve) => {
+                    runWithUserGesture( () => {
+                      resolve(device.requestSession({ immersive: true }));
+                    });
+                  }));
+                }));
+            });
+        })));
+      });
+    }));
+}, "requestSession prevents creation of multiple simultaneous immersive sessions");
+
+</script>

third_party/WebKit/LayoutTests/xr/xrSession_requestFrameOfReference.html

+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/public/mojom/vr_service.mojom.js"></script>
+<script src="../external/wpt/resources/chromium/webxr-test.js"></script>
+<script src="../xr/resources/xr-test-utils.js"></script>
+<script src="../xr/resources/test-constants.js"></script>
+<canvas id="webgl-canvas"></canvas>
+
+<script>
+let testName = "requestFrameOfReference returns the expected objects";
+
+let fakeDeviceInitParams = { supportsImmersive:true };
+
+let requestSessionOptions = [
+  { outputContext: getOutputContext() },
+  { immersive: true },
+];
+
+let testFunction = function(session, t) {
+  return promise_rejects(t, new TypeError(), session.requestFrameOfReference("foo"))
+    .then(() => Promise.all([
+      session.requestFrameOfReference("head-model").then( (frameOfRef) => {
+        assert_true(frameOfRef instanceof XRCoordinateSystem,
+          "head-model frameOfRef is not correct type.");
+        assert_true(frameOfRef instanceof XRFrameOfReference,
+          "head-model frameOfRef is not correct type.");
+      }),
+      session.requestFrameOfReference("eye-level").then( (frameOfRef) => {
+        assert_true(frameOfRef instanceof XRCoordinateSystem,
+          "eye-level frameOfRef is not correct type.");
+        assert_true(frameOfRef instanceof XRFrameOfReference,
+          "eye-level frameOfRef is not correct type.");
+      }),
+      session.requestFrameOfReference("stage").then( (frameOfRef) => {
+        assert_true(frameOfRef instanceof XRCoordinateSystem,
+          "stage frameOfRef is not correct type.");
+        assert_true(frameOfRef instanceof XRFrameOfReference,
+          "stage frameOfRef is not correct type.");
+      })
+  ]));
+};
+
+xr_session_promise_test(
+  testFunction, fakeDeviceInitParams, requestSessionOptions, testName);
+
+</script>