sensors: Rewrite the frequency hint test.

This test has been flaky on the Mac bots for a very long time. Previous
efforts such as r770328 ('sensors: Make frequency hint test wait for another
slow sensor "tick"') did improve things a bit, but the flakiness has not
been fully fixed.

The problem is that our mock platform sensor dispatches sensor reading
notifications via window.setInterval(), and the actual period of the
callback can vary significantly, to the point where we cannot make any
assumptions about how precise it will be. The Mac bots in particular seem to
have big deviations in the timer's precision.

Consequently, we also cannot assume a faster sensor will really receive more
"reading" events than a slower one, or how long it will take for it to
happen.

Make the test deterministic at the expense of testing a less "real" use
case: instead of comparing how many times each sensor receives a "reading"
event, we just check that MockSensor.getSamplingFrequency() is adjusted
accordingly depending on which sensors are active.

Bug: 731018
Change-Id: Idc994d7e7d1cfb30d7c4e2f4b285494faff7160c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2401139
Commit-Queue: Raphael Kubo da Costa <raphael.kubo.da.costa@intel.com>
Auto-Submit: Raphael Kubo da Costa <raphael.kubo.da.costa@intel.com>
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#805674}

third_party/blink/web_tests/TestExpectations

@@ -5799,12 +5799,6 @@ crbug.com/1003055 external/wpt/css/css-scroll-snap/scroll-target-align-002.html
 crbug.com/1003055 external/wpt/css/css-scroll-snap/scroll-target-snap-001.html [ Failure ]
 crbug.com/1003055 external/wpt/css/css-scroll-snap/scroll-target-snap-002.html [ Failure ]
 
-# Sheriff 2019-09-12
-crbug.com/731018 [ Mac ] external/wpt/accelerometer/Accelerometer.https.html [ Pass Failure ]
-crbug.com/731018 [ Mac ] external/wpt/gyroscope/Gyroscope.https.html [ Pass Failure ]
-crbug.com/731018 [ Mac ] external/wpt/orientation-sensor/AbsoluteOrientationSensor.https.html [ Pass Failure ]
-crbug.com/731018 [ Mac ] external/wpt/orientation-sensor/RelativeOrientationSensor.https.html [ Pass Failure ]
-
 # Sheriff 2019-09-20
 crbug.com/1005128 crypto/subtle/abandon-crypto-operation2.html [ Pass Crash ]
 

third_party/blink/web_tests/external/wpt/generic-sensor/generic-sensor-tests.js

@@ -371,47 +371,40 @@ function runGenericSensorTests(sensorName,
 
   sensor_test(async (t, sensorProvider) => {
     assert_implements(sensorName in self, `${sensorName} is not supported.`);
-    const fastSensor = new sensorType({frequency: 60});
+
+    const fastSensor = new sensorType({ frequency: 60 });
+    t.add_cleanup(() => { fastSensor.stop(); });
+    let eventWatcher = new EventWatcher(t, fastSensor, "activate");
     fastSensor.start();
 
+    // Wait for |fastSensor| to be activated so that the call to
+    // getSamplingFrequency() below works.
+    await eventWatcher.wait_for("activate");
+
     const mockSensor = await sensorProvider.getCreatedSensor(sensorName);
     await mockSensor.setSensorReading(readings);
 
-    return new Promise((resolve, reject) => {
-      let fastSensorNotifiedCounter = 0;
-      let slowSensorNotifiedCounter = 0;
-
-      fastSensor.onreading = () => {
-        if (fastSensorNotifiedCounter === 0) {
-          // For Magnetometer and ALS, the maximum frequency is less than 60Hz
-          // we make "slow" sensor 4 times slower than the actual applied
-          // frequency, so that the "fast" sensor will immediately overtake it
-          // despite the notification adjustments.
-          const slowFrequency = mockSensor.getSamplingFrequency() * 0.25;
-          const slowSensor = new sensorType({frequency: slowFrequency});
-          slowSensor.onreading = () => {
-            // Skip the initial notification that always comes immediately.
-            if (slowSensorNotifiedCounter === 2) {
-              fastSensor.stop();
-              slowSensor.stop();
-
-              try {
-                assert_greater_than(fastSensorNotifiedCounter, 3,
-                    "Fast sensor overtakes the slow one");
-                resolve();
-              } catch (e) {
-                reject(e);
-              }
-            }
-            slowSensorNotifiedCounter++;
-          }
-          slowSensor.onerror = reject;
-          slowSensor.start();
-        }
-        fastSensorNotifiedCounter++;
-      }
-      fastSensor.onerror = reject;
-    });
+    // We need |fastSensorFrequency| because 60Hz might be higher than a sensor
+    // type's maximum allowed frequency.
+    const fastSensorFrequency = mockSensor.getSamplingFrequency();
+    const slowSensorFrequency = fastSensorFrequency * 0.25;
+
+    const slowSensor = new sensorType({ frequency: slowSensorFrequency });
+    t.add_cleanup(() => { slowSensor.stop(); });
+    eventWatcher = new EventWatcher(t, slowSensor, "activate");
+    slowSensor.start();
+
+    // Wait for |slowSensor| to be activated before we check if the mock
+    // platform sensor's sampling frequency has changed.
+    await eventWatcher.wait_for("activate");
+    assert_equals(mockSensor.getSamplingFrequency(), fastSensorFrequency);
+
+    // Now stop |fastSensor| and verify that the sampling frequency has dropped
+    // to the one |slowSensor| had requested.
+    fastSensor.stop();
+    return t.step_wait(() => {
+      return mockSensor.getSamplingFrequency() === slowSensorFrequency;
+    }, "Sampling frequency has dropped to slowSensor's requested frequency");
   }, `${sensorName}: frequency hint works.`);
 
 //  Re-enable after https://github.com/w3c/sensors/issues/361 is fixed.