Dart: Adds optional named arguments for creating bindings.

mojo/public/tools/bindings/generators/dart_templates/interface_definition.tmpl

 {%- for method in interface.methods %}
 const int k{{interface|name}}_{{method|name}}_name = {{method.ordinal}};
 {%- endfor %}
 
 const String {{interface|name}}Name =
       '{{namespace|replace(".","::")}}::{{interface|name}}';
 
 abstract class {{interface|name}} {
 {%- for method in interface.methods %}
 {%- if method.response_parameters == None %}
@@ skipping 20 matching lines @@
 {#--- Interface Enums #}
 {%- from "enum_definition.tmpl" import enum_def -%}
 {%- for enum in interface.enums %}
   {{ enum_def("  static ", enum) }}
 {%-  endfor %}
 }
 
 
 class {{interface|name}}ProxyImpl extends bindings.Proxy {
   {{interface|name}}ProxyImpl.fromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint) : super(endpoint);
+      core.MojoMessagePipeEndpoint endpoint,
+      {bool doListen: true, Function onClosed}) :
+      super.fromEndpoint(endpoint, doListen: doListen, onClosed: onClosed);
 
-  {{interface|name}}ProxyImpl.fromHandle(core.MojoHandle handle) :
-      super.fromHandle(handle);
+  {{interface|name}}ProxyImpl.fromHandle(core.MojoHandle handle,
+      {bool doListen: true, Function onClosed}) :
+      super.fromHandle(handle, doListen: doListen, onClosed: onClosed);
 
   {{interface|name}}ProxyImpl.unbound() : super.unbound();
 
   static {{interface|name}}ProxyImpl newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) =>
       new {{interface|name}}ProxyImpl.fromEndpoint(endpoint);
 
   String get name => {{interface|name}}Name;
 
   void handleResponse(bindings.ServiceMessage message) {
@@ skipping 27 matching lines @@
   _{{interface|name}}ProxyCalls(this._proxyImpl);
 
   {%- for method in interface.methods %}
   {%- if method.response_parameters == None %}
     void {{method|name}}(
   {%- for parameter in method.parameters -%}
       {{parameter.kind|dart_type}} {{parameter|name}}{% if not loop.last %}, {% endif %}
   {%- endfor -%}
   {%- set request_struct = method|struct_from_method -%}
     ) {
+      assert(_proxyImpl.isBound);
       var params = new {{request_struct|name}}();
   {%- for parameter in method.parameters %}
       params.{{parameter|name}} = {{parameter|name}};
   {%- endfor %}
       _proxyImpl.sendMessage(params, k{{interface|name}}_{{method|name}}_name);
     }
   {% else %}
   {%- set response_struct = method|response_struct_from_method %}
   {%- set request_struct = method|struct_from_method %}
     Future<{{response_struct|name}}> {{method|name}}(
   {%- for parameter in method.parameters -%}
       {{parameter.kind|dart_type}} {{parameter|name}},
   {%- endfor -%}
       [Function responseFactory = null]) {
+      assert(_proxyImpl.isBound);
       var params = new {{request_struct|name}}();
   {%- for parameter in method.parameters %}
       params.{{parameter|name}} = {{parameter|name}};
   {%- endfor %}
       return _proxyImpl.sendMessageWithRequestId(
           params,
           k{{interface|name}}_{{method|name}}_name,
           -1,
           bindings.MessageHeader.kMessageExpectsResponse);
     }
   {%- endif %}
   {%- endfor %}
 }
 
 
 class {{interface|name}}Proxy implements bindings.ProxyBase {
   final bindings.Proxy impl;
   {{interface|name}} ptr;
   final String name = {{interface|name}}Name;
 
   {{interface|name}}Proxy({{interface|name}}ProxyImpl proxyImpl) :
       impl = proxyImpl,
       ptr = new _{{interface|name}}ProxyCalls(proxyImpl);
 
   {{interface|name}}Proxy.fromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint) :
-      impl = new {{interface|name}}ProxyImpl.fromEndpoint(endpoint) {
+      core.MojoMessagePipeEndpoint endpoint,
+      {bool doListen: true, Function onClosed}) :
+      impl = new {{interface|name}}ProxyImpl.fromEndpoint(
+          endpoint, doListen: doListen, onClosed: onClosed) {
     ptr = new _{{interface|name}}ProxyCalls(impl);
   }
 
-  {{interface|name}}Proxy.fromHandle(core.MojoHandle handle) :
-      impl = new {{interface|name}}ProxyImpl.fromHandle(handle) {
+  {{interface|name}}Proxy.fromHandle(core.MojoHandle handle,
+      {bool doListen: true, Function onClosed}) :
+      impl = new {{interface|name}}ProxyImpl.fromHandle(
+          handle, doListen: doListen, onClosed: onClosed) {
     ptr = new _{{interface|name}}ProxyCalls(impl);
   }
 
   {{interface|name}}Proxy.unbound() :
       impl = new {{interface|name}}ProxyImpl.unbound() {
     ptr = new _{{interface|name}}ProxyCalls(impl);
   }
 
   static {{interface|name}}Proxy newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) =>
       new {{interface|name}}Proxy.fromEndpoint(endpoint);
 
   void close() => impl.close();
 }
 
 
 class {{interface|name}}Stub extends bindings.Stub {
-  {{interface|name}} _delegate = null;
+  {{interface|name}} _impl = null;
 
-  {{interface|name}}Stub.fromEndpoint(core.MojoMessagePipeEndpoint endpoint) :
-      super(endpoint);
+  {{interface|name}}Stub.fromEndpoint(core.MojoMessagePipeEndpoint endpoint,
+      { {{interface|name}} impl, bool doListen: true, Function onClosed}) :
+      super.fromEndpoint(endpoint, doListen: false) {
+    assert(!doListen || (impl != null));
+    if (impl != null) {
+      this._impl = impl;
+    }
+    if (doListen) {
+      listen(onClosed: onClosed);
+    }
+  }
 
-  {{interface|name}}Stub.fromHandle(core.MojoHandle handle) :
-      super.fromHandle(handle);
+  {{interface|name}}Stub.fromHandle(core.MojoHandle handle,
+      { {{interface|name}} impl, bool doListen: true, Function onClosed}) :
+      super.fromHandle(handle, doListen: false) {
+    assert(!doListen || (impl != null));
+    if (impl != null) {
+      this._impl = impl;
+    }
+    if (doListen) {
+      listen(onClosed: onClosed);
+    }
+  }
 
   {{interface|name}}Stub.unbound() : super.unbound();
 
   static {{interface|name}}Stub newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) =>
-      new {{interface|name}}Stub.fromEndpoint(endpoint);
+      new {{interface|name}}Stub.fromEndpoint(endpoint, doListen: false);
 
   static const String name = {{interface|name}}Name;
 
 {% for method in interface.methods %}
 {%- if method.response_parameters != None %}
 {%- set response_struct = method|response_struct_from_method %}
   {{response_struct|name}} _{{response_struct|name}}Factory(
     {%- for param in method.response_parameters -%}
       {{param.kind|dart_type}} {{param|name}}{% if not loop.last %}, {% endif %}
     {%- endfor -%}
   ) {
     var result = new {{response_struct|name}}();
     {%- for param in method.response_parameters %}
     result.{{param|name}} = {{param|name}};
     {%- endfor %}
     return result;
   }
 {%- endif %}
 {%- endfor %}
 
   Future<bindings.Message> handleMessage(bindings.ServiceMessage message) {
-    assert(_delegate != null);
+    assert(_impl != null);
     switch (message.header.type) {
 {%- for method in interface.methods %}
 {%- set request_struct = method|struct_from_method %}
       case k{{interface|name}}_{{method|name}}_name:
         var params = {{request_struct|name}}.deserialize(
             message.payload);
 {%- if method.response_parameters == None %}
-        _delegate.{{method|name}}(
+        _impl.{{method|name}}(
           {%- for parameter in method.parameters -%}
               params.{{parameter|name}}{% if not loop.last %}, {% endif %}
           {%- endfor -%}
         );
 {%- else %}
 {%- set response_struct = method|response_struct_from_method %}
-        return _delegate.{{method|name}}(
+        return _impl.{{method|name}}(
           {%- for parameter in method.parameters -%}
               params.{{parameter|name}},
           {%- endfor -%}
           _{{response_struct|name}}Factory).then((response) {
           if (response != null) {
             return buildResponseWithId(
                 response,
                 k{{interface|name}}_{{method|name}}_name,
                 message.header.requestId,
                 bindings.MessageHeader.kMessageIsResponse);
           }
         });
 {%- endif %}
         break;
 {%- endfor %}
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
         break;
     }
     return null;
   }
 
-  {{interface|name}} get delegate => _delegate;
-      set delegate({{interface|name}} d) {
-    assert(_delegate == null);
-    _delegate = d;
+  {{interface|name}} get impl => _impl;
+      set impl({{interface|name}} d) {
+    assert(_impl == null);
+    _impl = d;
   }
 }