| OLD | NEW |
|---|
| (Empty) |
| 1 'use strict'; | |
| 2 | |
| 3 function sensor_mocks(mojo) { | |
| 4 return define('Generic Sensor API mocks', [ | |
| 5 'mojo/public/js/core', | |
| 6 'mojo/public/js/bindings', | |
| 7 'mojo/public/js/connection', | |
| 8 'device/generic_sensor/public/interfaces/sensor_provider.mojom', | |
| 9 'device/generic_sensor/public/interfaces/sensor.mojom', | |
| 10 ], (core, bindings, connection, sensor_provider, sensor) => { | |
| 11 | |
| 12 // Helper function that returns resolved promise with result. | |
| 13 function sensorResponse(success) { | |
| 14 return Promise.resolve({success}); | |
| 15 } | |
| 16 | |
| 17 // Class that mocks Sensor interface defined in sensor.mojom | |
| 18 class MockSensor { | |
| 19 constructor(stub, handle, offset, size, reportingMode) { | |
| 20 this.client_ = null; | |
| 21 this.stub_ = stub; | |
| 22 this.start_should_fail_ = false; | |
| 23 this.reporting_mode_ = reportingMode; | |
| 24 this.sensor_reading_timer_id_ = null; | |
| 25 this.update_reading_function_ = null; | |
| 26 this.suspend_called_ = null; | |
| 27 this.resume_called_ = null; | |
| 28 this.add_configuration_called_ = null; | |
| 29 this.remove_configuration_called_ = null; | |
| 30 this.active_sensor_configurations_ = []; | |
| 31 let rv = core.mapBuffer(handle, offset, size, | |
| 32 core.MAP_BUFFER_FLAG_NONE); | |
| 33 assert_equals(rv.result, core.RESULT_OK, "Failed to map shared buffer"); | |
| 34 this.buffer_array_ = rv.buffer; | |
| 35 this.buffer_ = new Float64Array(this.buffer_array_); | |
| 36 bindings.StubBindings(this.stub_).delegate = this; | |
| 37 bindings.StubBindings(this.stub_).connectionErrorHandler = () => { | |
| 38 reset(); | |
| 39 }; | |
| 40 } | |
| 41 | |
| 42 // Returns default configuration. | |
| 43 getDefaultConfiguration() { | |
| 44 return Promise.resolve({frequency: 5}); | |
| 45 } | |
| 46 | |
| 47 // Adds configuration for the sensor and starts reporting fake data | |
| 48 // through update_reading_function_ callback. | |
| 49 addConfiguration(configuration) { | |
| 50 assert_not_equals(configuration, null, "Invalid sensor configuration."); | |
| 51 | |
| 52 if (this.add_configuration_called_ != null) { | |
| 53 this.add_configuration_called_(this); | |
| 54 } | |
| 55 | |
| 56 if (!this.start_should_fail_ && this.update_reading_function_ != null) { | |
| 57 let timeout = (1 / configuration.frequency) * 1000; | |
| 58 this.sensor_reading_timer_id_ = window.setTimeout(() => { | |
| 59 this.update_reading_function_(this.buffer_); | |
| 60 if (this.reporting_mode_ === sensor.ReportingMode.ON_CHANGE) { | |
| 61 this.client_.sensorReadingChanged(); | |
| 62 } | |
| 63 }, timeout); | |
| 64 | |
| 65 this.active_sensor_configurations_.push(configuration); | |
| 66 } | |
| 67 | |
| 68 return sensorResponse(!this.start_should_fail_); | |
| 69 } | |
| 70 | |
| 71 // Removes sensor configuration from the list of active configurations and | |
| 72 // stops notification about sensor reading changes if | |
| 73 // active_sensor_configurations_ is empty. | |
| 74 removeConfiguration(configuration) { | |
| 75 if (this.remove_configuration_called_ != null) { | |
| 76 this.remove_configuration_called_(this); | |
| 77 } | |
| 78 | |
| 79 let index = this.active_sensor_configurations_.indexOf(configuration); | |
| 80 if (index !== -1) { | |
| 81 this.active_sensor_configurations_.splice(index, 1); | |
| 82 } else { | |
| 83 return sensorResponse(false); | |
| 84 } | |
| 85 | |
| 86 if (this.sensor_reading_timer_id_ != null | |
| 87 && this.active_sensor_configurations_.length === 0) { | |
| 88 window.clearTimeout(this.sensor_reading_timer_id_); | |
| 89 this.sensor_reading_timer_id_ = null; | |
| 90 } | |
| 91 | |
| 92 return sensorResponse(true); | |
| 93 } | |
| 94 | |
| 95 // Suspends sensor. | |
| 96 suspend() { | |
| 97 if (this.suspend_called_ != null) { | |
| 98 this.suspend_called_(this); | |
| 99 } | |
| 100 } | |
| 101 | |
| 102 // Resumes sensor. | |
| 103 resume() { | |
| 104 if (this.resume_called_ != null) { | |
| 105 this.resume_called_(this); | |
| 106 } | |
| 107 } | |
| 108 | |
| 109 // Mock functions | |
| 110 | |
| 111 // Resets mock Sensor state. | |
| 112 reset() { | |
| 113 if (this.sensor_reading_timer_id_) { | |
| 114 window.clearTimeout(this.sensor_reading_timer_id_); | |
| 115 } | |
| 116 | |
| 117 this.start_should_fail_ = false; | |
| 118 this.sensor_reading_timer_id_ = null; | |
| 119 this.active_sensor_configurations_ = []; | |
| 120 this.suspend_called_ = null; | |
| 121 this.resume_called_ = null; | |
| 122 this.add_configuration_called_ = null; | |
| 123 this.remove_configuration_called_ = null; | |
| 124 for (let i = 0; i < this.buffer_.length; ++i) { | |
| 125 this.buffer_[i] = 0; | |
| 126 } | |
| 127 } | |
| 128 | |
| 129 // Sets callback that is used to deliver sensor reading updates. | |
| 130 setUpdateSensorReadingFunction(update_reading_function) { | |
| 131 this.update_reading_function_ = update_reading_function; | |
| 132 return Promise.resolve(this); | |
| 133 } | |
| 134 | |
| 135 // Sets flag that forces sensor to fail when addConfiguration is invoked. | |
| 136 setStartShouldFail(should_fail) { | |
| 137 this.start_should_fail_ = should_fail; | |
| 138 } | |
| 139 | |
| 140 // Returns resolved promise if suspend() was called, rejected otherwise. | |
| 141 suspendCalled() { | |
| 142 return new Promise((resolve, reject) => { | |
| 143 this.suspend_called_ = resolve; | |
| 144 }); | |
| 145 } | |
| 146 | |
| 147 // Returns resolved promise if resume() was called, rejected otherwise. | |
| 148 resumeCalled() { | |
| 149 return new Promise((resolve, reject) => { | |
| 150 this.resume_called_ = resolve; | |
| 151 }); | |
| 152 } | |
| 153 | |
| 154 // Resolves promise when addConfiguration() is called. | |
| 155 addConfigurationCalled() { | |
| 156 return new Promise((resolve, reject) => { | |
| 157 this.add_configuration_called_ = resolve; | |
| 158 }); | |
| 159 } | |
| 160 | |
| 161 // Resolves promise when removeConfiguration() is called. | |
| 162 removeConfigurationCalled() { | |
| 163 return new Promise((resolve, reject) => { | |
| 164 this.remove_configuration_called_ = resolve; | |
| 165 }); | |
| 166 } | |
| 167 | |
| 168 } | |
| 169 | |
| 170 // Helper function that returns resolved promise for getSensor() function. | |
| 171 function getSensorResponse(init_params, client_request) { | |
| 172 return Promise.resolve({init_params, client_request}); | |
| 173 } | |
| 174 | |
| 175 // Class that mocks SensorProvider interface defined in | |
| 176 // sensor_provider.mojom | |
| 177 class MockSensorProvider { | |
| 178 constructor() { | |
| 179 this.reading_size_in_bytes_ = | |
| 180 sensor_provider.SensorInitParams.kReadBufferSize; | |
| 181 this.shared_buffer_size_in_bytes_ = this.reading_size_in_bytes_ * | |
| 182 sensor.SensorType.LAST; | |
| 183 let rv = | |
| 184 core.createSharedBuffer( | |
| 185 this.shared_buffer_size_in_bytes_, | |
| 186 core.CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE); | |
| 187 assert_equals(rv.result, core.RESULT_OK, "Failed to create buffer"); | |
| 188 this.shared_buffer_handle_ = rv.handle; | |
| 189 this.active_sensor_ = null; | |
| 190 this.get_sensor_should_fail_ = false; | |
| 191 this.resolve_func_ = null; | |
| 192 this.is_continuous_ = false; | |
| 193 } | |
| 194 | |
| 195 // Returns initialized Sensor proxy to the client. | |
| 196 getSensor(type, stub) { | |
| 197 if (this.get_sensor_should_fail_) { | |
| 198 return getSensorResponse(null, null); | |
| 199 } | |
| 200 | |
| 201 let offset = | |
| 202 (sensor.SensorType.LAST - type) * this.reading_size_in_bytes_; | |
| 203 let reporting_mode = sensor.ReportingMode.ON_CHANGE; | |
| 204 if (this.is_continuous_) { | |
| 205 reporting_mode = sensor.ReportingMode.CONTINUOUS; | |
| 206 } | |
| 207 | |
| 208 if (this.active_sensor_ == null) { | |
| 209 let mockSensor = new MockSensor(stub, this.shared_buffer_handle_, | |
| 210 offset, this.reading_size_in_bytes_, reporting_mode); | |
| 211 this.active_sensor_ = mockSensor; | |
| 212 } | |
| 213 | |
| 214 let rv = | |
| 215 core.duplicateBufferHandle( | |
| 216 this.shared_buffer_handle_, | |
| 217 core.DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE); | |
| 218 | |
| 219 assert_equals(rv.result, core.RESULT_OK); | |
| 220 | |
| 221 let default_config = {frequency: 5}; | |
| 222 | |
| 223 let init_params = | |
| 224 new sensor_provider.SensorInitParams( | |
| 225 { memory: rv.handle, | |
| 226 buffer_offset: offset, | |
| 227 mode: reporting_mode, | |
| 228 default_configuration: default_config }); | |
| 229 | |
| 230 if (this.resolve_func_ !== null) { | |
| 231 this.resolve_func_(this.active_sensor_); | |
| 232 } | |
| 233 | |
| 234 var client_handle = connection.bindProxy(proxy => { | |
| 235 this.active_sensor_.client_ = proxy; | |
| 236 }, sensor.SensorClient); | |
| 237 | |
| 238 return getSensorResponse(init_params, client_handle); | |
| 239 } | |
| 240 | |
| 241 // Binds object to mojo message pipe | |
| 242 bindToPipe(pipe) { | |
| 243 this.stub_ = connection.bindHandleToStub( | |
| 244 pipe, sensor_provider.SensorProvider); | |
| 245 bindings.StubBindings(this.stub_).delegate = this; | |
| 246 } | |
| 247 | |
| 248 // Mock functions | |
| 249 | |
| 250 // Resets state of mock SensorProvider between test runs. | |
| 251 reset() { | |
| 252 if (this.active_sensor_ != null) { | |
| 253 this.active_sensor_.reset(); | |
| 254 } | |
| 255 | |
| 256 this.get_sensor_should_fail_ = false; | |
| 257 this.resolve_func_ = null; | |
| 258 } | |
| 259 | |
| 260 // Sets flag that forces mock SensorProvider to fail when getSensor() is | |
| 261 // invoked. | |
| 262 setGetSensorShouldFail(should_fail) { | |
| 263 this.get_sensor_should_fail_ = should_fail; | |
| 264 } | |
| 265 | |
| 266 // Returns mock sensor that was created in getSensor to the layout test. | |
| 267 getCreatedSensor() { | |
| 268 if (this.active_sensor_ != null) { | |
| 269 return Promise.resolve(this.active_sensor_); | |
| 270 } | |
| 271 | |
| 272 return new Promise((resolve, reject) => { | |
| 273 this.resolve_func_ = resolve; | |
| 274 }); | |
| 275 } | |
| 276 | |
| 277 // Forces sensor to use |reporting_mode| as an update mode. | |
| 278 setContinuousReportingMode(reporting_mode) { | |
| 279 this.is_continuous_ = reporting_mode; | |
| 280 } | |
| 281 } | |
| 282 | |
| 283 let mockSensorProvider = new MockSensorProvider; | |
| 284 mojo.frameInterfaces.addInterfaceOverrideForTesting( | |
| 285 sensor_provider.SensorProvider.name, | |
| 286 pipe => { | |
| 287 mockSensorProvider.bindToPipe(pipe); | |
| 288 }); | |
| 289 | |
| 290 return Promise.resolve({ | |
| 291 mockSensorProvider: mockSensorProvider, | |
| 292 }); | |
| 293 }); | |
| 294 } | |
| 295 | |
| 296 function sensor_test(func, name, properties) { | |
| 297 mojo_test(mojo => sensor_mocks(mojo).then(sensor => { | |
| 298 let result = Promise.resolve(func(sensor)); | |
| 299 let cleanUp = () => { sensor.mockSensorProvider.reset(); }; | |
| 300 return result.then(cleanUp, cleanUp); | |
| 301 }), name, properties); | |
| 302 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2348333002:
Revert of [sensors] Ambient light sensor bindings implementation (Closed)
