Dart: Refactor Stubs

mojo/dart/packages/mojo_services/lib/mojo/camera.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 camera_mojom;
 import 'dart:async';
 import 'package:mojo/bindings.dart' as bindings;
 import 'package:mojo/core.dart' as core;
 import 'package:mojo/mojo/bindings/types/service_describer.mojom.dart' as service_describer;
 
@@ skipping 558 matching lines @@
       responseFactory(null);
 }
 
 abstract class CameraRollService {
   static const String serviceName = "mojo::CameraRollService";
   void update();
   dynamic getCount([Function responseFactory = null]);
   dynamic getPhoto(int index,[Function responseFactory = null]);
 }
 
-
-class _CameraRollServiceProxyControl extends bindings.ProxyMessageHandler
-                                      implements bindings.ProxyControl {
+class _CameraRollServiceProxyControl
+    extends bindings.ProxyMessageHandler
+    implements bindings.ProxyControl {
   _CameraRollServiceProxyControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _CameraRollServiceProxyControl.fromHandle(
       core.MojoHandle handle) : super.fromHandle(handle);
 
   _CameraRollServiceProxyControl.unbound() : super.unbound();
 
   service_describer.ServiceDescription get serviceDescription =>
       new _CameraRollServiceServiceDescription();
 
   String get serviceName => CameraRollService.serviceName;
 
-  @override
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       case _cameraRollServiceMethodGetCountName:
         var r = CameraRollServiceGetCountResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
         }
         Completer c = completerMap[message.header.requestId];
@@ skipping 36 matching lines @@
     }
   }
 
   @override
   String toString() {
     var superString = super.toString();
     return "_CameraRollServiceProxyControl($superString)";
   }
 }
 
-
-class CameraRollServiceProxy extends bindings.Proxy
-                              implements CameraRollService {
+class CameraRollServiceProxy
+    extends bindings.Proxy
+    implements CameraRollService {
   CameraRollServiceProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint)
       : super(new _CameraRollServiceProxyControl.fromEndpoint(endpoint));
 
   CameraRollServiceProxy.fromHandle(core.MojoHandle handle)
       : super(new _CameraRollServiceProxyControl.fromHandle(handle));
 
   CameraRollServiceProxy.unbound()
       : super(new _CameraRollServiceProxyControl.unbound());
 
@@ skipping 32 matching lines @@
     var params = new _CameraRollServiceGetPhotoParams();
     params.index = index;
     return ctrl.sendMessageWithRequestId(
         params,
         _cameraRollServiceMethodGetPhotoName,
         -1,
         bindings.MessageHeader.kMessageExpectsResponse);
   }
 }
 
-
-class CameraRollServiceStub extends bindings.Stub {
+class _CameraRollServiceStubControl
+    extends bindings.StubMessageHandler
+    implements bindings.StubControl<CameraRollService> {
   CameraRollService _impl;
 
-  CameraRollServiceStub.fromEndpoint(
+  _CameraRollServiceStubControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [CameraRollService impl])
       : super.fromEndpoint(endpoint, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  CameraRollServiceStub.fromHandle(
+  _CameraRollServiceStubControl.fromHandle(
       core.MojoHandle handle, [CameraRollService impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  CameraRollServiceStub.unbound([this._impl]) : super.unbound();
-
-  static CameraRollServiceStub newFromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For CameraRollServiceStub"));
-    return new CameraRollServiceStub.fromEndpoint(endpoint);
-  }
+  _CameraRollServiceStubControl.unbound([this._impl]) : super.unbound();
 
 
   CameraRollServiceGetCountResponseParams _cameraRollServiceGetCountResponseParamsFactory(int numPhotos) {
     var result = new CameraRollServiceGetCountResponseParams();
     result.numPhotos = numPhotos;
     return result;
   }
   CameraRollServiceGetPhotoResponseParams _cameraRollServiceGetPhotoResponseParamsFactory(Photo photo) {
     var result = new CameraRollServiceGetPhotoResponseParams();
     result.photo = photo;
@@ skipping 74 matching lines @@
   }
 
   @override
   void bind(core.MojoMessagePipeEndpoint endpoint) {
     super.bind(endpoint);
     if (!isOpen && (_impl != null)) {
       beginHandlingEvents();
     }
   }
 
+  @override
   String toString() {
     var superString = super.toString();
-    return "CameraRollServiceStub($superString)";
+    return "_CameraRollServiceStubControl($superString)";
   }
 
   int get version => 0;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _CameraRollServiceServiceDescription();
     }
     return _cachedServiceDescription;
   }
 }
 
+class CameraRollServiceStub
+    extends bindings.Stub<CameraRollService>
+    implements CameraRollService {
+  CameraRollServiceStub.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint, [CameraRollService impl])
+      : super(new _CameraRollServiceStubControl.fromEndpoint(endpoint, impl));
+
+  CameraRollServiceStub.fromHandle(
+      core.MojoHandle handle, [CameraRollService impl])
+      : super(new _CameraRollServiceStubControl.fromHandle(handle, impl));
+
+  CameraRollServiceStub.unbound([CameraRollService impl])
+      : super(new _CameraRollServiceStubControl.unbound(impl));
+
+  static CameraRollServiceStub newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For CameraRollServiceStub"));
+    return new CameraRollServiceStub.fromEndpoint(endpoint);
+  }
+
+  static service_describer.ServiceDescription get serviceDescription =>
+      _CameraRollServiceStubControl.serviceDescription;
+
+
+  void update() {
+    return impl.update();
+  }
+  dynamic getCount([Function responseFactory = null]) {
+    return impl.getCount(responseFactory);
+  }
+  dynamic getPhoto(int index,[Function responseFactory = null]) {
+    return impl.getPhoto(index,responseFactory);
+  }
+}
+
 const int _cameraServiceMethodGetLatestFrameName = 0;
 
 class _CameraServiceServiceDescription 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 CameraService {
   static const String serviceName = "mojo::CameraService";
   dynamic getLatestFrame([Function responseFactory = null]);
 }
 
-
-class _CameraServiceProxyControl extends bindings.ProxyMessageHandler
-                                      implements bindings.ProxyControl {
+class _CameraServiceProxyControl
+    extends bindings.ProxyMessageHandler
+    implements bindings.ProxyControl {
   _CameraServiceProxyControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _CameraServiceProxyControl.fromHandle(
       core.MojoHandle handle) : super.fromHandle(handle);
 
   _CameraServiceProxyControl.unbound() : super.unbound();
 
   service_describer.ServiceDescription get serviceDescription =>
       new _CameraServiceServiceDescription();
 
   String get serviceName => CameraService.serviceName;
 
-  @override
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       case _cameraServiceMethodGetLatestFrameName:
         var r = CameraServiceGetLatestFrameResponseParams.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 "_CameraServiceProxyControl($superString)";
   }
 }
 
-
-class CameraServiceProxy extends bindings.Proxy
-                              implements CameraService {
+class CameraServiceProxy
+    extends bindings.Proxy
+    implements CameraService {
   CameraServiceProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint)
       : super(new _CameraServiceProxyControl.fromEndpoint(endpoint));
 
   CameraServiceProxy.fromHandle(core.MojoHandle handle)
       : super(new _CameraServiceProxyControl.fromHandle(handle));
 
   CameraServiceProxy.unbound()
       : super(new _CameraServiceProxyControl.unbound());
 
@@ skipping 14 matching lines @@
   dynamic getLatestFrame([Function responseFactory = null]) {
     var params = new _CameraServiceGetLatestFrameParams();
     return ctrl.sendMessageWithRequestId(
         params,
         _cameraServiceMethodGetLatestFrameName,
         -1,
         bindings.MessageHeader.kMessageExpectsResponse);
   }
 }
 
-
-class CameraServiceStub extends bindings.Stub {
+class _CameraServiceStubControl
+    extends bindings.StubMessageHandler
+    implements bindings.StubControl<CameraService> {
   CameraService _impl;
 
-  CameraServiceStub.fromEndpoint(
+  _CameraServiceStubControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [CameraService impl])
       : super.fromEndpoint(endpoint, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  CameraServiceStub.fromHandle(
+  _CameraServiceStubControl.fromHandle(
       core.MojoHandle handle, [CameraService impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  CameraServiceStub.unbound([this._impl]) : super.unbound();
-
-  static CameraServiceStub newFromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For CameraServiceStub"));
-    return new CameraServiceStub.fromEndpoint(endpoint);
-  }
+  _CameraServiceStubControl.unbound([this._impl]) : super.unbound();
 
 
   CameraServiceGetLatestFrameResponseParams _cameraServiceGetLatestFrameResponseParamsFactory(core.MojoDataPipeConsumer content) {
     var result = new CameraServiceGetLatestFrameResponseParams();
     result.content = content;
     return result;
   }
 
   dynamic handleMessage(bindings.ServiceMessage message) {
     if (bindings.ControlMessageHandler.isControlMessage(message)) {
@@ skipping 44 matching lines @@
   }
 
   @override
   void bind(core.MojoMessagePipeEndpoint endpoint) {
     super.bind(endpoint);
     if (!isOpen && (_impl != null)) {
       beginHandlingEvents();
     }
   }
 
+  @override
   String toString() {
     var superString = super.toString();
-    return "CameraServiceStub($superString)";
+    return "_CameraServiceStubControl($superString)";
   }
 
   int get version => 0;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _CameraServiceServiceDescription();
     }
     return _cachedServiceDescription;
   }
 }
 
+class CameraServiceStub
+    extends bindings.Stub<CameraService>
+    implements CameraService {
+  CameraServiceStub.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint, [CameraService impl])
+      : super(new _CameraServiceStubControl.fromEndpoint(endpoint, impl));
+
+  CameraServiceStub.fromHandle(
+      core.MojoHandle handle, [CameraService impl])
+      : super(new _CameraServiceStubControl.fromHandle(handle, impl));
+
+  CameraServiceStub.unbound([CameraService impl])
+      : super(new _CameraServiceStubControl.unbound(impl));
+
+  static CameraServiceStub newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For CameraServiceStub"));
+    return new CameraServiceStub.fromEndpoint(endpoint);
+  }
+
+  static service_describer.ServiceDescription get serviceDescription =>
+      _CameraServiceStubControl.serviceDescription;
+
+
+  dynamic getLatestFrame([Function responseFactory = null]) {
+    return impl.getLatestFrame(responseFactory);
+  }
+}
+