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

mojo/public/js/bindings.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 define("mojo/public/js/bindings", [
   "mojo/public/js/connection",
   "mojo/public/js/core",
-], function(connection, core) {
-
-  // ---------------------------------------------------------------------------
-
-  function InterfacePtrInfo(handle, version) {
-    this.handle = handle;
-    this.version = version;
-  }
-
-  InterfacePtrInfo.prototype.isValid = function() {
-    return core.isHandle(this.handle);
-  };
-
-  // ---------------------------------------------------------------------------
-
-  function InterfaceRequest(handle) {
-    this.handle = handle;
-  }
-
-  InterfaceRequest.prototype.isValid = function() {
-    return core.isHandle(this.handle);
-  };
+  "mojo/public/js/interface_types",
+], function(connection, core, types) {
 
   // ---------------------------------------------------------------------------
 
   function makeRequest(interfacePtr) {
     var pipe = core.createMessagePipe();
-    interfacePtr.ptr.bind(new InterfacePtrInfo(pipe.handle0, 0));
-    return new InterfaceRequest(pipe.handle1);
+    interfacePtr.ptr.bind(new types.InterfacePtrInfo(pipe.handle0, 0));
+    return new types.InterfaceRequest(pipe.handle1);
   }
 
   // ---------------------------------------------------------------------------
 
   // Operations used to setup/configure an interface pointer. Exposed as the
   // |ptr| field of generated interface pointer classes.
   function InterfacePtrController(interfaceType) {
     this.version = 0;
 
     this.interfaceType_ = interfaceType;
@@ skipping 33 matching lines @@
     if (!this.isBound())
       throw new Error("Cannot set connection error handler if not bound.");
 
     this.configureProxyIfNecessary_();
     this.connection_.router_.setErrorHandler(callback);
   };
 
   InterfacePtrController.prototype.passInterface = function() {
     var result;
     if (this.connection_) {
-      result = new InterfacePtrInfo(
+      result = new types.InterfacePtrInfo(
           this.connection_.router_.connector_.handle_, this.version);
       this.connection_.router_.connector_.handle_ = null;
     } else {
       // This also handles the case when this object is not bound.
-      result = new InterfacePtrInfo(this.handle_, this.version);
+      result = new types.InterfacePtrInfo(this.handle_, this.version);
       this.handle_ = null;
     }
 
     this.reset();
     return result;
   };
 
   InterfacePtrController.prototype.getProxy = function() {
     this.configureProxyIfNecessary_();
     return this.connection_.remote;
@@ skipping 35 matching lines @@
     this.stub_ = null;
 
     if (request)
       this.bind(request);
   }
 
   Binding.prototype.isBound = function() {
     return this.stub_ !== null;
   };
 
+  Binding.prototype.createInterfacePtrAndBind = function() {
+    var ptr = new this.interfaceType_.ptrClass();
+    // TODO(yzshen): Set the version of the interface pointer.
+    this.bind(makeRequest(ptr));
+    return ptr;
+  }
+
   Binding.prototype.bind = function(request) {
     this.close();
     if (request.isValid()) {
       this.stub_ = connection.bindHandleToStub(request.handle,
                                                this.interfaceType_);
       connection.StubBindings(this.stub_).delegate = this.impl_;
     }
   };
 
   Binding.prototype.close = function() {
     if (!this.isBound())
       return;
     connection.StubBindings(this.stub_).close();
     this.stub_ = null;
   };
 
   Binding.prototype.setConnectionErrorHandler
       = function(callback) {
     if (!this.isBound())
       throw new Error("Cannot set connection error handler if not bound.");
     connection.StubBindings(this.stub_).connection.router_.setErrorHandler(
         callback);
   };
 
   Binding.prototype.unbind = function() {
     if (!this.isBound())
-      return new InterfaceRequest(null);
+      return new types.InterfaceRequest(null);
 
-    var result = new InterfaceRequest(
+    var result = new types.InterfaceRequest(
         connection.StubBindings(this.stub_).connection.router_.connector_
             .handle_);
     connection.StubBindings(this.stub_).connection.router_.connector_.handle_ =
         null;
     this.close();
     return result;
   };
 
   var exports = {};
-  exports.InterfacePtrInfo = InterfacePtrInfo;
-  exports.InterfaceRequest = InterfaceRequest;
+  exports.InterfacePtrInfo = types.InterfacePtrInfo;
+  exports.InterfaceRequest = types.InterfaceRequest;
   exports.makeRequest = makeRequest;
   exports.InterfacePtrController = InterfacePtrController;
   exports.Binding = Binding;
 
   // TODO(yzshen): Remove the following exports.
   exports.EmptyProxy = connection.EmptyProxy;
   exports.EmptyStub = connection.EmptyStub;
   exports.ProxyBase = connection.ProxyBase;
   exports.ProxyBindings = connection.ProxyBindings;
   exports.StubBase = connection.StubBase;
   exports.StubBindings = connection.StubBindings;
 
   return exports;
 });