Dart: Refactors Proxies

mojo/dart/unittests/embedder_tests/bindings_generation_test.dart

 // 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.
 
 import 'dart:async';
 import 'dart:isolate';
 import 'dart:typed_data';
 import 'dart:convert';
 
 import 'package:mojo/bindings.dart' as bindings;
@@ skipping 40 matching lines @@
 
 void providerIsolate(core.MojoMessagePipeEndpoint endpoint) {
   new ProviderImpl(endpoint);
 }
 
 Future<bool> testCallResponse() {
   var pipe = new core.MojoMessagePipe();
   var client = new sample.ProviderProxy.fromEndpoint(pipe.endpoints[0]);
   var c = new Completer();
   Isolate.spawn(providerIsolate, pipe.endpoints[1]).then((_) {
-    client.ptr.echoString("hello!").then((echoStringResponse) {
+    client.echoString("hello!").then((echoStringResponse) {
       Expect.equals("hello!", echoStringResponse.a);
     }).then((_) {
-      client.ptr.echoStrings("hello", "mojo!").then((echoStringsResponse) {
+      client.echoStrings("hello", "mojo!").then((echoStringsResponse) {
         Expect.equals("hello", echoStringsResponse.a);
         Expect.equals("mojo!", echoStringsResponse.b);
         client.close().then((_) {
           c.complete(true);
         });
       });
     });
   });
   return c.future;
 }
 
 Future testAwaitCallResponse() async {
   var pipe = new core.MojoMessagePipe();
   var client = new sample.ProviderProxy.fromEndpoint(pipe.endpoints[0]);
   var isolate = await Isolate.spawn(providerIsolate, pipe.endpoints[1]);
 
-  var echoStringResponse = await client.ptr.echoString("hello!");
+  var echoStringResponse = await client.echoString("hello!");
   Expect.equals("hello!", echoStringResponse.a);
 
-  var echoStringsResponse = await client.ptr.echoStrings("hello", "mojo!");
+  var echoStringsResponse = await client.echoStrings("hello", "mojo!");
   Expect.equals("hello", echoStringsResponse.a);
   Expect.equals("mojo!", echoStringsResponse.b);
 
   await client.close();
 }
 
 bindings.ServiceMessage messageOfStruct(bindings.Struct s) =>
     s.serializeWithHeader(new bindings.MessageHeader(0));
 
 testSerializeNamedRegion() {
@@ skipping 181 matching lines @@
 checkEnumCapsIsolate(core.MojoMessagePipeEndpoint endpoint) {
   new CheckEnumCapsImpl(endpoint);
 }
 
 testCheckEnumCapsImpl() {
   var pipe = new core.MojoMessagePipe();
   var client =
       new regression.CheckEnumCapsProxy.fromEndpoint(pipe.endpoints[0]);
   var c = new Completer();
   Isolate.spawn(checkEnumCapsIsolate, pipe.endpoints[1]).then((_) {
-    client.ptr.setEnumWithInternalAllCaps(
+    client.setEnumWithInternalAllCaps(
         regression.EnumWithInternalAllCaps.standard);
     client.close().then((_) {
       c.complete(null);
     });
   });
   return c.future;
 }
 
 testSerializeEnum() {
   var constants = new structs.ScopedConstants();
@@ skipping 16 matching lines @@
 
 void closingProviderIsolate(core.MojoMessagePipeEndpoint endpoint) {
   var provider = new ProviderImpl(endpoint);
   provider._stub.close();
 }
 
 Future<bool> runOnClosedTest() {
   var testCompleter = new Completer();
   var pipe = new core.MojoMessagePipe();
   var proxy = new sample.ProviderProxy.fromEndpoint(pipe.endpoints[0]);
-  proxy.impl.onError = (_) => testCompleter.complete(true);
+  proxy.ctrl.onError = (_) => testCompleter.complete(true);
   Isolate.spawn(closingProviderIsolate, pipe.endpoints[1]);
   return testCompleter.future.then((b) {
     Expect.isTrue(b);
   });
 }
 
 class Regression551Impl implements regression.Regression551 {
   regression.Regression551Stub _stub;
 
   Regression551Impl(core.MojoMessagePipeEndpoint endpoint) {
     _stub = new regression.Regression551Stub.fromEndpoint(endpoint, this);
   }
 
   dynamic get(List<String> keyPrefixes, Function responseFactory) =>
     responseFactory(0);
 }
 
 void regression551Isolate(core.MojoMessagePipeEndpoint endpoint) {
   new Regression551Impl(endpoint);
 }
 
 Future<bool> testRegression551() {
   var pipe = new core.MojoMessagePipe();
   var client = new regression.Regression551Proxy.fromEndpoint(pipe.endpoints[0]);
   var c = new Completer();
   Isolate.spawn(regression551Isolate, pipe.endpoints[1]).then((_) {
-    client.ptr.get(["hello!"]).then((response) {
+    client.get(["hello!"]).then((response) {
       Expect.equals(0, response.result);
       client.close().then((_) {
         c.complete(true);
       });
     });
   });
   return c.future;
 }
 
 class ServiceNameImpl implements regression.ServiceName {
   regression.ServiceNameStub _stub;
 
   ServiceNameImpl(core.MojoMessagePipeEndpoint endpoint) {
     _stub = new regression.ServiceNameStub.fromEndpoint(endpoint, this);
   }
 
   dynamic serviceName_(Function responseFactory) =>
       responseFactory(regression.ServiceName.serviceName);
 }
 
 void serviceNameIsolate(core.MojoMessagePipeEndpoint endpoint) {
   new ServiceNameImpl(endpoint);
 }
 
 Future<bool> testServiceName() {
   var pipe = new core.MojoMessagePipe();
   var client = new regression.ServiceNameProxy.fromEndpoint(pipe.endpoints[0]);
   var c = new Completer();
   Isolate.spawn(serviceNameIsolate, pipe.endpoints[1]).then((_) {
-    client.ptr.serviceName_().then((response) {
+    client.serviceName_().then((response) {
       Expect.equals(ServiceName.serviceName, response.serviceName_);
       client.close().then((_) {
         c.complete(true);
       });
     });
   });
   return c.future;
 }
 
 
@@ skipping 256 matching lines @@
 
   mojom_types.UserDefinedType udt = testValidationDescriptor[interfaceID];
   Expect.isNotNull(udt);
 
   mojom_types.MojomInterface mi = udt.interfaceType;
   Expect.isNotNull(mi);
 
   _checkMojomInterface(mi, shortName, fullIdentifier, methodMap);
 
   // The proxy and stub need to have a valid serviceDescription.
-  var boundsCheckProxyImpl =
-      new validation.BoundsCheckTestInterfaceProxy.unbound().impl;
+  var boundsCheckProxyController =
+      new validation.BoundsCheckTestInterfaceProxy.unbound().ctrl;
   var boundsCheckStubDescription =
       validation.BoundsCheckTestInterfaceStub.serviceDescription;
 
   _checkServiceDescription(
-      boundsCheckProxyImpl.serviceDescription, interfaceID, shortName,
+      boundsCheckProxyController.serviceDescription, interfaceID, shortName,
       fullIdentifier, methodMap);
   _checkServiceDescription(
       boundsCheckStubDescription, interfaceID, shortName, fullIdentifier,
       methodMap);
 }
 
 _checkServiceDescription(service_describer.ServiceDescription sd,
     String interfaceID, String shortName, String fullIdentifier,
     Map<int, String> methodMap) {
   // Check the top level interface, which must pass _checkMojomInterface.
@@ skipping 81 matching lines @@
   testValidateMojomTypes();
   testCamelCase();
   testSerializeErrorMessage();
   await testEnums();
   await testCallResponse();
   await testAwaitCallResponse();
   await runOnClosedTest();
   await testRegression551();
   await testServiceName();
 }