Dart: Futures -> Callbacks.

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;
 
 
 
 class _WebSocketConnectParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(48, 0)
   ];
   String url = null;
   List<String> protocols = null;
   String origin = null;
   core.MojoDataPipeConsumer sendStream = null;
   WebSocketClientInterface client = null;
 
   _WebSocketConnectParams() : super(kVersions.last.size);
 
+  _WebSocketConnectParams.init(
+    String this.url, 
+    List<String> this.protocols, 
+    String this.origin, 
+    core.MojoDataPipeConsumer this.sendStream, 
+    WebSocketClientInterface this.client
+  ) : super(kVersions.last.size);
+
   static _WebSocketConnectParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     return result;
   }
 
   static _WebSocketConnectParams decode(bindings.Decoder decoder0) {
@@ skipping 116 matching lines @@
 class _WebSocketSendParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   bool fin = false;
   WebSocketMessageType type = null;
   int numBytes = 0;
 
   _WebSocketSendParams() : super(kVersions.last.size);
 
+  _WebSocketSendParams.init(
+    bool this.fin, 
+    WebSocketMessageType this.type, 
+    int this.numBytes
+  ) : super(kVersions.last.size);
+
   static _WebSocketSendParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     return result;
   }
 
   static _WebSocketSendParams decode(bindings.Decoder decoder0) {
@@ skipping 82 matching lines @@
 
 
 class _WebSocketFlowControlParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   int quota = 0;
 
   _WebSocketFlowControlParams() : super(kVersions.last.size);
 
+  _WebSocketFlowControlParams.init(
+    int this.quota
+  ) : super(kVersions.last.size);
+
   static _WebSocketFlowControlParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     return result;
   }
 
   static _WebSocketFlowControlParams decode(bindings.Decoder decoder0) {
@@ skipping 53 matching lines @@
 
 class _WebSocketCloseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   int code = 0;
   String reason = null;
 
   _WebSocketCloseParams() : super(kVersions.last.size);
 
+  _WebSocketCloseParams.init(
+    int this.code, 
+    String this.reason
+  ) : super(kVersions.last.size);
+
   static _WebSocketCloseParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     return result;
   }
 
   static _WebSocketCloseParams decode(bindings.Decoder decoder0) {
@@ skipping 67 matching lines @@
 class _WebSocketClientDidConnectParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(32, 0)
   ];
   String selectedSubprotocol = null;
   String extensions = null;
   core.MojoDataPipeConsumer receiveStream = null;
 
   _WebSocketClientDidConnectParams() : super(kVersions.last.size);
 
+  _WebSocketClientDidConnectParams.init(
+    String this.selectedSubprotocol, 
+    String this.extensions, 
+    core.MojoDataPipeConsumer this.receiveStream
+  ) : super(kVersions.last.size);
+
   static _WebSocketClientDidConnectParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     return result;
   }
 
   static _WebSocketClientDidConnectParams decode(bindings.Decoder decoder0) {
@@ skipping 77 matching lines @@
 class _WebSocketClientDidReceiveDataParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   bool fin = false;
   WebSocketMessageType type = null;
   int numBytes = 0;
 
   _WebSocketClientDidReceiveDataParams() : super(kVersions.last.size);
 
+  _WebSocketClientDidReceiveDataParams.init(
+    bool this.fin, 
+    WebSocketMessageType this.type, 
+    int this.numBytes
+  ) : super(kVersions.last.size);
+
   static _WebSocketClientDidReceiveDataParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     return result;
   }
 
   static _WebSocketClientDidReceiveDataParams decode(bindings.Decoder decoder0) {
@@ skipping 82 matching lines @@
 
 
 class _WebSocketClientDidReceiveFlowControlParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   int quota = 0;
 
   _WebSocketClientDidReceiveFlowControlParams() : super(kVersions.last.size);
 
+  _WebSocketClientDidReceiveFlowControlParams.init(
+    int this.quota
+  ) : super(kVersions.last.size);
+
   static _WebSocketClientDidReceiveFlowControlParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     return result;
   }
 
   static _WebSocketClientDidReceiveFlowControlParams decode(bindings.Decoder decoder0) {
@@ skipping 52 matching lines @@
 
 
 class _WebSocketClientDidFailParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   String message = null;
 
   _WebSocketClientDidFailParams() : super(kVersions.last.size);
 
+  _WebSocketClientDidFailParams.init(
+    String this.message
+  ) : super(kVersions.last.size);
+
   static _WebSocketClientDidFailParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     return result;
   }
 
   static _WebSocketClientDidFailParams decode(bindings.Decoder decoder0) {
@@ skipping 54 matching lines @@
 class _WebSocketClientDidCloseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   bool wasClean = false;
   int code = 0;
   String reason = null;
 
   _WebSocketClientDidCloseParams() : super(kVersions.last.size);
 
+  _WebSocketClientDidCloseParams.init(
+    bool this.wasClean, 
+    int this.code, 
+    String this.reason
+  ) : super(kVersions.last.size);
+
   static _WebSocketClientDidCloseParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     return result;
   }
 
   static _WebSocketClientDidCloseParams decode(bindings.Decoder decoder0) {
@@ skipping 134 matching lines @@
         return 'WebSocketMessageType.binary';
       default:
         return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
 class _WebSocketServiceDescription implements service_describer.ServiceDescription {
-  dynamic getTopLevelInterface([Function responseFactory]) =>
-      responseFactory(null);
+  void getTopLevelInterface(Function responder) {
+    responder(null);
+  }
 
-  dynamic getTypeDefinition(String typeKey, [Function responseFactory]) =>
-      responseFactory(null);
+  void getTypeDefinition(String typeKey, Function responder) {
+    responder(null);
+  }
 
-  dynamic getAllTypeDefinitions([Function responseFactory]) =>
-      responseFactory(null);
+  void getAllTypeDefinitions(Function responder) {
+    responder(null);
+  }
 }
 
 abstract class WebSocket {
   static const String serviceName = null;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _WebSocketServiceDescription();
     }
@@ skipping 157 matching lines @@
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
   _WebSocketStubControl.unbound([this._impl]) : super.unbound();
 
   String get serviceName => WebSocket.serviceName;
 
 
 
-  dynamic handleMessage(bindings.ServiceMessage message) {
+  void handleMessage(bindings.ServiceMessage message) {
     if (bindings.ControlMessageHandler.isControlMessage(message)) {
-      return bindings.ControlMessageHandler.handleMessage(this,
-                                                          0,
-                                                          message);
+      bindings.ControlMessageHandler.handleMessage(
+          this, 0, message);
+      return;
     }
     if (_impl == null) {
       throw new core.MojoApiError("$this has no implementation set");
     }
     switch (message.header.type) {
       case _webSocketMethodConnectName:
         var params = _WebSocketConnectParams.deserialize(
             message.payload);
         _impl.connect(params.url, params.protocols, params.origin, params.sendStream, params.client);
         break;
       case _webSocketMethodSendName:
         var params = _WebSocketSendParams.deserialize(
             message.payload);
         _impl.send(params.fin, params.type, params.numBytes);
         break;
       case _webSocketMethodFlowControlName:
         var params = _WebSocketFlowControlParams.deserialize(
             message.payload);
         _impl.flowControl(params.quota);
         break;
       case _webSocketMethodCloseName:
         var params = _WebSocketCloseParams.deserialize(
             message.payload);
         _impl.close_(params.code, params.reason);
         break;
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
         break;
     }
-    return null;
   }
 
   WebSocket get impl => _impl;
   set impl(WebSocket d) {
     if (d == null) {
       throw new core.MojoApiError("$this: Cannot set a null implementation");
     }
     if (isBound && (_impl == null)) {
       beginHandlingEvents();
     }
@@ skipping 54 matching lines @@
   }
 }
 
 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);
+  void getTopLevelInterface(Function responder) {
+    responder(null);
+  }
 
-  dynamic getTypeDefinition(String typeKey, [Function responseFactory]) =>
-      responseFactory(null);
+  void getTypeDefinition(String typeKey, Function responder) {
+    responder(null);
+  }
 
-  dynamic getAllTypeDefinitions([Function responseFactory]) =>
-      responseFactory(null);
+  void getAllTypeDefinitions(Function responder) {
+    responder(null);
+  }
 }
 
 abstract class WebSocketClient {
   static const String serviceName = null;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _WebSocketClientServiceDescription();
     }
@@ skipping 166 matching lines @@
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
   _WebSocketClientStubControl.unbound([this._impl]) : super.unbound();
 
   String get serviceName => WebSocketClient.serviceName;
 
 
 
-  dynamic handleMessage(bindings.ServiceMessage message) {
+  void handleMessage(bindings.ServiceMessage message) {
     if (bindings.ControlMessageHandler.isControlMessage(message)) {
-      return bindings.ControlMessageHandler.handleMessage(this,
-                                                          0,
-                                                          message);
+      bindings.ControlMessageHandler.handleMessage(
+          this, 0, message);
+      return;
     }
     if (_impl == null) {
       throw new core.MojoApiError("$this has no implementation set");
     }
     switch (message.header.type) {
       case _webSocketClientMethodDidConnectName:
         var params = _WebSocketClientDidConnectParams.deserialize(
             message.payload);
         _impl.didConnect(params.selectedSubprotocol, params.extensions, params.receiveStream);
         break;
@@ skipping 14 matching lines @@
         break;
       case _webSocketClientMethodDidCloseName:
         var params = _WebSocketClientDidCloseParams.deserialize(
             message.payload);
         _impl.didClose(params.wasClean, params.code, params.reason);
         break;
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
         break;
     }
-    return null;
   }
 
   WebSocketClient get impl => _impl;
   set impl(WebSocketClient d) {
     if (d == null) {
       throw new core.MojoApiError("$this: Cannot set a null implementation");
     }
     if (isBound && (_impl == null)) {
       beginHandlingEvents();
     }
@@ skipping 52 matching lines @@
   void didFail(String message) {
     return impl.didFail(message);
   }
   void didClose(bool wasClean, int code, String reason) {
     return impl.didClose(wasClean, code, reason);
   }
 }