Mojo JS bindings: code generator maps interface ptr and request to InterfacePtr and InterfaceReques…

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();
@@ skipping 226 matching lines @@
         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) {
+      getSensor(type, request) {
         if (this.get_sensor_should_fail_) {
-          return getSensorResponse(null,
-              connection.bindProxy(null, sensor.SensorClient));
+          var ignored = new sensor.SensorClientPtr();
+          return getSensorResponse(null, bindings.makeRequest(ignored));
         }
 
         let offset =
                 (sensor.SensorType.LAST - type) * this.reading_size_in_bytes_;
         let reporting_mode = sensor.ReportingMode.ON_CHANGE;
         if (this.is_continuous_) {
             reporting_mode = sensor.ReportingMode.CONTINUOUS;
         }
 
         if (this.active_sensor_ == null) {
+          var stub = connection.bindHandleToStub(request.handle, sensor.Sensor);
           let mockSensor = new MockSensor(stub, 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 default_config = {frequency: 5};
 
         let init_params =
             new sensor_provider.SensorInitParams(
                 { memory: rv.handle,
                   buffer_offset: offset,
                   mode: reporting_mode,
                   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);
+        var client_request = new bindings.InterfaceRequest(
+            connection.bindProxy(proxy => {
+              this.active_sensor_.client_ = proxy;
+            }, sensor.SensorClient));
+        return getSensorResponse(init_params, client_request);
       }
 
       // Binds object to mojo message pipe
       bindToPipe(pipe) {
         this.stub_ = connection.bindHandleToStub(
             pipe, sensor_provider.SensorProvider);
         bindings.StubBindings(this.stub_).delegate = this;
         bindings.StubBindings(this.stub_).connectionErrorHandler = () => {
           this.reset();
         };
@@ skipping 68 matching lines @@
     };
 
     let onFailure = () => {
       sensor.mockSensorProvider.reset();
       return new Promise((resolve, reject) => { setTimeout(reject, 0); });
     };
 
     return Promise.resolve(func(sensor)).then(onSuccess, onFailure);
   }), name, properties);
 }