Dart: Refactor Stubs

mojo/dart/packages/_mojo_for_test_only/lib/mojo/test/validation_test_interfaces.mojom.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.
 
 library validation_test_interfaces_mojom;
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
 import 'dart:typed_data';
@@ skipping 3350 matching lines @@
       responseFactory(null);
 
   dynamic getAllTypeDefinitions([Function responseFactory]) =>
       responseFactory(null);
 }
 
 abstract class InterfaceA {
   static const String serviceName = null;
 }
 
-
-class _InterfaceAProxyControl extends bindings.ProxyMessageHandler
-                                      implements bindings.ProxyControl {
+class _InterfaceAProxyControl
+    extends bindings.ProxyMessageHandler
+    implements bindings.ProxyControl {
   _InterfaceAProxyControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _InterfaceAProxyControl.fromHandle(
       core.MojoHandle handle) : super.fromHandle(handle);
 
   _InterfaceAProxyControl.unbound() : super.unbound();
 
   service_describer.ServiceDescription get serviceDescription =>
       new _InterfaceAServiceDescription();
 
   String get serviceName => InterfaceA.serviceName;
 
-  @override
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       default:
         proxyError("Unexpected message type: ${message.header.type}");
         close(immediate: true);
         break;
     }
   }
 
   @override
   String toString() {
     var superString = super.toString();
     return "_InterfaceAProxyControl($superString)";
   }
 }
 
-
-class InterfaceAProxy extends bindings.Proxy
-                              implements InterfaceA {
+class InterfaceAProxy
+    extends bindings.Proxy
+    implements InterfaceA {
   InterfaceAProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint)
       : super(new _InterfaceAProxyControl.fromEndpoint(endpoint));
 
   InterfaceAProxy.fromHandle(core.MojoHandle handle)
       : super(new _InterfaceAProxyControl.fromHandle(handle));
 
   InterfaceAProxy.unbound()
       : super(new _InterfaceAProxyControl.unbound());
 
   static InterfaceAProxy newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For InterfaceAProxy"));
     return new InterfaceAProxy.fromEndpoint(endpoint);
   }
 
   factory InterfaceAProxy.connectToService(
       bindings.ServiceConnector s, String url, [String serviceName]) {
     InterfaceAProxy p = new InterfaceAProxy.unbound();
     s.connectToService(url, p, serviceName);
     return p;
   }
 
 
 }
 
-
-class InterfaceAStub extends bindings.Stub {
+class _InterfaceAStubControl
+    extends bindings.StubMessageHandler
+    implements bindings.StubControl<InterfaceA> {
   InterfaceA _impl;
 
-  InterfaceAStub.fromEndpoint(
+  _InterfaceAStubControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [InterfaceA impl])
       : super.fromEndpoint(endpoint, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  InterfaceAStub.fromHandle(
+  _InterfaceAStubControl.fromHandle(
       core.MojoHandle handle, [InterfaceA impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  InterfaceAStub.unbound([this._impl]) : super.unbound();
-
-  static InterfaceAStub newFromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For InterfaceAStub"));
-    return new InterfaceAStub.fromEndpoint(endpoint);
-  }
+  _InterfaceAStubControl.unbound([this._impl]) : super.unbound();
 
 
 
   dynamic handleMessage(bindings.ServiceMessage message) {
     if (bindings.ControlMessageHandler.isControlMessage(message)) {
       return bindings.ControlMessageHandler.handleMessage(this,
                                                           0,
                                                           message);
     }
     if (_impl == null) {
@@ skipping 19 matching lines @@
   }
 
   @override
   void bind(core.MojoMessagePipeEndpoint endpoint) {
     super.bind(endpoint);
     if (!isOpen && (_impl != null)) {
       beginHandlingEvents();
     }
   }
 
+  @override
   String toString() {
     var superString = super.toString();
-    return "InterfaceAStub($superString)";
+    return "_InterfaceAStubControl($superString)";
   }
 
   int get version => 0;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _InterfaceAServiceDescription();
     }
     return _cachedServiceDescription;
   }
 }
 
+class InterfaceAStub
+    extends bindings.Stub<InterfaceA>
+    implements InterfaceA {
+  InterfaceAStub.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint, [InterfaceA impl])
+      : super(new _InterfaceAStubControl.fromEndpoint(endpoint, impl));
+
+  InterfaceAStub.fromHandle(
+      core.MojoHandle handle, [InterfaceA impl])
+      : super(new _InterfaceAStubControl.fromHandle(handle, impl));
+
+  InterfaceAStub.unbound([InterfaceA impl])
+      : super(new _InterfaceAStubControl.unbound(impl));
+
+  static InterfaceAStub newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For InterfaceAStub"));
+    return new InterfaceAStub.fromEndpoint(endpoint);
+  }
+
+  static service_describer.ServiceDescription get serviceDescription =>
+      _InterfaceAStubControl.serviceDescription;
+
+
+}
+
 const int _boundsCheckTestInterfaceMethodMethod0Name = 0;
 const int _boundsCheckTestInterfaceMethodMethod1Name = 1;
 
 class _BoundsCheckTestInterfaceServiceDescription implements service_describer.ServiceDescription {
   dynamic getTopLevelInterface([Function responseFactory]){
     var interfaceTypeKey = getRuntimeTypeInfo().services["this.is.the.service.name.for.BoundsCheckTestInterface"];
     var userDefinedType = getAllMojomTypeDefinitions()[interfaceTypeKey];
     return responseFactory(userDefinedType.interfaceType);
   }
 
   dynamic getTypeDefinition(String typeKey, [Function responseFactory]) =>
     responseFactory(getAllMojomTypeDefinitions()[typeKey]);
 
   dynamic getAllTypeDefinitions([Function responseFactory]) =>
     responseFactory(getAllMojomTypeDefinitions());
 }
 
 abstract class BoundsCheckTestInterface {
   static const String serviceName = "this.is.the.service.name.for.BoundsCheckTestInterface";
   dynamic method0(int param0,[Function responseFactory = null]);
   void method1(int param0);
 }
 
-
-class _BoundsCheckTestInterfaceProxyControl extends bindings.ProxyMessageHandler
-                                      implements bindings.ProxyControl {
+class _BoundsCheckTestInterfaceProxyControl
+    extends bindings.ProxyMessageHandler
+    implements bindings.ProxyControl {
   _BoundsCheckTestInterfaceProxyControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _BoundsCheckTestInterfaceProxyControl.fromHandle(
       core.MojoHandle handle) : super.fromHandle(handle);
 
   _BoundsCheckTestInterfaceProxyControl.unbound() : super.unbound();
 
   service_describer.ServiceDescription get serviceDescription =>
       new _BoundsCheckTestInterfaceServiceDescription();
 
   String get serviceName => BoundsCheckTestInterface.serviceName;
 
-  @override
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       case _boundsCheckTestInterfaceMethodMethod0Name:
         var r = BoundsCheckTestInterfaceMethod0ResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
         }
         Completer c = completerMap[message.header.requestId];
@@ skipping 16 matching lines @@
     }
   }
 
   @override
   String toString() {
     var superString = super.toString();
     return "_BoundsCheckTestInterfaceProxyControl($superString)";
   }
 }
 
-
-class BoundsCheckTestInterfaceProxy extends bindings.Proxy
-                              implements BoundsCheckTestInterface {
+class BoundsCheckTestInterfaceProxy
+    extends bindings.Proxy
+    implements BoundsCheckTestInterface {
   BoundsCheckTestInterfaceProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint)
       : super(new _BoundsCheckTestInterfaceProxyControl.fromEndpoint(endpoint));
 
   BoundsCheckTestInterfaceProxy.fromHandle(core.MojoHandle handle)
       : super(new _BoundsCheckTestInterfaceProxyControl.fromHandle(handle));
 
   BoundsCheckTestInterfaceProxy.unbound()
       : super(new _BoundsCheckTestInterfaceProxyControl.unbound());
 
@@ skipping 25 matching lines @@
       ctrl.proxyError("The Proxy is closed.");
       return;
     }
     var params = new _BoundsCheckTestInterfaceMethod1Params();
     params.param0 = param0;
     ctrl.sendMessage(params,
         _boundsCheckTestInterfaceMethodMethod1Name);
   }
 }
 
-
-class BoundsCheckTestInterfaceStub extends bindings.Stub {
+class _BoundsCheckTestInterfaceStubControl
+    extends bindings.StubMessageHandler
+    implements bindings.StubControl<BoundsCheckTestInterface> {
   BoundsCheckTestInterface _impl;
 
-  BoundsCheckTestInterfaceStub.fromEndpoint(
+  _BoundsCheckTestInterfaceStubControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [BoundsCheckTestInterface impl])
       : super.fromEndpoint(endpoint, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  BoundsCheckTestInterfaceStub.fromHandle(
+  _BoundsCheckTestInterfaceStubControl.fromHandle(
       core.MojoHandle handle, [BoundsCheckTestInterface impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  BoundsCheckTestInterfaceStub.unbound([this._impl]) : super.unbound();
-
-  static BoundsCheckTestInterfaceStub newFromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For BoundsCheckTestInterfaceStub"));
-    return new BoundsCheckTestInterfaceStub.fromEndpoint(endpoint);
-  }
+  _BoundsCheckTestInterfaceStubControl.unbound([this._impl]) : super.unbound();
 
 
   BoundsCheckTestInterfaceMethod0ResponseParams _boundsCheckTestInterfaceMethod0ResponseParamsFactory(int param0) {
     var result = new BoundsCheckTestInterfaceMethod0ResponseParams();
     result.param0 = param0;
     return result;
   }
 
   dynamic handleMessage(bindings.ServiceMessage message) {
     if (bindings.ControlMessageHandler.isControlMessage(message)) {
@@ skipping 51 matching lines @@
   }
 
   @override
   void bind(core.MojoMessagePipeEndpoint endpoint) {
     super.bind(endpoint);
     if (!isOpen && (_impl != null)) {
       beginHandlingEvents();
     }
   }
 
+  @override
   String toString() {
     var superString = super.toString();
-    return "BoundsCheckTestInterfaceStub($superString)";
+    return "_BoundsCheckTestInterfaceStubControl($superString)";
   }
 
   int get version => 0;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _BoundsCheckTestInterfaceServiceDescription();
     }
     return _cachedServiceDescription;
   }
 }
 
+class BoundsCheckTestInterfaceStub
+    extends bindings.Stub<BoundsCheckTestInterface>
+    implements BoundsCheckTestInterface {
+  BoundsCheckTestInterfaceStub.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint, [BoundsCheckTestInterface impl])
+      : super(new _BoundsCheckTestInterfaceStubControl.fromEndpoint(endpoint, impl));
+
+  BoundsCheckTestInterfaceStub.fromHandle(
+      core.MojoHandle handle, [BoundsCheckTestInterface impl])
+      : super(new _BoundsCheckTestInterfaceStubControl.fromHandle(handle, impl));
+
+  BoundsCheckTestInterfaceStub.unbound([BoundsCheckTestInterface impl])
+      : super(new _BoundsCheckTestInterfaceStubControl.unbound(impl));
+
+  static BoundsCheckTestInterfaceStub newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For BoundsCheckTestInterfaceStub"));
+    return new BoundsCheckTestInterfaceStub.fromEndpoint(endpoint);
+  }
+
+  static service_describer.ServiceDescription get serviceDescription =>
+      _BoundsCheckTestInterfaceStubControl.serviceDescription;
+
+
+  dynamic method0(int param0,[Function responseFactory = null]) {
+    return impl.method0(param0,responseFactory);
+  }
+  void method1(int param0) {
+    return impl.method1(param0);
+  }
+}
+
 const int _conformanceTestInterfaceMethodMethod0Name = 0;
 const int _conformanceTestInterfaceMethodMethod1Name = 1;
 const int _conformanceTestInterfaceMethodMethod2Name = 2;
 const int _conformanceTestInterfaceMethodMethod3Name = 3;
 const int _conformanceTestInterfaceMethodMethod4Name = 4;
 const int _conformanceTestInterfaceMethodMethod5Name = 5;
 const int _conformanceTestInterfaceMethodMethod6Name = 6;
 const int _conformanceTestInterfaceMethodMethod7Name = 7;
 const int _conformanceTestInterfaceMethodMethod8Name = 8;
 const int _conformanceTestInterfaceMethodMethod9Name = 9;
@@ skipping 28 matching lines @@
   void method8(List<List<String>> param0);
   void method9(List<List<core.MojoHandle>> param0);
   void method10(Map<String, int> param0);
   void method11(StructG param0);
   dynamic method12(double param0,[Function responseFactory = null]);
   void method13(Object param0, int param1, Object param2);
   void method14(UnionA param0);
   void method15(StructH param0);
 }
 
-
-class _ConformanceTestInterfaceProxyControl extends bindings.ProxyMessageHandler
-                                      implements bindings.ProxyControl {
+class _ConformanceTestInterfaceProxyControl
+    extends bindings.ProxyMessageHandler
+    implements bindings.ProxyControl {
   _ConformanceTestInterfaceProxyControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _ConformanceTestInterfaceProxyControl.fromHandle(
       core.MojoHandle handle) : super.fromHandle(handle);
 
   _ConformanceTestInterfaceProxyControl.unbound() : super.unbound();
 
   service_describer.ServiceDescription get serviceDescription =>
       new _ConformanceTestInterfaceServiceDescription();
 
   String get serviceName => ConformanceTestInterface.serviceName;
 
-  @override
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       case _conformanceTestInterfaceMethodMethod12Name:
         var r = ConformanceTestInterfaceMethod12ResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
         }
         Completer c = completerMap[message.header.requestId];
@@ skipping 16 matching lines @@
     }
   }
 
   @override
   String toString() {
     var superString = super.toString();
     return "_ConformanceTestInterfaceProxyControl($superString)";
   }
 }
 
-
-class ConformanceTestInterfaceProxy extends bindings.Proxy
-                              implements ConformanceTestInterface {
+class ConformanceTestInterfaceProxy
+    extends bindings.Proxy
+    implements ConformanceTestInterface {
   ConformanceTestInterfaceProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint)
       : super(new _ConformanceTestInterfaceProxyControl.fromEndpoint(endpoint));
 
   ConformanceTestInterfaceProxy.fromHandle(core.MojoHandle handle)
       : super(new _ConformanceTestInterfaceProxyControl.fromHandle(handle));
 
   ConformanceTestInterfaceProxy.unbound()
       : super(new _ConformanceTestInterfaceProxyControl.unbound());
 
@@ skipping 171 matching lines @@
       ctrl.proxyError("The Proxy is closed.");
       return;
     }
     var params = new _ConformanceTestInterfaceMethod15Params();
     params.param0 = param0;
     ctrl.sendMessage(params,
         _conformanceTestInterfaceMethodMethod15Name);
   }
 }
 
-
-class ConformanceTestInterfaceStub extends bindings.Stub {
+class _ConformanceTestInterfaceStubControl
+    extends bindings.StubMessageHandler
+    implements bindings.StubControl<ConformanceTestInterface> {
   ConformanceTestInterface _impl;
 
-  ConformanceTestInterfaceStub.fromEndpoint(
+  _ConformanceTestInterfaceStubControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [ConformanceTestInterface impl])
       : super.fromEndpoint(endpoint, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  ConformanceTestInterfaceStub.fromHandle(
+  _ConformanceTestInterfaceStubControl.fromHandle(
       core.MojoHandle handle, [ConformanceTestInterface impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  ConformanceTestInterfaceStub.unbound([this._impl]) : super.unbound();
-
-  static ConformanceTestInterfaceStub newFromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For ConformanceTestInterfaceStub"));
-    return new ConformanceTestInterfaceStub.fromEndpoint(endpoint);
-  }
+  _ConformanceTestInterfaceStubControl.unbound([this._impl]) : super.unbound();
 
 
   ConformanceTestInterfaceMethod12ResponseParams _conformanceTestInterfaceMethod12ResponseParamsFactory(double param0) {
     var result = new ConformanceTestInterfaceMethod12ResponseParams();
     result.param0 = param0;
     return result;
   }
 
   dynamic handleMessage(bindings.ServiceMessage message) {
     if (bindings.ControlMessageHandler.isControlMessage(message)) {
@@ skipping 121 matching lines @@
   }
 
   @override
   void bind(core.MojoMessagePipeEndpoint endpoint) {
     super.bind(endpoint);
     if (!isOpen && (_impl != null)) {
       beginHandlingEvents();
     }
   }
 
+  @override
   String toString() {
     var superString = super.toString();
-    return "ConformanceTestInterfaceStub($superString)";
+    return "_ConformanceTestInterfaceStubControl($superString)";
   }
 
   int get version => 0;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _ConformanceTestInterfaceServiceDescription();
     }
     return _cachedServiceDescription;
   }
 }
 
+class ConformanceTestInterfaceStub
+    extends bindings.Stub<ConformanceTestInterface>
+    implements ConformanceTestInterface {
+  ConformanceTestInterfaceStub.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint, [ConformanceTestInterface impl])
+      : super(new _ConformanceTestInterfaceStubControl.fromEndpoint(endpoint, impl));
+
+  ConformanceTestInterfaceStub.fromHandle(
+      core.MojoHandle handle, [ConformanceTestInterface impl])
+      : super(new _ConformanceTestInterfaceStubControl.fromHandle(handle, impl));
+
+  ConformanceTestInterfaceStub.unbound([ConformanceTestInterface impl])
+      : super(new _ConformanceTestInterfaceStubControl.unbound(impl));
+
+  static ConformanceTestInterfaceStub newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For ConformanceTestInterfaceStub"));
+    return new ConformanceTestInterfaceStub.fromEndpoint(endpoint);
+  }
+
+  static service_describer.ServiceDescription get serviceDescription =>
+      _ConformanceTestInterfaceStubControl.serviceDescription;
+
+
+  void method0(double param0) {
+    return impl.method0(param0);
+  }
+  void method1(StructA param0) {
+    return impl.method1(param0);
+  }
+  void method2(StructB param0, StructA param1) {
+    return impl.method2(param0, param1);
+  }
+  void method3(List<bool> param0) {
+    return impl.method3(param0);
+  }
+  void method4(StructC param0, List<int> param1) {
+    return impl.method4(param0, param1);
+  }
+  void method5(StructE param0, core.MojoDataPipeProducer param1) {
+    return impl.method5(param0, param1);
+  }
+  void method6(List<List<int>> param0) {
+    return impl.method6(param0);
+  }
+  void method7(StructF param0, List<List<int>> param1) {
+    return impl.method7(param0, param1);
+  }
+  void method8(List<List<String>> param0) {
+    return impl.method8(param0);
+  }
+  void method9(List<List<core.MojoHandle>> param0) {
+    return impl.method9(param0);
+  }
+  void method10(Map<String, int> param0) {
+    return impl.method10(param0);
+  }
+  void method11(StructG param0) {
+    return impl.method11(param0);
+  }
+  dynamic method12(double param0,[Function responseFactory = null]) {
+    return impl.method12(param0,responseFactory);
+  }
+  void method13(Object param0, int param1, Object param2) {
+    return impl.method13(param0, param1, param2);
+  }
+  void method14(UnionA param0) {
+    return impl.method14(param0);
+  }
+  void method15(StructH param0) {
+    return impl.method15(param0);
+  }
+}
+
 const int _integrationTestInterfaceMethodMethod0Name = 0;
 
 class _IntegrationTestInterfaceServiceDescription implements service_describer.ServiceDescription {
   dynamic getTopLevelInterface([Function responseFactory]) =>
       responseFactory(null);
 
   dynamic getTypeDefinition(String typeKey, [Function responseFactory]) =>
       responseFactory(null);
 
   dynamic getAllTypeDefinitions([Function responseFactory]) =>
       responseFactory(null);
 }
 
 abstract class IntegrationTestInterface {
   static const String serviceName = null;
   dynamic method0(BasicStruct param0,[Function responseFactory = null]);
 }
 
-
-class _IntegrationTestInterfaceProxyControl extends bindings.ProxyMessageHandler
-                                      implements bindings.ProxyControl {
+class _IntegrationTestInterfaceProxyControl
+    extends bindings.ProxyMessageHandler
+    implements bindings.ProxyControl {
   _IntegrationTestInterfaceProxyControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _IntegrationTestInterfaceProxyControl.fromHandle(
       core.MojoHandle handle) : super.fromHandle(handle);
 
   _IntegrationTestInterfaceProxyControl.unbound() : super.unbound();
 
   service_describer.ServiceDescription get serviceDescription =>
       new _IntegrationTestInterfaceServiceDescription();
 
   String get serviceName => IntegrationTestInterface.serviceName;
 
-  @override
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       case _integrationTestInterfaceMethodMethod0Name:
         var r = IntegrationTestInterfaceMethod0ResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
         }
         Completer c = completerMap[message.header.requestId];
@@ skipping 16 matching lines @@
     }
   }
 
   @override
   String toString() {
     var superString = super.toString();
     return "_IntegrationTestInterfaceProxyControl($superString)";
   }
 }
 
-
-class IntegrationTestInterfaceProxy extends bindings.Proxy
-                              implements IntegrationTestInterface {
+class IntegrationTestInterfaceProxy
+    extends bindings.Proxy
+    implements IntegrationTestInterface {
   IntegrationTestInterfaceProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint)
       : super(new _IntegrationTestInterfaceProxyControl.fromEndpoint(endpoint));
 
   IntegrationTestInterfaceProxy.fromHandle(core.MojoHandle handle)
       : super(new _IntegrationTestInterfaceProxyControl.fromHandle(handle));
 
   IntegrationTestInterfaceProxy.unbound()
       : super(new _IntegrationTestInterfaceProxyControl.unbound());
 
@@ skipping 15 matching lines @@
     var params = new _IntegrationTestInterfaceMethod0Params();
     params.param0 = param0;
     return ctrl.sendMessageWithRequestId(
         params,
         _integrationTestInterfaceMethodMethod0Name,
         -1,
         bindings.MessageHeader.kMessageExpectsResponse);
   }
 }
 
-
-class IntegrationTestInterfaceStub extends bindings.Stub {
+class _IntegrationTestInterfaceStubControl
+    extends bindings.StubMessageHandler
+    implements bindings.StubControl<IntegrationTestInterface> {
   IntegrationTestInterface _impl;
 
-  IntegrationTestInterfaceStub.fromEndpoint(
+  _IntegrationTestInterfaceStubControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [IntegrationTestInterface impl])
       : super.fromEndpoint(endpoint, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  IntegrationTestInterfaceStub.fromHandle(
+  _IntegrationTestInterfaceStubControl.fromHandle(
       core.MojoHandle handle, [IntegrationTestInterface impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  IntegrationTestInterfaceStub.unbound([this._impl]) : super.unbound();
-
-  static IntegrationTestInterfaceStub newFromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For IntegrationTestInterfaceStub"));
-    return new IntegrationTestInterfaceStub.fromEndpoint(endpoint);
-  }
+  _IntegrationTestInterfaceStubControl.unbound([this._impl]) : super.unbound();
 
 
   IntegrationTestInterfaceMethod0ResponseParams _integrationTestInterfaceMethod0ResponseParamsFactory(List<int> param0) {
     var result = new IntegrationTestInterfaceMethod0ResponseParams();
     result.param0 = param0;
     return result;
   }
 
   dynamic handleMessage(bindings.ServiceMessage message) {
     if (bindings.ControlMessageHandler.isControlMessage(message)) {
@@ skipping 46 matching lines @@
   }
 
   @override
   void bind(core.MojoMessagePipeEndpoint endpoint) {
     super.bind(endpoint);
     if (!isOpen && (_impl != null)) {
       beginHandlingEvents();
     }
   }
 
+  @override
   String toString() {
     var superString = super.toString();
-    return "IntegrationTestInterfaceStub($superString)";
+    return "_IntegrationTestInterfaceStubControl($superString)";
   }
 
   int get version => 0;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _IntegrationTestInterfaceServiceDescription();
     }
     return _cachedServiceDescription;
   }
 }
 
+class IntegrationTestInterfaceStub
+    extends bindings.Stub<IntegrationTestInterface>
+    implements IntegrationTestInterface {
+  IntegrationTestInterfaceStub.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint, [IntegrationTestInterface impl])
+      : super(new _IntegrationTestInterfaceStubControl.fromEndpoint(endpoint, impl));
+
+  IntegrationTestInterfaceStub.fromHandle(
+      core.MojoHandle handle, [IntegrationTestInterface impl])
+      : super(new _IntegrationTestInterfaceStubControl.fromHandle(handle, impl));
+
+  IntegrationTestInterfaceStub.unbound([IntegrationTestInterface impl])
+      : super(new _IntegrationTestInterfaceStubControl.unbound(impl));
+
+  static IntegrationTestInterfaceStub newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For IntegrationTestInterfaceStub"));
+    return new IntegrationTestInterfaceStub.fromEndpoint(endpoint);
+  }
+
+  static service_describer.ServiceDescription get serviceDescription =>
+      _IntegrationTestInterfaceStubControl.serviceDescription;
+
+
+  dynamic method0(BasicStruct param0,[Function responseFactory = null]) {
+    return impl.method0(param0,responseFactory);
+  }
+}
+
 
 mojom_types.RuntimeTypeInfo getRuntimeTypeInfo() => _runtimeTypeInfo ??
     _initRuntimeTypeInfo();
 
 Map<String, mojom_types.UserDefinedType> getAllMojomTypeDefinitions() {
   return getRuntimeTypeInfo().typeMap;
 }
 
 var _runtimeTypeInfo;
 mojom_types.RuntimeTypeInfo  _initRuntimeTypeInfo() {
   // serializedRuntimeTypeInfo contains the bytes of the Mojo serialization of
   // a mojom_types.RuntimeTypeInfo struct describing the Mojom types in this
   // file. The string contains the base64 encoding of the gzip-compressed bytes.
   var serializedRuntimeTypeInfo = "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";
 
   // Deserialize RuntimeTypeInfo
   var bytes = BASE64.decode(serializedRuntimeTypeInfo);
   var unzippedBytes = new ZLibDecoder().convert(bytes);
   var bdata = new ByteData.view(unzippedBytes.buffer);
   var message = new bindings.Message(bdata, null, unzippedBytes.length, 0);
   _runtimeTypeInfo = mojom_types.RuntimeTypeInfo.deserialize(message);
   return _runtimeTypeInfo;
 }