Dart: Refactors Proxies

mojo/dart/apptests/test_apps/pingpong/lib/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 'package:mojo/application.dart';
 import 'package:mojo/bindings.dart';
 import 'package:mojo/core.dart';
 
@@ skipping 23 matching lines @@
   PingPongClientProxy _pingPongClient;
 
   PingPongServiceImpl(this._application, MojoMessagePipeEndpoint endpoint) {
     _stub = new PingPongServiceStub.fromEndpoint(endpoint, this);
   }
 
   PingPongServiceImpl.fromStub(this._stub) {
     _stub.impl = this;
   }
 
-  void setClient(ProxyBase proxyBase) {
+  void setClient(Proxy proxy) {
     assert(_pingPongClient == null);
-    _pingPongClient = proxyBase;
+    _pingPongClient = proxy;
   }
 
   void ping(int pingValue) {
     if (_pingPongClient != null) {
-      _pingPongClient.ptr.pong(pingValue + 1);
+      _pingPongClient.pong(pingValue + 1);
     }
   }
 
   Future pingTargetUrl(String url, int count,
       [Function responseFactory]) async {
     if (_application == null) {
       return responseFactory(false);
     }
     var completer = new Completer();
     var pingPongService = new PingPongServiceProxy.unbound();
     _application.connectToService(url, pingPongService);
 
     var pingPongClient = new PingPongClientImpl.unbound(count, completer);
-    pingPongService.ptr.setClient(pingPongClient.stub);
+    pingPongService.setClient(pingPongClient.stub);
 
     for (var i = 0; i < count; i++) {
-      pingPongService.ptr.ping(i);
+      pingPongService.ping(i);
     }
     await completer.future;
     await pingPongService.close();
 
     return responseFactory(true);
   }
 
-  Future pingTargetService(ProxyBase proxyBase, int count,
+  Future pingTargetService(Proxy proxy, int count,
       [Function responseFactory]) async {
-    var pingPongService = proxyBase;
+    var pingPongService = proxy;
     var completer = new Completer();
     var client = new PingPongClientImpl.unbound(count, completer);
-    pingPongService.ptr.setClient(client.stub);
+    pingPongService.setClient(client.stub);
 
     for (var i = 0; i < count; i++) {
-      pingPongService.ptr.ping(i);
+      pingPongService.ping(i);
     }
     await completer.future;
     await pingPongService.close();
 
     return responseFactory(true);
   }
 
   getPingPongService(PingPongServiceStub serviceStub) {
     var targetServiceProxy = new PingPongServiceProxy.unbound();
     _application.connectToService(
         "mojo:dart_pingpong_target", targetServiceProxy);
 
     // Pass along the interface request to another implementation of the
     // service.
-    targetServiceProxy.ptr.getPingPongService(serviceStub);
+    targetServiceProxy.getPingPongService(serviceStub);
     targetServiceProxy.close();
   }
 
   getPingPongServiceDelayed(PingPongServiceStub serviceStub) {
     Timer.run(() {
       var endpoint = serviceStub.unbind();
       new Timer(const Duration(milliseconds: 10), () {
         var targetServiceProxy = new PingPongServiceProxy.unbound();
         _application.connectToService(
             "mojo:dart_pingpong_target", targetServiceProxy);
 
         // Pass along the interface request to another implementation of the
         // service.
         serviceStub.bind(endpoint);
-        targetServiceProxy.ptr.getPingPongService(serviceStub);
+        targetServiceProxy.getPingPongService(serviceStub);
         targetServiceProxy.close();
       });
     });
   }
 
   void quit() {}
 }
 
 class PingPongApplication extends Application {
   PingPongApplication.fromHandle(MojoHandle handle) : super.fromHandle(handle);
 
   @override
   void acceptConnection(String requestorUrl, String resolvedUrl,
       ApplicationConnection connection) {
     connection.provideService(PingPongService.serviceName,
         (endpoint) => new PingPongServiceImpl(this, endpoint),
         description: PingPongServiceStub.serviceDescription);
   }
 }
 
 main(List args, Object handleToken) {
   MojoHandle appHandle = new MojoHandle(handleToken);
   new PingPongApplication.fromHandle(appHandle)
     ..onError = ((_) {
       MojoHandle.reportLeakedHandles();
     });
 }