Dart: Removes name conflicts from generated bindings.

services/dart/test/pingpong_target/main.dart

 // Copyright 2015 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.
 
 import 'dart:async';
 import 'mojo:application';
 import 'mojo:bindings';
 import 'mojo:core';
 
 import 'package:services/dart/test/pingpong_service.mojom.dart';
 
-class PingPongServiceImpl extends PingPongService {
+class PingPongServiceImpl implements PingPongService {
+  PingPongServiceStub _stub;
   Application _application;
-  PingPongClientProxy _proxy;
+  PingPongClientProxy _pingPongClient;
 
   PingPongServiceImpl(Application application, MojoMessagePipeEndpoint endpoint)
-      : _application = application, super(endpoint) {
-    super.delegate = this;
+      : _application = application {
+    _stub = new PingPongServiceStub.fromEndpoint(endpoint)

[sky, 2015/02/27 17:00:22]

In looking at implementing this in the modular side I'm thinking these names are
rather confusing. WDYT of making this code:

_binding = new PingPongServiceBinding.fromEndpoint(endpoint)
               ..ptr = this
               ..listen();

I prefer 'interface' over 'ptr', but 'ptr' is consistent with the name you went
with.

The reason I like Binding over Stub is it better conveys what the object is
doing (and it more closely mirrors the C++ side).

[sky, 2015/02/27 17:02:06]

One more suggestion:

new PingPongServiceBinding(endpoint, this);

? No need for a listen. That's done for me.

+            ..delegate = this
+            ..listen();
   }
 
-  void setClient(PingPongClientProxy proxy) {
-    assert(_proxy == null);
-    _proxy = proxy;
+  void setClient(ProxyBase proxyBase) {
+    assert(_pingPongClient == null);
+    _pingPongClient = proxyBase;
   }
 
-  void ping(int pingValue) => _proxy.pong(pingValue + 1);
+  void ping(int pingValue) => _pingPongClient.ptr.pong(pingValue + 1);
 
   void quit() {
-    if (_proxy != null) {
-      _proxy.close();
+    if (_pingPongClient != null) {
+      _pingPongClient.close();
+      _pingPongClient = null;
     }
-    super.close();
+    _stub.close();
     if (_application != null) {
       _application.close();
     }
   }
 }
 
 class PingPongApplication extends Application {
   PingPongApplication.fromHandle(MojoHandle handle) : super.fromHandle(handle);
 
   void acceptConnection(String requestorUrl, ApplicationConnection connection) {
-    connection.provideService(PingPongService.name,
+    connection.provideService(PingPongServiceName,
         (endpoint) => new PingPongServiceImpl(this, endpoint));
     connection.listen();
   }
 }
 
 main(List args) {
   MojoHandle appHandle = new MojoHandle(args[0]);
   String url = args[1];
-  var pingPongApplication = new PingPongApplication.fromHandle(appHandle);
-  pingPongApplication.listen();
+  new PingPongApplication.fromHandle(appHandle);
 }