[Sensors] Stop exposing sensor state

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(e);
@@ skipping 16 matching lines @@
 
     // Helper function that returns resolved promise with result.
     function sensorResponse(success) {
       return Promise.resolve({success});
     }
 
     // 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_ = [];
@@ skipping 74 matching lines @@
           this.resume_called_(this);
         }
       }
 
       // Mock functions
 
       // Resets mock Sensor state.
       reset() {
         this.stopReading();
 
-        this.expects_modified_reading_ = false;
         this.reading_updates_count_ = 0;
         this.start_should_fail_ = false;
         this.update_reading_function_ = null;
         this.active_sensor_configurations_ = [];
         this.suspend_called_ = null;
         this.resume_called_ = null;
         this.add_configuration_called_ = null;
         this.remove_configuration_called_ = null;
         this.resetBuffer();
         core.unmapBuffer(this.buffer_array_);
@@ skipping 12 matching lines @@
       setUpdateSensorReadingFunction(update_reading_function) {
         this.update_reading_function_ = update_reading_function;
         return Promise.resolve(this);
       }
 
       // Sets flag that forces sensor to fail when addConfiguration is invoked.
       setStartShouldFail(should_fail) {
         this.start_should_fail_ = should_fail;
       }
 
-      // Sets flags that asks for a modified reading values at each iteration
-      // to initiate 'onchange' event broadcasting.
-      setExpectsModifiedReading(expects_modified_reading) {
-        this.expects_modified_reading_ = expects_modified_reading;
-      }
-
       // Returns resolved promise if suspend() was called, rejected otherwise.
       suspendCalled() {
         return new Promise((resolve, reject) => {
           this.suspend_called_ = resolve;
         });
       }
 
       // Returns resolved promise if resume() was called, rejected otherwise.
       resumeCalled() {
         return new Promise((resolve, reject) => {
@@ skipping 16 matching lines @@
       }
 
       startReading() {
         if (this.update_reading_function_ != null) {
           this.stopReading();
           let max_frequency_used =
               this.active_sensor_configurations_[0].frequency;
           let timeout = (1 / max_frequency_used) * 1000;
           this.sensor_reading_timer_id_ = window.setInterval(() => {
             if (this.update_reading_function_) {
-              this.update_reading_function_(this.buffer_,
-                                            this.expects_modified_reading_,
-                                            this.reading_updates_count_);
+              this.update_reading_function_(this.buffer_);
               this.reading_updates_count_++;
             }
             if (this.reporting_mode_ === sensor.ReportingMode.ON_CHANGE) {
               this.client_.sensorReadingChanged();
             }
           }, timeout);
         }
       }
 
       stopReading() {
@@ skipping 163 matching lines @@
     };
 
     let onFailure = error => {
       sensor.mockSensorProvider.reset();
       return new Promise((resolve, reject) => { setTimeout(() => {reject(error);}, 0); });
     };
 
     return Promise.resolve(func(sensor)).then(onSuccess, onFailure);
   }), name, properties);
 }