Port device_generic_sensor to be hosted in Device Service.

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);
       }
     }
   }
 
   get callback() {
     return this.wrapper_func_;
   }
 }
 
 function sensor_mocks(mojo) {
   return define('Generic Sensor API mocks', [
     'mojo/public/js/core',
     'mojo/public/js/bindings',
     'device/generic_sensor/public/interfaces/sensor_provider.mojom',
     'device/generic_sensor/public/interfaces/sensor.mojom',
-  ], (core, bindings, sensor_provider, sensor) => {
+    'services/device/public/interfaces/constants.mojom',
+  ], (core, bindings, sensor_provider, sensor, deviceConstants) => {
 
     // 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;
@@ skipping 316 matching lines @@
           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(
+    mojo.connector.addInterfaceOverrideForTesting(
+        deviceConstants.kServiceName,
         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 => {
     // Clean up and reset mock sensor stubs asynchronously, so that the blink
     // side closes its proxies and notifies JS sensor objects before new test is
     // started.
     let onSuccess = () => {
       sensor.mockSensorProvider.reset();
       return new Promise((resolve, reject) => { setTimeout(resolve, 0); });
     };
 
     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);
 }