tor-browser

generic-sensor-helpers.js (5838B)

---

'use strict';

// If two doubles differ by less than this amount, we can consider them
// to be effectively equal.
const kEpsilon = 1e-8;

class RingBuffer {
 constructor(data) {
   if (!Array.isArray(data)) {
     throw new TypeError('`data` must be an array.');
   }

   this.bufferPosition_ = 0;
   this.data_ = Array.from(data);
 }

 get data() {
   return Array.from(this.data_);
 }

 next() {
   const value = this.data_[this.bufferPosition_];
   this.bufferPosition_ = (this.bufferPosition_ + 1) % this.data_.length;
   return {done: false, value: value};
 }

 value() {
   return this.data_[this.bufferPosition_];
 }

 [Symbol.iterator]() {
   return this;
 }

 reset() {
   this.bufferPosition_ = 0;
 }
};

// Calls test_driver.update_virtual_sensor() until it results in a "reading"
// event. It waits |timeoutInMs| before considering that an event has not been
// delivered.
async function update_virtual_sensor_until_reading(
   t, readings, readingPromise, testDriverName, timeoutInMs) {
 while (true) {
   await test_driver.update_virtual_sensor(
       testDriverName, readings.next().value);
   const value = await Promise.race([
     new Promise(
         resolve => {t.step_timeout(() => resolve('TIMEOUT'), timeoutInMs)}),
     readingPromise,
   ]);
   if (value !== 'TIMEOUT') {
     break;
   }
 }
}

// This could be turned into a t.step_wait() call once
// https://github.com/web-platform-tests/wpt/pull/34289 is merged.
async function wait_for_virtual_sensor_state(testDriverName, predicate) {
 const result =
     await test_driver.get_virtual_sensor_information(testDriverName);
 if (!predicate(result)) {
   await wait_for_virtual_sensor_state(testDriverName, predicate);
 }
}

function validate_sensor_data(sensorData) {
 if (!('sensorName' in sensorData)) {
   throw new TypeError('sensorData.sensorName is missing');
 }
 if (!('permissionName' in sensorData)) {
   throw new TypeError('sensorData.permissionName is missing');
 }
 if (!('testDriverName' in sensorData)) {
   throw new TypeError('sensorData.testDriverName is missing');
 }
 if (sensorData.featurePolicyNames !== undefined &&
     !Array.isArray(sensorData.featurePolicyNames)) {
   throw new TypeError('sensorData.featurePolicyNames must be an array');
 }
}

function validate_reading_data(readingData) {
 if (!Array.isArray(readingData.readings)) {
   throw new TypeError('readingData.readings must be an array.');
 }
 if (!Array.isArray(readingData.expectedReadings)) {
   throw new TypeError('readingData.expectedReadings must be an array.');
 }
 if (readingData.readings.length < readingData.expectedReadings.length) {
   throw new TypeError(
       'readingData.readings\' length must be bigger than ' +
       'or equal to readingData.expectedReadings\' length.');
 }
 if (readingData.expectedRemappedReadings &&
     !Array.isArray(readingData.expectedRemappedReadings)) {
   throw new TypeError(
       'readingData.expectedRemappedReadings must be an ' +
       'array.');
 }
 if (readingData.expectedRemappedReadings &&
     readingData.expectedReadings.length !=
         readingData.expectedRemappedReadings.length) {
   throw new TypeError(
       'readingData.expectedReadings and ' +
       'readingData.expectedRemappedReadings must have the same ' +
       'length.');
 }
}

function get_sensor_reading_properties(sensor) {
 const className = sensor[Symbol.toStringTag];
 if ([
       'Accelerometer', 'GravitySensor', 'Gyroscope',
       'LinearAccelerationSensor', 'Magnetometer', 'ProximitySensor'
     ].includes(className)) {
   return ['x', 'y', 'z'];
 } else if (className == 'AmbientLightSensor') {
   return ['illuminance'];
 } else if ([
              'AbsoluteOrientationSensor', 'RelativeOrientationSensor'
            ].includes(className)) {
   return ['quaternion'];
 } else {
   throw new TypeError(`Unexpected sensor '${className}'`);
 }
}

// Checks that `sensor` and `expectedSensorLike` have the same properties
// (except for timestamp) and they have the same values.
//
// Options allows configuring some aspects of the comparison:
// - ignoreTimestamps (boolean): If true, `sensor` and `expectedSensorLike`'s
//   "timestamp" attribute will not be compared. If `expectedSensorLike` does
//   not have a "timestamp" attribute, the values will not be compared either.
//   This is particularly useful when comparing sensor objects from different
//   origins (and consequently different time origins).
function assert_sensor_reading_equals(
   sensor, expectedSensorLike, options = {}) {
 for (const prop of get_sensor_reading_properties(sensor)) {
   assert_true(
       prop in expectedSensorLike,
       `expectedSensorLike must have a property called '${prop}'`);
   if (Array.isArray(sensor[prop]))
     assert_array_approx_equals(
         sensor[prop], expectedSensorLike[prop], kEpsilon);
   else
     assert_approx_equals(sensor[prop], expectedSensorLike[prop], kEpsilon);
 }
 assert_not_equals(sensor.timestamp, null);

 if ('timestamp' in expectedSensorLike && !options.ignoreTimestamps) {
   assert_equals(
       sensor.timestamp, expectedSensorLike.timestamp,
       'Sensor timestamps must be equal');
 }
}

function assert_sensor_reading_is_null(sensor) {
 for (const prop of get_sensor_reading_properties(sensor)) {
   assert_equals(sensor[prop], null);
 }
 assert_equals(sensor.timestamp, null);
}

function serialize_sensor_data(sensor) {
 const sensorData = {};
 for (const property of get_sensor_reading_properties(sensor)) {
   sensorData[property] = sensor[property];
 }
 sensorData['timestamp'] = sensor.timestamp;

 // Note that this is not serialized by postMessage().
 sensorData[Symbol.toStringTag] = sensor[Symbol.toStringTag];

 return sensorData;
}