tor-browser

generic-sensor-iframe-tests.sub.js (14198B)

---

function send_message_to_iframe(iframe, message) {
 return new Promise((resolve, reject) => {
   window.addEventListener('message', (e) => {
     // The usage of test_driver.set_test_context() in
     // iframe_sensor_handler.html causes unrelated messages to be sent as
     // well. We just need to ignore them here.
     if (!e.data.command) {
       return;
     }

     if (e.data.command !== message.command) {
       reject(`Expected reply with command '${message.command}', got '${
           e.data.command}' instead`);
       return;
     }
     if (e.data.error) {
       reject(e.data.error);
       return;
     }
     resolve(e.data.result);
   });
   iframe.contentWindow.postMessage(message, '*');
 });
}

function run_generic_sensor_iframe_tests(sensorData, readingData) {
 validate_sensor_data(sensorData);
 validate_reading_data(readingData);

 const {sensorName, permissionName, testDriverName} = sensorData;
 const sensorType = self[sensorName];
 const featurePolicies = get_feature_policies_for_sensor(sensorName);

 // When comparing timestamps in the tests below, we need to account for small
 // deviations coming from the way time is coarsened according to the High
 // Resolution Time specification, even more so when we need to translate
 // timestamps from different documents with different time origins.
 // 0.5 is 500 microseconds, which is acceptable enough given that even a high
 // sensor frequency beyond what is usually allowed like 100Hz has a period
 // much larger than 0.5ms.
 const ALLOWED_JITTER_IN_MS = 0.5;

 function sensor_test(func, name, properties) {
   promise_test(async t => {
     assert_implements(sensorName in self, `${sensorName} is not supported.`);
     const readings = new RingBuffer(readingData.readings);
     return func(t, readings);
   }, name, properties);
 }

 promise_setup(async () => {
   // Ensure window's document starts with focus so that it can receive data.
   await test_driver.click(document.documentElement);
 });

 sensor_test(async (t, readings) => {
   // This is a specialized EventWatcher that works with a sensor inside a
   // cross-origin iframe. We cannot manipulate the sensor object there
   // directly from this frame, so we need the iframe to send us a message
   // when the "reading" event is fired, and we decide whether we were
   // expecting for it or not. This should be instantiated early in the test
   // to catch as many unexpected events as possible.
   class IframeSensorReadingEventWatcher {
     constructor(test_obj) {
       this.resolve_ = null;

       window.onmessage = test_obj.step_func((ev) => {
         // Unrelated message, ignore.
         if (!ev.data.eventName) {
           return;
         }

         assert_equals(
             ev.data.eventName, 'reading', 'Expecting a "reading" event');
         assert_true(
             !!this.resolve_,
             'Received "reading" event from iframe but was not expecting one');
         const resolveFunc = this.resolve_;
         this.resolve_ = null;
         resolveFunc(ev.data.serializedSensor);
       });
     }

     wait_for_reading() {
       return new Promise(resolve => {
         this.resolve_ = resolve;
       });
     }
   };

   // Create main frame sensor.
   await test_driver.bidi.permissions.set_permission(
       {descriptor: {name: permissionName}, state: 'granted'});
   await test_driver.create_virtual_sensor(testDriverName);
   const sensor = new sensorType();
   t.add_cleanup(async () => {
     sensor.stop();
     await test_driver.remove_virtual_sensor(testDriverName);
   });
   const sensorWatcher =
       new EventWatcher(t, sensor, ['activate', 'reading', 'error']);

   // Create cross-origin iframe and a sensor inside it.
   const iframe = document.createElement('iframe');
   iframe.allow = featurePolicies.join(';') + '; focus-without-user-activation;';
   iframe.src =
       'https://{{domains[www1]}}:{{ports[https][0]}}/generic-sensor/resources/iframe_sensor_handler.html';
   const iframeLoadWatcher = new EventWatcher(t, iframe, 'load');
   document.body.appendChild(iframe);
   t.add_cleanup(async () => {
     await send_message_to_iframe(iframe, {command: 'stop_sensor'});
     iframe.parentNode.removeChild(iframe);
   });
   await iframeLoadWatcher.wait_for('load');
   const iframeSensorWatcher = new IframeSensorReadingEventWatcher(t);
   await send_message_to_iframe(
       iframe, {command: 'create_sensor', sensorData});

   // Start the test by focusing the main frame. It is already focused by
   // default, but this makes the test easier to follow.
   // When the main frame is focused, it sensor is expected to fire "reading"
   // events and provide access to new reading values while the sensor in the
   // cross-origin iframe is not.
   window.focus();

   // Start both sensors. They should both have the same state: active, but no
   // readings have been provided to them yet.
   await send_message_to_iframe(iframe, {command: 'start_sensor'});
   sensor.start();
   await sensorWatcher.wait_for('activate');
   assert_false(
       await send_message_to_iframe(iframe, {command: 'has_reading'}));
   assert_false(sensor.hasReading);

   // We store `reading` here because we want to make sure the very same
   // value is accepted later.
   const reading = readings.next().value;
   await Promise.all([
     sensorWatcher.wait_for('reading'),
     test_driver.update_virtual_sensor(testDriverName, reading),
     // Since we do not wait for the iframe sensor's "reading" event, it could
     // arguably be delivered later. There are enough async calls happening
     // that IframeSensorReadingEventWatcher would end up catching it and
     // throwing an error.
   ]);
   assert_true(sensor.hasReading);
   assert_false(
       await send_message_to_iframe(iframe, {command: 'has_reading'}));

   // Save sensor data for later before the sensor is stopped.
   const savedMainFrameSensorReadings = serialize_sensor_data(sensor);

   sensor.stop();
   await send_message_to_iframe(iframe, {command: 'stop_sensor'});

   // The sensors are stopped; queue the same reading. The virtual sensor
   // would send it anyway, but this update changes its timestamp.
   await test_driver.update_virtual_sensor(testDriverName, reading);

   // Now focus the cross-origin iframe. The situation should be the opposite:
   // the sensor in the main frame should not fire any "reading" events or
   // provide access to updated readings, but the sensor in the iframe should.
   iframe.contentWindow.focus();

   // Start both sensors. Only the iframe sensor should receive a reading
   // event and contain readings.
   sensor.start();
   await sensorWatcher.wait_for('activate');
   await send_message_to_iframe(iframe, {command: 'start_sensor'});
   const serializedIframeSensor = await iframeSensorWatcher.wait_for_reading();
   assert_true(await send_message_to_iframe(iframe, {command: 'has_reading'}));
   assert_false(sensor.hasReading);

   assert_sensor_reading_is_null(sensor);

   assert_sensor_reading_equals(
       savedMainFrameSensorReadings, serializedIframeSensor,
       {ignoreTimestamps: true});

   // We could check that serializedIframeSensor.timestamp (adjusted to this
   // frame by adding the iframe's timeOrigin and substracting
   // performance.timeOrigin) is greater than
   // savedMainFrameSensorReadings.timestamp (or other timestamps prior to the
   // last test_driver.update_virtual_sensor() call), but this is surprisingly
   // tricky and flaky due to the fact that we are using timestamps from
   // cross-origin frames.
   //
   // On Chrome on Windows (M120 at the time of writing), for example, the
   // difference between timeOrigin values is sometimes off by more than 10ms
   // from the real difference, and allowing for this much jitter makes the
   // test not test something meaningful.
 }, `${sensorName}: unfocused sensors in cross-origin frames are not updated`);

 sensor_test(async (t, readings) => {
   // Create main frame sensor.
   await test_driver.bidi.permissions.set_permission(
       {descriptor: {name: permissionName}, state: 'granted'});
   await test_driver.create_virtual_sensor(testDriverName);
   const sensor = new sensorType();
   t.add_cleanup(async () => {
     sensor.stop();
     await test_driver.remove_virtual_sensor(testDriverName);
   });
   const sensorWatcher =
       new EventWatcher(t, sensor, ['activate', 'reading', 'error']);

   // Create same-origin iframe and a sensor inside it.
   const iframe = document.createElement('iframe');
   iframe.allow = featurePolicies.join(';') + ';';
   iframe.src = 'https://{{host}}:{{ports[https][0]}}/resources/blank.html';
   // Create sensor inside same-origin nested browsing context.
   const iframeLoadWatcher = new EventWatcher(t, iframe, 'load');
   document.body.appendChild(iframe);
   t.add_cleanup(() => {
     if (iframeSensor) {
       iframeSensor.stop();
     }
     iframe.parentNode.removeChild(iframe);
   });
   await iframeLoadWatcher.wait_for('load');
   // We deliberately create the sensor here instead of using
   // send_messge_to_iframe() because this is a same-origin iframe, and we can
   // therefore use EventWatcher() to wait for "reading" events a lot more
   // easily.
   const iframeSensor = new iframe.contentWindow[sensorName]();
   const iframeSensorWatcher =
       new EventWatcher(t, iframeSensor, ['activate', 'error', 'reading']);

   // Focus a different same-origin window each time and check that everything
   // works the same.
   for (const windowObject of [window, iframe.contentWindow]) {
     await test_driver.update_virtual_sensor(
         testDriverName, readings.next().value);

     windowObject.focus();

     iframeSensor.start();
     sensor.start();

     await Promise.all([
       iframeSensorWatcher.wait_for(['activate', 'reading']),
       sensorWatcher.wait_for(['activate', 'reading'])
     ]);

     assert_greater_than(
         iframe.contentWindow.performance.timeOrigin, performance.timeOrigin,
         'iframe\'s time origin must be higher than the main window\'s');

     // Check that the timestamps are similar enough to indicate that this is
     // the same reading that was delivered to both sensors.
     // The values are not identical due to how high resolution time is
     // coarsened.
     const translatedIframeSensorTimestamp = iframeSensor.timestamp +
         iframe.contentWindow.performance.timeOrigin - performance.timeOrigin;
     assert_approx_equals(
         translatedIframeSensorTimestamp, sensor.timestamp,
         ALLOWED_JITTER_IN_MS);

     // Do not compare timestamps here because of the reasons above.
     assert_sensor_reading_equals(
         sensor, iframeSensor, {ignoreTimestamps: true});

     // Stop all sensors so we can use the same value in `reading` on every
     // loop iteration.
     iframeSensor.stop();
     sensor.stop();
   }
 }, `${sensorName}: sensors in same-origin frames are updated if one of the frames is focused`);

 promise_test(async t => {
   assert_implements(sensorName in self, `${sensorName} is not supported.`);
   const iframe = document.createElement('iframe');
   iframe.allow = featurePolicies.join(';') + ';';
   iframe.src =
       'https://{{host}}:{{ports[https][0]}}/generic-sensor/resources/iframe_sensor_handler.html';

   const iframeLoadWatcher = new EventWatcher(t, iframe, 'load');
   document.body.appendChild(iframe);
   await iframeLoadWatcher.wait_for('load');

   // Create sensor in the iframe.
   await test_driver.bidi.permissions.set_permission(
       {descriptor: {name: permissionName}, state: 'granted'});
   await test_driver.create_virtual_sensor(testDriverName);
   iframe.contentWindow.focus();
   const iframeSensor = new iframe.contentWindow[sensorName]();
   t.add_cleanup(async () => {
     iframeSensor.stop();
     await test_driver.remove_virtual_sensor(testDriverName);
   });
   const sensorWatcher = new EventWatcher(t, iframeSensor, ['activate']);
   iframeSensor.start();
   await sensorWatcher.wait_for('activate');

   // Remove iframe from main document and change focus. When focus changes,
   // we need to determine whether a sensor must have its execution suspended
   // or resumed (section 4.2.3, "Focused Area" of the Generic Sensor API
   // spec). In Blink, this involves querying a frame, which might no longer
   // exist at the time of the check.
   iframe.parentNode.removeChild(iframe);
   window.focus();
 }, `${sensorName}: losing a document's frame with an active sensor does not crash`);

 promise_test(async t => {
   assert_implements(sensorName in self, `${sensorName} is not supported.`);
   const iframe = document.createElement('iframe');
   iframe.allow = featurePolicies.join(';') + ';';
   iframe.src =
       'https://{{host}}:{{ports[https][0]}}/generic-sensor/resources/iframe_sensor_handler.html';

   const iframeLoadWatcher = new EventWatcher(t, iframe, 'load');
   document.body.appendChild(iframe);
   await iframeLoadWatcher.wait_for('load');

   // Create sensor in the iframe.
   await test_driver.bidi.permissions.set_permission(
       {descriptor: {name: permissionName}, state: 'granted'});
   await test_driver.create_virtual_sensor(testDriverName);
   const iframeSensor = new iframe.contentWindow[sensorName]();
   t.add_cleanup(async () => {
     iframeSensor.stop();
     await test_driver.remove_virtual_sensor(testDriverName);
   });
   assert_not_equals(iframeSensor, null);

   // Remove iframe from main document. |iframeSensor| no longer has a
   // non-null browsing context. Calling start() should probably throw an
   // error when called from a non-fully active document, but that depends on
   // https://github.com/w3c/sensors/issues/415
   iframe.parentNode.removeChild(iframe);
   iframeSensor.start();
 }, `${sensorName}: calling start() in a non-fully active document does not crash`);
}