[Sensors] Consider maximum supported frequency

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

 'use strict';
 
 function sensor_mocks(mojo) {
   return define('Generic Sensor API mocks', [
     'mojo/public/js/core',
     'mojo/public/js/bindings',
     'mojo/public/js/connection',
     'device/generic_sensor/public/interfaces/sensor_provider.mojom',
     'device/generic_sensor/public/interfaces/sensor.mojom',
   ], (core, bindings, connection, sensor_provider, sensor) => {
@@ skipping 177 matching lines @@
         let rv =
                 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;
       }
 
       // Returns initialized Sensor proxy to the client.
       getSensor(type, stub) {
         if (this.get_sensor_should_fail_) {
           return getSensorResponse(null,
               connection.bindProxy(null, sensor.SensorClient));
         }
 
         let offset =
@@ skipping 16 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 });
+                  default_configuration: default_config,
+                  maximum_frequency: this.max_frequency_});
 
         if (this.resolve_func_ !== null) {
           this.resolve_func_(this.active_sensor_);
         }
 
         var client_handle = connection.bindProxy(proxy => {
           this.active_sensor_.client_ = proxy;
           }, sensor.SensorClient);
-
         return getSensorResponse(init_params, client_handle);
       }
 
       // Binds object to mojo message pipe
       bindToPipe(pipe) {
         this.stub_ = connection.bindHandleToStub(
             pipe, sensor_provider.SensorProvider);
         bindings.StubBindings(this.stub_).delegate = this;
       }
 
       // Mock functions
 
       // Resets state of mock SensorProvider between test runs.
       reset() {
         if (this.active_sensor_ != null) {
           this.active_sensor_.reset();
         }
 
         this.get_sensor_should_fail_ = false;
         this.resolve_func_ = null;
+        this.max_frequency_ = 60;
       }
 
       // Sets flag that forces mock SensorProvider to fail when getSensor() is
       // invoked.
       setGetSensorShouldFail(should_fail) {
         this.get_sensor_should_fail_ = should_fail;
       }
 
       // Returns mock sensor that was created in getSensor to the layout test.
       getCreatedSensor() {
         if (this.active_sensor_ != null) {
           return Promise.resolve(this.active_sensor_);
         }
 
         return new Promise((resolve, reject) => {
           this.resolve_func_ = resolve;
          });
       }
 
       // Forces sensor to use |reporting_mode| as an update mode.
       setContinuousReportingMode(reporting_mode) {
           this.is_continuous_ = reporting_mode;
       }
+
+      // Sets the maximum frequency for a concrete sensor.
+      setMaximumSupportedFrequency(frequency) {
+          this.max_frequency_ = frequency;
+      }
     }
 
     let mockSensorProvider = new MockSensorProvider;
     mojo.frameInterfaces.addInterfaceOverrideForTesting(
         sensor_provider.SensorProvider.name,
         pipe => {
           mockSensorProvider.bindToPipe(pipe);
         });
 
     return Promise.resolve({
       mockSensorProvider: mockSensorProvider,
     });
   });
 }
 
 function sensor_test(func, name, properties) {
   mojo_test(mojo => sensor_mocks(mojo).then(sensor => {
     let result = Promise.resolve(func(sensor));
     let cleanUp = () => { sensor.mockSensorProvider.reset(); };
     return result.then(cleanUp, cleanUp);
   }), name, properties);
 }