Dart: Refactor Stubs

mojo/dart/packages/mojo_services/lib/keyboard/keyboard.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 keyboard_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;
 import 'package:mojo_services/mojo/native_viewport_event_dispatcher.mojom.dart' as native_viewport_event_dispatcher_mojom;
@@ skipping 1447 matching lines @@
   void commitCompletion(CompletionData completion);
   void commitCorrection(CorrectionData correction);
   void commitText(String text, int newCursorPosition);
   void deleteSurroundingText(int beforeLength, int afterLength);
   void setComposingRegion(int start, int end);
   void setComposingText(String text, int newCursorPosition);
   void setSelection(int start, int end);
   void submit(SubmitAction action);
 }
 
-
-class _KeyboardClientProxyControl extends bindings.ProxyMessageHandler
-                                      implements bindings.ProxyControl {
+class _KeyboardClientProxyControl
+    extends bindings.ProxyMessageHandler
+    implements bindings.ProxyControl {
   _KeyboardClientProxyControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _KeyboardClientProxyControl.fromHandle(
       core.MojoHandle handle) : super.fromHandle(handle);
 
   _KeyboardClientProxyControl.unbound() : super.unbound();
 
   service_describer.ServiceDescription get serviceDescription =>
       new _KeyboardClientServiceDescription();
 
   String get serviceName => KeyboardClient.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 "_KeyboardClientProxyControl($superString)";
   }
 }
 
-
-class KeyboardClientProxy extends bindings.Proxy
-                              implements KeyboardClient {
+class KeyboardClientProxy
+    extends bindings.Proxy
+    implements KeyboardClient {
   KeyboardClientProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint)
       : super(new _KeyboardClientProxyControl.fromEndpoint(endpoint));
 
   KeyboardClientProxy.fromHandle(core.MojoHandle handle)
       : super(new _KeyboardClientProxyControl.fromHandle(handle));
 
   KeyboardClientProxy.unbound()
       : super(new _KeyboardClientProxyControl.unbound());
 
@@ skipping 91 matching lines @@
       ctrl.proxyError("The Proxy is closed.");
       return;
     }
     var params = new _KeyboardClientSubmitParams();
     params.action = action;
     ctrl.sendMessage(params,
         _keyboardClientMethodSubmitName);
   }
 }
 
-
-class KeyboardClientStub extends bindings.Stub {
+class _KeyboardClientStubControl
+    extends bindings.StubMessageHandler
+    implements bindings.StubControl<KeyboardClient> {
   KeyboardClient _impl;
 
-  KeyboardClientStub.fromEndpoint(
+  _KeyboardClientStubControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [KeyboardClient impl])
       : super.fromEndpoint(endpoint, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  KeyboardClientStub.fromHandle(
+  _KeyboardClientStubControl.fromHandle(
       core.MojoHandle handle, [KeyboardClient impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  KeyboardClientStub.unbound([this._impl]) : super.unbound();
-
-  static KeyboardClientStub newFromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For KeyboardClientStub"));
-    return new KeyboardClientStub.fromEndpoint(endpoint);
-  }
+  _KeyboardClientStubControl.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 59 matching lines @@
   }
 
   @override
   void bind(core.MojoMessagePipeEndpoint endpoint) {
     super.bind(endpoint);
     if (!isOpen && (_impl != null)) {
       beginHandlingEvents();
     }
   }
 
+  @override
   String toString() {
     var superString = super.toString();
-    return "KeyboardClientStub($superString)";
+    return "_KeyboardClientStubControl($superString)";
   }
 
   int get version => 0;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _KeyboardClientServiceDescription();
     }
     return _cachedServiceDescription;
   }
 }
 
+class KeyboardClientStub
+    extends bindings.Stub<KeyboardClient>
+    implements KeyboardClient {
+  KeyboardClientStub.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint, [KeyboardClient impl])
+      : super(new _KeyboardClientStubControl.fromEndpoint(endpoint, impl));
+
+  KeyboardClientStub.fromHandle(
+      core.MojoHandle handle, [KeyboardClient impl])
+      : super(new _KeyboardClientStubControl.fromHandle(handle, impl));
+
+  KeyboardClientStub.unbound([KeyboardClient impl])
+      : super(new _KeyboardClientStubControl.unbound(impl));
+
+  static KeyboardClientStub newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For KeyboardClientStub"));
+    return new KeyboardClientStub.fromEndpoint(endpoint);
+  }
+
+  static service_describer.ServiceDescription get serviceDescription =>
+      _KeyboardClientStubControl.serviceDescription;
+
+
+  void commitCompletion(CompletionData completion) {
+    return impl.commitCompletion(completion);
+  }
+  void commitCorrection(CorrectionData correction) {
+    return impl.commitCorrection(correction);
+  }
+  void commitText(String text, int newCursorPosition) {
+    return impl.commitText(text, newCursorPosition);
+  }
+  void deleteSurroundingText(int beforeLength, int afterLength) {
+    return impl.deleteSurroundingText(beforeLength, afterLength);
+  }
+  void setComposingRegion(int start, int end) {
+    return impl.setComposingRegion(start, end);
+  }
+  void setComposingText(String text, int newCursorPosition) {
+    return impl.setComposingText(text, newCursorPosition);
+  }
+  void setSelection(int start, int end) {
+    return impl.setSelection(start, end);
+  }
+  void submit(SubmitAction action) {
+    return impl.submit(action);
+  }
+}
+
 const int _keyboardServiceMethodShowName = 0;
 const int _keyboardServiceMethodShowByRequestName = 1;
 const int _keyboardServiceMethodHideName = 2;
 const int _keyboardServiceMethodSetTextName = 3;
 const int _keyboardServiceMethodSetSelectionName = 4;
 
 class _KeyboardServiceServiceDescription 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 KeyboardService {
   static const String serviceName = "keyboard::KeyboardService";
   void show(Object client, KeyboardType type);
   void showByRequest();
   void hide();
   void setText(String text);
   void setSelection(int start, int end);
 }
 
-
-class _KeyboardServiceProxyControl extends bindings.ProxyMessageHandler
-                                      implements bindings.ProxyControl {
+class _KeyboardServiceProxyControl
+    extends bindings.ProxyMessageHandler
+    implements bindings.ProxyControl {
   _KeyboardServiceProxyControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _KeyboardServiceProxyControl.fromHandle(
       core.MojoHandle handle) : super.fromHandle(handle);
 
   _KeyboardServiceProxyControl.unbound() : super.unbound();
 
   service_describer.ServiceDescription get serviceDescription =>
       new _KeyboardServiceServiceDescription();
 
   String get serviceName => KeyboardService.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 "_KeyboardServiceProxyControl($superString)";
   }
 }
 
-
-class KeyboardServiceProxy extends bindings.Proxy
-                              implements KeyboardService {
+class KeyboardServiceProxy
+    extends bindings.Proxy
+    implements KeyboardService {
   KeyboardServiceProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint)
       : super(new _KeyboardServiceProxyControl.fromEndpoint(endpoint));
 
   KeyboardServiceProxy.fromHandle(core.MojoHandle handle)
       : super(new _KeyboardServiceProxyControl.fromHandle(handle));
 
   KeyboardServiceProxy.unbound()
       : super(new _KeyboardServiceProxyControl.unbound());
 
@@ skipping 56 matching lines @@
       return;
     }
     var params = new _KeyboardServiceSetSelectionParams();
     params.start = start;
     params.end = end;
     ctrl.sendMessage(params,
         _keyboardServiceMethodSetSelectionName);
   }
 }
 
-
-class KeyboardServiceStub extends bindings.Stub {
+class _KeyboardServiceStubControl
+    extends bindings.StubMessageHandler
+    implements bindings.StubControl<KeyboardService> {
   KeyboardService _impl;
 
-  KeyboardServiceStub.fromEndpoint(
+  _KeyboardServiceStubControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [KeyboardService impl])
       : super.fromEndpoint(endpoint, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  KeyboardServiceStub.fromHandle(
+  _KeyboardServiceStubControl.fromHandle(
       core.MojoHandle handle, [KeyboardService impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  KeyboardServiceStub.unbound([this._impl]) : super.unbound();
-
-  static KeyboardServiceStub newFromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For KeyboardServiceStub"));
-    return new KeyboardServiceStub.fromEndpoint(endpoint);
-  }
+  _KeyboardServiceStubControl.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 40 matching lines @@
   }
 
   @override
   void bind(core.MojoMessagePipeEndpoint endpoint) {
     super.bind(endpoint);
     if (!isOpen && (_impl != null)) {
       beginHandlingEvents();
     }
   }
 
+  @override
   String toString() {
     var superString = super.toString();
-    return "KeyboardServiceStub($superString)";
+    return "_KeyboardServiceStubControl($superString)";
   }
 
   int get version => 0;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _KeyboardServiceServiceDescription();
     }
     return _cachedServiceDescription;
   }
 }
 
+class KeyboardServiceStub
+    extends bindings.Stub<KeyboardService>
+    implements KeyboardService {
+  KeyboardServiceStub.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint, [KeyboardService impl])
+      : super(new _KeyboardServiceStubControl.fromEndpoint(endpoint, impl));
+
+  KeyboardServiceStub.fromHandle(
+      core.MojoHandle handle, [KeyboardService impl])
+      : super(new _KeyboardServiceStubControl.fromHandle(handle, impl));
+
+  KeyboardServiceStub.unbound([KeyboardService impl])
+      : super(new _KeyboardServiceStubControl.unbound(impl));
+
+  static KeyboardServiceStub newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For KeyboardServiceStub"));
+    return new KeyboardServiceStub.fromEndpoint(endpoint);
+  }
+
+  static service_describer.ServiceDescription get serviceDescription =>
+      _KeyboardServiceStubControl.serviceDescription;
+
+
+  void show(Object client, KeyboardType type) {
+    return impl.show(client, type);
+  }
+  void showByRequest() {
+    return impl.showByRequest();
+  }
+  void hide() {
+    return impl.hide();
+  }
+  void setText(String text) {
+    return impl.setText(text);
+  }
+  void setSelection(int start, int end) {
+    return impl.setSelection(start, end);
+  }
+}
+
 const int _keyboardServiceFactoryMethodCreateKeyboardServiceName = 0;
 
 class _KeyboardServiceFactoryServiceDescription 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 KeyboardServiceFactory {
   static const String serviceName = "keyboard::KeyboardServiceFactory";
   void createKeyboardService(Object keyEventDispatcher, Object serviceRequest);
 }
 
-
-class _KeyboardServiceFactoryProxyControl extends bindings.ProxyMessageHandler
-                                      implements bindings.ProxyControl {
+class _KeyboardServiceFactoryProxyControl
+    extends bindings.ProxyMessageHandler
+    implements bindings.ProxyControl {
   _KeyboardServiceFactoryProxyControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _KeyboardServiceFactoryProxyControl.fromHandle(
       core.MojoHandle handle) : super.fromHandle(handle);
 
   _KeyboardServiceFactoryProxyControl.unbound() : super.unbound();
 
   service_describer.ServiceDescription get serviceDescription =>
       new _KeyboardServiceFactoryServiceDescription();
 
   String get serviceName => KeyboardServiceFactory.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 "_KeyboardServiceFactoryProxyControl($superString)";
   }
 }
 
-
-class KeyboardServiceFactoryProxy extends bindings.Proxy
-                              implements KeyboardServiceFactory {
+class KeyboardServiceFactoryProxy
+    extends bindings.Proxy
+    implements KeyboardServiceFactory {
   KeyboardServiceFactoryProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint)
       : super(new _KeyboardServiceFactoryProxyControl.fromEndpoint(endpoint));
 
   KeyboardServiceFactoryProxy.fromHandle(core.MojoHandle handle)
       : super(new _KeyboardServiceFactoryProxyControl.fromHandle(handle));
 
   KeyboardServiceFactoryProxy.unbound()
       : super(new _KeyboardServiceFactoryProxyControl.unbound());
 
@@ skipping 17 matching lines @@
       return;
     }
     var params = new _KeyboardServiceFactoryCreateKeyboardServiceParams();
     params.keyEventDispatcher = keyEventDispatcher;
     params.serviceRequest = serviceRequest;
     ctrl.sendMessage(params,
         _keyboardServiceFactoryMethodCreateKeyboardServiceName);
   }
 }
 
-
-class KeyboardServiceFactoryStub extends bindings.Stub {
+class _KeyboardServiceFactoryStubControl
+    extends bindings.StubMessageHandler
+    implements bindings.StubControl<KeyboardServiceFactory> {
   KeyboardServiceFactory _impl;
 
-  KeyboardServiceFactoryStub.fromEndpoint(
+  _KeyboardServiceFactoryStubControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [KeyboardServiceFactory impl])
       : super.fromEndpoint(endpoint, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  KeyboardServiceFactoryStub.fromHandle(
+  _KeyboardServiceFactoryStubControl.fromHandle(
       core.MojoHandle handle, [KeyboardServiceFactory impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  KeyboardServiceFactoryStub.unbound([this._impl]) : super.unbound();
-
-  static KeyboardServiceFactoryStub newFromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For KeyboardServiceFactoryStub"));
-    return new KeyboardServiceFactoryStub.fromEndpoint(endpoint);
-  }
+  _KeyboardServiceFactoryStubControl.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 24 matching lines @@
   }
 
   @override
   void bind(core.MojoMessagePipeEndpoint endpoint) {
     super.bind(endpoint);
     if (!isOpen && (_impl != null)) {
       beginHandlingEvents();
     }
   }
 
+  @override
   String toString() {
     var superString = super.toString();
-    return "KeyboardServiceFactoryStub($superString)";
+    return "_KeyboardServiceFactoryStubControl($superString)";
   }
 
   int get version => 0;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _KeyboardServiceFactoryServiceDescription();
     }
     return _cachedServiceDescription;
   }
 }
 
+class KeyboardServiceFactoryStub
+    extends bindings.Stub<KeyboardServiceFactory>
+    implements KeyboardServiceFactory {
+  KeyboardServiceFactoryStub.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint, [KeyboardServiceFactory impl])
+      : super(new _KeyboardServiceFactoryStubControl.fromEndpoint(endpoint, impl));
+
+  KeyboardServiceFactoryStub.fromHandle(
+      core.MojoHandle handle, [KeyboardServiceFactory impl])
+      : super(new _KeyboardServiceFactoryStubControl.fromHandle(handle, impl));
+
+  KeyboardServiceFactoryStub.unbound([KeyboardServiceFactory impl])
+      : super(new _KeyboardServiceFactoryStubControl.unbound(impl));
+
+  static KeyboardServiceFactoryStub newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For KeyboardServiceFactoryStub"));
+    return new KeyboardServiceFactoryStub.fromEndpoint(endpoint);
+  }
+
+  static service_describer.ServiceDescription get serviceDescription =>
+      _KeyboardServiceFactoryStubControl.serviceDescription;
+
+
+  void createKeyboardService(Object keyEventDispatcher, Object serviceRequest) {
+    return impl.createKeyboardService(keyEventDispatcher, serviceRequest);
+  }
+}
+