Dart: Removes name conflicts from generated 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 %}
 
-abstract class {{interface|name}} implements core.Listener {
-  static const String name = '{{namespace|replace(".","::")}}::{{interface|name}}';
-  {{interface|name}}Stub stub;
+const String {{interface|name}}Name =
+      '{{namespace|replace(".","::")}}::{{interface|name}}';
 
-  {{interface|name}}(core.MojoMessagePipeEndpoint endpoint) :
-      stub = new {{interface|name}}Stub(endpoint);
-
-  {{interface|name}}.fromHandle(core.MojoHandle handle) :
-      stub = new {{interface|name}}Stub.fromHandle(handle);
-
-  {{interface|name}}.fromStub(this.stub);
-
-  {{interface|name}}.unbound() :
-      stub = new {{interface|name}}Stub.unbound();
-
-  void close({bool nodefer : false}) => stub.close(nodefer: nodefer);
-
-  StreamSubscription<int> listen() => stub.listen();
-
-  {{interface|name}} get delegate => stub.delegate;
-  set delegate({{interface|name}} d) {
-    stub.delegate = d;
-  }
-
+abstract class {{interface|name}} {
 {%- 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 -%}
     );
 {%- else %}
 {%- set response_struct = method|response_struct_from_method %}
   Future<{{response_struct|name}}> {{method|name}}(
   {%- for parameter in method.parameters -%}
     {{parameter.kind|dart_type}} {{parameter|name}},
   {%- endfor -%}
     [Function responseFactory = null]);
 {%- endif %}
 {%- endfor %}
 
-
 {#--- Interface Constants #}
 {% for constant in interface.constants %}
   static final {{constant|name}} = {{constant.value|expression_to_text}};
 {%-   endfor %}
 
-
 {#--- Interface Enums #}
 {%- from "enum_definition.tmpl" import enum_def -%}
 {%- for enum in interface.enums %}
   {{ enum_def("  static ", enum) }}
 {%-  endfor %}
 }
 
-class {{interface|name}}Proxy extends bindings.Proxy implements {{interface|name}} {
-  {{interface|name}}Proxy(core.MojoMessagePipeEndpoint endpoint) : super(endpoint);
 
-  {{interface|name}}Proxy.fromHandle(core.MojoHandle handle) :
+class {{interface|name}}ProxyImpl extends bindings.Proxy {
+  {{interface|name}}ProxyImpl.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) : super(endpoint);
+
+  {{interface|name}}ProxyImpl.fromHandle(core.MojoHandle handle) :
       super.fromHandle(handle);
 
-  {{interface|name}}Proxy.unbound() : super.unbound();
+  {{interface|name}}ProxyImpl.unbound() : super.unbound();
 
-  String get name => {{interface|name}}.name;
+  static {{interface|name}}ProxyImpl newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) =>
+      new {{interface|name}}ProxyImpl.fromEndpoint(endpoint);
 
-  static {{interface|name}}Proxy newFromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint) =>
-      new {{interface|name}}Proxy(endpoint);
+  String get name => {{interface|name}}Name;
 
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
 {%- for method in interface.methods %}
 {%- if method.response_parameters != None %}
 {%- set response_struct = method|response_struct_from_method %}
       case k{{interface|name}}_{{method|name}}_name:
         var r = {{response_struct|name}}.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           throw 'Expected a message with a valid request Id.';
         }
         Completer c = completerMap[message.header.requestId];
         completerMap[message.header.requestId] = null;
         c.complete(r);
         break;
 {%- endif %}
 {%- endfor %}
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
         break;
     }
   }
+}
 
-{%- 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 -%}
-  ) {
-    var params = new {{request_struct|name}}();
-{%- for parameter in method.parameters %}
-    params.{{parameter|name}} = {{parameter|name}};
-{%- endfor %}
-    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]) {
-    var params = new {{request_struct|name}}();
-{%- for parameter in method.parameters %}
-    params.{{parameter|name}} = {{parameter|name}};
-{%- endfor %}
-    return sendMessageWithRequestId(
-        params,
-        k{{interface|name}}_{{method|name}}_name,
-        -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
-  }
-{%- endif %}
-{%- endfor %}
+
+class {{interface|name}}Proxy implements {{interface|name}} {
+  {{interface|name}}ProxyImpl _proxyImpl;
+
+  {{interface|name}}Proxy(this._proxyImpl);
+
+  {{interface|name}}Proxy.fromEndpoint(core.MojoMessagePipeEndpoint endpoint) :
+      _proxyImpl = new {{interface|name}}ProxyImpl.fromEndpoint(endpoint);
+
+  {{interface|name}}Proxy.fromHandle(core.MojoHandle handle) :
+      _proxyImpl = new {{interface|name}}ProxyImpl.fromHandle(handle);
+
+  {{interface|name}}Proxy.unbound() :
+      _proxyImpl = new {{interface|name}}ProxyImpl.unbound();
+
+  {%- 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 -%}
+    ) {
+      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]) {
+      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 %}
 }
 
+
+void {{interface|name}}ProxyClose({{interface|name}}Proxy proxy) {
+  assert(proxy != null);
+  proxy._proxyImpl.close();
+}
+
+
+void {{interface|name}}ProxyBind({{interface|name}}Proxy proxy,
+                                 core.MojoMessagePipeEndpoint endpoint) {
+  assert(proxy != null);
+  proxy._proxyImpl.bind(endpoint);
+}
+
+
+bindings.Proxy {{interface|name}}Request({{interface|name}}Proxy proxy) {
+  assert(!proxy._proxyImpl.isBound);
+  return proxy._proxyImpl;
+}
+
+
+bool {{interface|name}}IsBound({{interface|name}}Proxy proxy) {
+  return proxy._proxyImpl.isBound;
+}
+
+
+bindings.Proxy {{interface|name}}GetProxyImpl({{interface|name}}Proxy proxy) {
+  return proxy._proxyImpl;
+}
+
+
 class {{interface|name}}Stub extends bindings.Stub {
   {{interface|name}} _delegate = null;
 
-  {{interface|name}}Stub(core.MojoMessagePipeEndpoint endpoint) : super(endpoint);
+  {{interface|name}}Stub.fromEndpoint(core.MojoMessagePipeEndpoint endpoint) :
+      super(endpoint);
 
   {{interface|name}}Stub.fromHandle(core.MojoHandle handle) :
       super.fromHandle(handle);
 
   {{interface|name}}Stub.unbound() : super.unbound();
 
   static {{interface|name}}Stub newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) =>
-      new {{interface|name}}Stub(endpoint);
+      new {{interface|name}}Stub.fromEndpoint(endpoint);
 
-  static const String name = {{interface|name}}.name;
+  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}}();
@@ skipping 43 matching lines @@
     }
     return null;
   }
 
   {{interface|name}} get delegate => _delegate;
       set delegate({{interface|name}} d) {
     assert(_delegate == null);
     _delegate = d;
   }
 }
-
-
-{#--- TODO(zra): Validation #}
-
-