[Sensors] Clamp given sampling frequency to the minimum supported one

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 231 matching lines @@
                 core.createSharedBuffer(
                         this.shared_buffer_size_in_bytes_,
                         core.CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE);
         assert_equals(rv.result, core.RESULT_OK, "Failed to create buffer");
         this.shared_buffer_handle_ = rv.handle;
         this.active_sensor_ = null;
         this.get_sensor_should_fail_ = false;
         this.resolve_func_ = null;
         this.is_continuous_ = false;
         this.max_frequency_ = 60;
+        this.min_frequency_ = 1;
         this.binding_ = new bindings.Binding(sensor_provider.SensorProvider,
                                              this);
       }
 
       // Returns initialized Sensor proxy to the client.
       getSensor(type, request) {
         if (this.get_sensor_should_fail_) {
           var ignored = new sensor.SensorClientPtr();
           return getSensorResponse(null, bindings.makeRequest(ignored));
         }
@@ skipping 19 matching lines @@
         assert_equals(rv.result, core.RESULT_OK);
 
         let default_config = {frequency: 5};
 
         let init_params =
             new sensor_provider.SensorInitParams(
                 { memory: rv.handle,
                   buffer_offset: offset,
                   mode: reporting_mode,
                   default_configuration: default_config,
+                  minimum_frequency: this.min_frequency_,
                   maximum_frequency: this.max_frequency_});
 
         if (this.resolve_func_ !== null) {
           this.resolve_func_(this.active_sensor_);
         }
 
         this.active_sensor_.client_ = new sensor.SensorClientPtr();
         return getSensorResponse(
             init_params, bindings.makeRequest(this.active_sensor_.client_));
       }
@@ skipping 11 matching lines @@
       // Resets state of mock SensorProvider between test runs.
       reset() {
         if (this.active_sensor_ != null) {
           this.active_sensor_.reset();
           this.active_sensor_ = null;
         }
 
         this.get_sensor_should_fail_ = false;
         this.resolve_func_ = null;
         this.max_frequency_ = 60;
+        this.min_frequency_ = 1;
         this.is_continuous_ = false;
         this.binding_.close();
       }
 
       // Sets flag that forces mock SensorProvider to fail when getSensor() is
       // invoked.
       setGetSensorShouldFail(should_fail) {
         this.get_sensor_should_fail_ = should_fail;
       }
 
@@ skipping 10 matching lines @@
 
       // Forces sensor to use |reporting_mode| as an update mode.
       setContinuousReportingMode() {
           this.is_continuous_ = true;
       }
 
       // Sets the maximum frequency for a concrete sensor.
       setMaximumSupportedFrequency(frequency) {
           this.max_frequency_ = frequency;
       }
+
+      // Sets the minimum frequency for a concrete sensor.
+      setMinimumSupportedFrequency(frequency) {
+          this.min_frequency_ = frequency;
+      }
     }
 
     let mockSensorProvider = new MockSensorProvider;
     mojo.frameInterfaces.addInterfaceOverrideForTesting(
         sensor_provider.SensorProvider.name,
         pipe => {
           mockSensorProvider.bindToPipe(pipe);
         });
 
     return Promise.resolve({
@@ skipping 13 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);
 }