[Sensors] Reland: Align sensor reading updates and 'onchange' notification with rAF.

third_party/WebKit/LayoutTests/sensor/resources/sensor-helpers.js

 'use strict';
 
 // Wraps callback and calls reject_func if callback throws an error.
 class CallbackWrapper {
   constructor(callback, reject_func) {
     this.wrapper_func_ = (args) => {
       try {
         callback(args);
       } catch(e) {
         reject_func();
@@ skipping 21 matching lines @@
 
     // Class that mocks Sensor interface defined in sensor.mojom
     class MockSensor {
       constructor(sensorRequest, handle, offset, size, reportingMode) {
         this.client_ = null;
         this.expects_modified_reading_ = false;
         this.start_should_fail_ = false;
         this.reporting_mode_ = reportingMode;
         this.sensor_reading_timer_id_ = null;
         this.update_reading_function_ = null;
+        this.reading_updates_count_ = 0;
         this.suspend_called_ = null;
         this.resume_called_ = null;
         this.add_configuration_called_ = null;
         this.remove_configuration_called_ = null;
         this.active_sensor_configurations_ = [];
         let rv = core.mapBuffer(handle, offset, size,
             core.MAP_BUFFER_FLAG_NONE);
         assert_equals(rv.result, core.RESULT_OK, "Failed to map shared buffer");
         this.buffer_array_ = rv.buffer;
         this.buffer_ = new Float64Array(this.buffer_array_);
         this.resetBuffer();
         this.binding_ = new bindings.Binding(sensor.Sensor, this,
                                              sensorRequest);
         this.binding_.setConnectionErrorHandler(() => {
           this.reset();
         });
       }
 
       // Returns default configuration.
       getDefaultConfiguration() {
         return Promise.resolve({frequency: 5});
       }
 
+      reading_updates_count() {
+        return this.reading_updates_count_;
+      }
       // Adds configuration for the sensor and starts reporting fake data
       // through update_reading_function_ callback.
       addConfiguration(configuration) {
         assert_not_equals(configuration, null, "Invalid sensor configuration.");
 
         this.active_sensor_configurations_.push(configuration);
         // Sort using descending order.
         this.active_sensor_configurations_.sort(
             (first, second) => { return second.frequency - first.frequency });
 
@@ skipping 114 matching lines @@
         return new Promise((resolve, reject) => {
           this.remove_configuration_called_ = resolve;
         });
       }
 
       startReading() {
         if (this.update_reading_function_ != null) {
           let max_frequency_used =
               this.active_sensor_configurations_[0].frequency;
           let timeout = (1 / max_frequency_used) * 1000;
           this.sensor_reading_timer_id_ = window.setInterval(() => {

[shalamov, 2016/12/21 10:41:03]

Should we clear previous interval if addConfiguration called multiple times?
e.g. when there are two active JS sensor objects?

[Mikhail, 2016/12/21 13:06:28]

Right, thanks for the catch!

-            if (this.update_reading_function_)
+            if (this.update_reading_function_) {
               this.update_reading_function_(this.buffer_,
-                                            this.expects_modified_reading_);
+                                            this.expects_modified_reading_,
+                                            this.reading_updates_count_);
+              this.reading_updates_count_++;
+            }
             if (this.reporting_mode_ === sensor.ReportingMode.ON_CHANGE) {
               this.client_.sensorReadingChanged();
             }
           }, timeout);
         }
       }
 
       stopReading() {
         if (this.sensor_reading_timer_id_ != null) {
           window.clearInterval(this.sensor_reading_timer_id_);
@@ skipping 153 matching lines @@
     };
 
     let onFailure = () => {
       sensor.mockSensorProvider.reset();
       return new Promise((resolve, reject) => { setTimeout(reject, 0); });
     };
 
     return Promise.resolve(func(sensor)).then(onSuccess, onFailure);
   }), name, properties);
 }