[WIP] Mojo native bindings interface.

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) => {
+  ], (bindings, sensor_provider, sensor) => {
 
     // 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_ = [];
-        let rv = core.mapBuffer(handle, offset, size,
-            core.MAP_BUFFER_FLAG_NONE);
-        assert_equals(rv.result, core.RESULT_OK, "Failed to map shared buffer");
+        let rv = handle.mapBuffer(offset, size);
+        assert_equals(rv.result, Mojo.RESULT_OK, "Failed to map shared buffer");
         this.buffer_array_ = rv.buffer;
         this.buffer_ = new Float64Array(this.buffer_array_);
         this.resetBuffer();
         this.binding_ = new bindings.Binding(sensor.Sensor, this,
                                              sensorRequest);
         this.binding_.setConnectionErrorHandler(() => {
           this.reset();
         });
       }
 
@@ skipping 71 matching lines @@
         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_);
         this.buffer_array_ = null;
         this.binding_.close();
       }
 
       // Zeroes shared buffer.
       resetBuffer() {
         for (let i = 0; i < this.buffer_.length; ++i) {
           this.buffer_[i] = 0;
         }
       }
@@ skipping 78 matching lines @@
     }
 
     // Class that mocks SensorProvider interface defined in
     // sensor_provider.mojom
     class MockSensorProvider {
       constructor() {
         this.reading_size_in_bytes_ =
             sensor_provider.SensorInitParams.kReadBufferSizeForTests;
         this.shared_buffer_size_in_bytes_ = this.reading_size_in_bytes_ *
                 sensor.SensorType.LAST;
-        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");
+        let rv = Mojo.createSharedBuffer(this.shared_buffer_size_in_bytes_);
+        assert_equals(rv.result, Mojo.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);
       }
@@ skipping 11 matching lines @@
         if (this.is_continuous_) {
             reporting_mode = sensor.ReportingMode.CONTINUOUS;
         }
 
         if (this.active_sensor_ == null) {
           let mockSensor = new MockSensor(request, this.shared_buffer_handle_,
               offset, this.reading_size_in_bytes_, reporting_mode);
           this.active_sensor_ = mockSensor;
         }
 
-        let rv =
-                core.duplicateBufferHandle(
-                        this.shared_buffer_handle_,
-                        core.DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE);
-
-        assert_equals(rv.result, core.RESULT_OK);
+        let rv = this.shared_buffer_handle_.duplicateBufferHandle();
+        assert_equals(rv.result, Mojo.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_,
@@ skipping 90 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);
 }