Dart: Refactor Stubs

mojo/dart/packages/mojo_services/lib/mojo/web_socket.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 web_socket_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 920 matching lines @@
 
 abstract class WebSocket {
   static const String serviceName = null;
   void connect(String url, List<String> protocols, String origin, core.MojoDataPipeConsumer sendStream, Object client);
   void send(bool fin, WebSocketMessageType type, int numBytes);
   void flowControl(int quota);
   void close_(int code, String reason);
   static const int kAbnormalCloseCode = 1006;
 }
 
-
-class _WebSocketProxyControl extends bindings.ProxyMessageHandler
-                                      implements bindings.ProxyControl {
+class _WebSocketProxyControl
+    extends bindings.ProxyMessageHandler
+    implements bindings.ProxyControl {
   _WebSocketProxyControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _WebSocketProxyControl.fromHandle(
       core.MojoHandle handle) : super.fromHandle(handle);
 
   _WebSocketProxyControl.unbound() : super.unbound();
 
   service_describer.ServiceDescription get serviceDescription =>
       new _WebSocketServiceDescription();
 
   String get serviceName => WebSocket.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 "_WebSocketProxyControl($superString)";
   }
 }
 
-
-class WebSocketProxy extends bindings.Proxy
-                              implements WebSocket {
+class WebSocketProxy
+    extends bindings.Proxy
+    implements WebSocket {
   WebSocketProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint)
       : super(new _WebSocketProxyControl.fromEndpoint(endpoint));
 
   WebSocketProxy.fromHandle(core.MojoHandle handle)
       : super(new _WebSocketProxyControl.fromHandle(handle));
 
   WebSocketProxy.unbound()
       : super(new _WebSocketProxyControl.unbound());
 
@@ skipping 53 matching lines @@
       return;
     }
     var params = new _WebSocketCloseParams();
     params.code = code;
     params.reason = reason;
     ctrl.sendMessage(params,
         _webSocketMethodCloseName);
   }
 }
 
-
-class WebSocketStub extends bindings.Stub {
+class _WebSocketStubControl
+    extends bindings.StubMessageHandler
+    implements bindings.StubControl<WebSocket> {
   WebSocket _impl;
 
-  WebSocketStub.fromEndpoint(
+  _WebSocketStubControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [WebSocket impl])
       : super.fromEndpoint(endpoint, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  WebSocketStub.fromHandle(
+  _WebSocketStubControl.fromHandle(
       core.MojoHandle handle, [WebSocket impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  WebSocketStub.unbound([this._impl]) : super.unbound();
-
-  static WebSocketStub newFromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For WebSocketStub"));
-    return new WebSocketStub.fromEndpoint(endpoint);
-  }
+  _WebSocketStubControl.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 39 matching lines @@
   }
 
   @override
   void bind(core.MojoMessagePipeEndpoint endpoint) {
     super.bind(endpoint);
     if (!isOpen && (_impl != null)) {
       beginHandlingEvents();
     }
   }
 
+  @override
   String toString() {
     var superString = super.toString();
-    return "WebSocketStub($superString)";
+    return "_WebSocketStubControl($superString)";
   }
 
   int get version => 0;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _WebSocketServiceDescription();
     }
     return _cachedServiceDescription;
   }
 }
 
+class WebSocketStub
+    extends bindings.Stub<WebSocket>
+    implements WebSocket {
+  WebSocketStub.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint, [WebSocket impl])
+      : super(new _WebSocketStubControl.fromEndpoint(endpoint, impl));
+
+  WebSocketStub.fromHandle(
+      core.MojoHandle handle, [WebSocket impl])
+      : super(new _WebSocketStubControl.fromHandle(handle, impl));
+
+  WebSocketStub.unbound([WebSocket impl])
+      : super(new _WebSocketStubControl.unbound(impl));
+
+  static WebSocketStub newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For WebSocketStub"));
+    return new WebSocketStub.fromEndpoint(endpoint);
+  }
+
+  static service_describer.ServiceDescription get serviceDescription =>
+      _WebSocketStubControl.serviceDescription;
+
+
+  void connect(String url, List<String> protocols, String origin, core.MojoDataPipeConsumer sendStream, Object client) {
+    return impl.connect(url, protocols, origin, sendStream, client);
+  }
+  void send(bool fin, WebSocketMessageType type, int numBytes) {
+    return impl.send(fin, type, numBytes);
+  }
+  void flowControl(int quota) {
+    return impl.flowControl(quota);
+  }
+  void close_(int code, String reason) {
+    return impl.close_(code, reason);
+  }
+}
+
 const int _webSocketClientMethodDidConnectName = 0;
 const int _webSocketClientMethodDidReceiveDataName = 1;
 const int _webSocketClientMethodDidReceiveFlowControlName = 2;
 const int _webSocketClientMethodDidFailName = 3;
 const int _webSocketClientMethodDidCloseName = 4;
 
 class _WebSocketClientServiceDescription 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 WebSocketClient {
   static const String serviceName = null;
   void didConnect(String selectedSubprotocol, String extensions, core.MojoDataPipeConsumer receiveStream);
   void didReceiveData(bool fin, WebSocketMessageType type, int numBytes);
   void didReceiveFlowControl(int quota);
   void didFail(String message);
   void didClose(bool wasClean, int code, String reason);
 }
 
-
-class _WebSocketClientProxyControl extends bindings.ProxyMessageHandler
-                                      implements bindings.ProxyControl {
+class _WebSocketClientProxyControl
+    extends bindings.ProxyMessageHandler
+    implements bindings.ProxyControl {
   _WebSocketClientProxyControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _WebSocketClientProxyControl.fromHandle(
       core.MojoHandle handle) : super.fromHandle(handle);
 
   _WebSocketClientProxyControl.unbound() : super.unbound();
 
   service_describer.ServiceDescription get serviceDescription =>
       new _WebSocketClientServiceDescription();
 
   String get serviceName => WebSocketClient.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 "_WebSocketClientProxyControl($superString)";
   }
 }
 
-
-class WebSocketClientProxy extends bindings.Proxy
-                              implements WebSocketClient {
+class WebSocketClientProxy
+    extends bindings.Proxy
+    implements WebSocketClient {
   WebSocketClientProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint)
       : super(new _WebSocketClientProxyControl.fromEndpoint(endpoint));
 
   WebSocketClientProxy.fromHandle(core.MojoHandle handle)
       : super(new _WebSocketClientProxyControl.fromHandle(handle));
 
   WebSocketClientProxy.unbound()
       : super(new _WebSocketClientProxyControl.unbound());
 
@@ skipping 62 matching lines @@
     }
     var params = new _WebSocketClientDidCloseParams();
     params.wasClean = wasClean;
     params.code = code;
     params.reason = reason;
     ctrl.sendMessage(params,
         _webSocketClientMethodDidCloseName);
   }
 }
 
-
-class WebSocketClientStub extends bindings.Stub {
+class _WebSocketClientStubControl
+    extends bindings.StubMessageHandler
+    implements bindings.StubControl<WebSocketClient> {
   WebSocketClient _impl;
 
-  WebSocketClientStub.fromEndpoint(
+  _WebSocketClientStubControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [WebSocketClient impl])
       : super.fromEndpoint(endpoint, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  WebSocketClientStub.fromHandle(
+  _WebSocketClientStubControl.fromHandle(
       core.MojoHandle handle, [WebSocketClient impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  WebSocketClientStub.unbound([this._impl]) : super.unbound();
-
-  static WebSocketClientStub newFromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For WebSocketClientStub"));
-    return new WebSocketClientStub.fromEndpoint(endpoint);
-  }
+  _WebSocketClientStubControl.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 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 "WebSocketClientStub($superString)";
+    return "_WebSocketClientStubControl($superString)";
   }
 
   int get version => 0;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _WebSocketClientServiceDescription();
     }
     return _cachedServiceDescription;
   }
 }
 
+class WebSocketClientStub
+    extends bindings.Stub<WebSocketClient>
+    implements WebSocketClient {
+  WebSocketClientStub.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint, [WebSocketClient impl])
+      : super(new _WebSocketClientStubControl.fromEndpoint(endpoint, impl));
+
+  WebSocketClientStub.fromHandle(
+      core.MojoHandle handle, [WebSocketClient impl])
+      : super(new _WebSocketClientStubControl.fromHandle(handle, impl));
+
+  WebSocketClientStub.unbound([WebSocketClient impl])
+      : super(new _WebSocketClientStubControl.unbound(impl));
+
+  static WebSocketClientStub newFromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint) {
+    assert(endpoint.setDescription("For WebSocketClientStub"));
+    return new WebSocketClientStub.fromEndpoint(endpoint);
+  }
+
+  static service_describer.ServiceDescription get serviceDescription =>
+      _WebSocketClientStubControl.serviceDescription;
+
+
+  void didConnect(String selectedSubprotocol, String extensions, core.MojoDataPipeConsumer receiveStream) {
+    return impl.didConnect(selectedSubprotocol, extensions, receiveStream);
+  }
+  void didReceiveData(bool fin, WebSocketMessageType type, int numBytes) {
+    return impl.didReceiveData(fin, type, numBytes);
+  }
+  void didReceiveFlowControl(int quota) {
+    return impl.didReceiveFlowControl(quota);
+  }
+  void didFail(String message) {
+    return impl.didFail(message);
+  }
+  void didClose(bool wasClean, int code, String reason) {
+    return impl.didClose(wasClean, code, reason);
+  }
+}
+