Dart: Futures -> Callbacks.

mojo/dart/packages/mojo_services/lib/mojo/udp_socket.mojom.dart

 // WARNING: DO NOT EDIT. This file was generated by a program.
 // See $MOJO_SDK/tools/bindings/mojom_bindings_generator.py.
 
 library udp_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;
 import 'package:mojo/mojo/network_error.mojom.dart' as network_error_mojom;
 import 'package:mojo_services/mojo/net_address.mojom.dart' as net_address_mojom;
 
 
 
 class _UdpSocketAllowAddressReuseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   _UdpSocketAllowAddressReuseParams() : super(kVersions.last.size);
 
+  _UdpSocketAllowAddressReuseParams.init(
+  ) : super(kVersions.last.size);
+
   static _UdpSocketAllowAddressReuseParams 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 _UdpSocketAllowAddressReuseParams decode(bindings.Decoder decoder0) {
@@ skipping 39 matching lines @@
 
 
 class UdpSocketAllowAddressReuseResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   network_error_mojom.NetworkError result = null;
 
   UdpSocketAllowAddressReuseResponseParams() : super(kVersions.last.size);
 
+  UdpSocketAllowAddressReuseResponseParams.init(
+    network_error_mojom.NetworkError this.result
+  ) : super(kVersions.last.size);
+
   static UdpSocketAllowAddressReuseResponseParams 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 UdpSocketAllowAddressReuseResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 53 matching lines @@
 
 
 class _UdpSocketBindParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   net_address_mojom.NetAddress addr = null;
 
   _UdpSocketBindParams() : super(kVersions.last.size);
 
+  _UdpSocketBindParams.init(
+    net_address_mojom.NetAddress this.addr
+  ) : super(kVersions.last.size);
+
   static _UdpSocketBindParams 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 _UdpSocketBindParams decode(bindings.Decoder decoder0) {
@@ skipping 55 matching lines @@
 class UdpSocketBindResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(32, 0)
   ];
   network_error_mojom.NetworkError result = null;
   net_address_mojom.NetAddress boundAddr = null;
   UdpSocketReceiverInterfaceRequest receiver = null;
 
   UdpSocketBindResponseParams() : super(kVersions.last.size);
 
+  UdpSocketBindResponseParams.init(
+    network_error_mojom.NetworkError this.result, 
+    net_address_mojom.NetAddress this.boundAddr, 
+    UdpSocketReceiverInterfaceRequest this.receiver
+  ) : super(kVersions.last.size);
+
   static UdpSocketBindResponseParams 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 UdpSocketBindResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 77 matching lines @@
 
 
 class _UdpSocketConnectParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   net_address_mojom.NetAddress remoteAddr = null;
 
   _UdpSocketConnectParams() : super(kVersions.last.size);
 
+  _UdpSocketConnectParams.init(
+    net_address_mojom.NetAddress this.remoteAddr
+  ) : super(kVersions.last.size);
+
   static _UdpSocketConnectParams 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 _UdpSocketConnectParams decode(bindings.Decoder decoder0) {
@@ skipping 55 matching lines @@
 class UdpSocketConnectResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(32, 0)
   ];
   network_error_mojom.NetworkError result = null;
   net_address_mojom.NetAddress localAddr = null;
   UdpSocketReceiverInterfaceRequest receiver = null;
 
   UdpSocketConnectResponseParams() : super(kVersions.last.size);
 
+  UdpSocketConnectResponseParams.init(
+    network_error_mojom.NetworkError this.result, 
+    net_address_mojom.NetAddress this.localAddr, 
+    UdpSocketReceiverInterfaceRequest this.receiver
+  ) : super(kVersions.last.size);
+
   static UdpSocketConnectResponseParams 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 UdpSocketConnectResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 77 matching lines @@
 
 
 class _UdpSocketSetSendBufferSizeParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   int size = 0;
 
   _UdpSocketSetSendBufferSizeParams() : super(kVersions.last.size);
 
+  _UdpSocketSetSendBufferSizeParams.init(
+    int this.size
+  ) : super(kVersions.last.size);
+
   static _UdpSocketSetSendBufferSizeParams 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 _UdpSocketSetSendBufferSizeParams decode(bindings.Decoder decoder0) {
@@ skipping 52 matching lines @@
 
 
 class UdpSocketSetSendBufferSizeResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   network_error_mojom.NetworkError result = null;
 
   UdpSocketSetSendBufferSizeResponseParams() : super(kVersions.last.size);
 
+  UdpSocketSetSendBufferSizeResponseParams.init(
+    network_error_mojom.NetworkError this.result
+  ) : super(kVersions.last.size);
+
   static UdpSocketSetSendBufferSizeResponseParams 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 UdpSocketSetSendBufferSizeResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 53 matching lines @@
 
 
 class _UdpSocketSetReceiveBufferSizeParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   int size = 0;
 
   _UdpSocketSetReceiveBufferSizeParams() : super(kVersions.last.size);
 
+  _UdpSocketSetReceiveBufferSizeParams.init(
+    int this.size
+  ) : super(kVersions.last.size);
+
   static _UdpSocketSetReceiveBufferSizeParams 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 _UdpSocketSetReceiveBufferSizeParams decode(bindings.Decoder decoder0) {
@@ skipping 52 matching lines @@
 
 
 class UdpSocketSetReceiveBufferSizeResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   network_error_mojom.NetworkError result = null;
 
   UdpSocketSetReceiveBufferSizeResponseParams() : super(kVersions.last.size);
 
+  UdpSocketSetReceiveBufferSizeResponseParams.init(
+    network_error_mojom.NetworkError this.result
+  ) : super(kVersions.last.size);
+
   static UdpSocketSetReceiveBufferSizeResponseParams 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 UdpSocketSetReceiveBufferSizeResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 53 matching lines @@
 
 
 class _UdpSocketNegotiateMaxPendingSendRequestsParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   int requestedSize = 0;
 
   _UdpSocketNegotiateMaxPendingSendRequestsParams() : super(kVersions.last.size);
 
+  _UdpSocketNegotiateMaxPendingSendRequestsParams.init(
+    int this.requestedSize
+  ) : super(kVersions.last.size);
+
   static _UdpSocketNegotiateMaxPendingSendRequestsParams 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 _UdpSocketNegotiateMaxPendingSendRequestsParams decode(bindings.Decoder decoder0) {
@@ skipping 52 matching lines @@
 
 
 class UdpSocketNegotiateMaxPendingSendRequestsResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   int actualSize = 0;
 
   UdpSocketNegotiateMaxPendingSendRequestsResponseParams() : super(kVersions.last.size);
 
+  UdpSocketNegotiateMaxPendingSendRequestsResponseParams.init(
+    int this.actualSize
+  ) : super(kVersions.last.size);
+
   static UdpSocketNegotiateMaxPendingSendRequestsResponseParams 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 UdpSocketNegotiateMaxPendingSendRequestsResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 52 matching lines @@
 
 
 class _UdpSocketReceiveMoreParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   int datagramNumber = 0;
 
   _UdpSocketReceiveMoreParams() : super(kVersions.last.size);
 
+  _UdpSocketReceiveMoreParams.init(
+    int this.datagramNumber
+  ) : super(kVersions.last.size);
+
   static _UdpSocketReceiveMoreParams 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 _UdpSocketReceiveMoreParams decode(bindings.Decoder decoder0) {
@@ skipping 53 matching lines @@
 
 class _UdpSocketSendToParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   net_address_mojom.NetAddress destAddr = null;
   List<int> data = null;
 
   _UdpSocketSendToParams() : super(kVersions.last.size);
 
+  _UdpSocketSendToParams.init(
+    net_address_mojom.NetAddress this.destAddr, 
+    List<int> this.data
+  ) : super(kVersions.last.size);
+
   static _UdpSocketSendToParams 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 _UdpSocketSendToParams decode(bindings.Decoder decoder0) {
@@ skipping 66 matching lines @@
 
 
 class UdpSocketSendToResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   network_error_mojom.NetworkError result = null;
 
   UdpSocketSendToResponseParams() : super(kVersions.last.size);
 
+  UdpSocketSendToResponseParams.init(
+    network_error_mojom.NetworkError this.result
+  ) : super(kVersions.last.size);
+
   static UdpSocketSendToResponseParams 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 UdpSocketSendToResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 55 matching lines @@
 class _UdpSocketReceiverOnReceivedParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(32, 0)
   ];
   network_error_mojom.NetworkError result = null;
   net_address_mojom.NetAddress srcAddr = null;
   List<int> data = null;
 
   _UdpSocketReceiverOnReceivedParams() : super(kVersions.last.size);
 
+  _UdpSocketReceiverOnReceivedParams.init(
+    network_error_mojom.NetworkError this.result, 
+    net_address_mojom.NetAddress this.srcAddr, 
+    List<int> this.data
+  ) : super(kVersions.last.size);
+
   static _UdpSocketReceiverOnReceivedParams 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 _UdpSocketReceiverOnReceivedParams decode(bindings.Decoder decoder0) {
@@ skipping 81 matching lines @@
 const int _udpSocketMethodAllowAddressReuseName = 0;
 const int _udpSocketMethodBindName = 1;
 const int _udpSocketMethodConnectName = 2;
 const int _udpSocketMethodSetSendBufferSizeName = 3;
 const int _udpSocketMethodSetReceiveBufferSizeName = 4;
 const int _udpSocketMethodNegotiateMaxPendingSendRequestsName = 5;
 const int _udpSocketMethodReceiveMoreName = 6;
 const int _udpSocketMethodSendToName = 7;
 
 class _UdpSocketServiceDescription 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 UdpSocket {
   static const String serviceName = null;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _UdpSocketServiceDescription();
     }
     return _cachedServiceDescription;
   }
 
   static UdpSocketProxy connectToService(
       bindings.ServiceConnector s, String url, [String serviceName]) {
     UdpSocketProxy p = new UdpSocketProxy.unbound();
     String name = serviceName ?? UdpSocket.serviceName;
     if ((name == null) || name.isEmpty) {
       throw new core.MojoApiError(
           "If an interface has no ServiceName, then one must be provided.");
     }
     s.connectToService(url, p, name);
     return p;
   }
-  dynamic allowAddressReuse([Function responseFactory = null]);
-  dynamic bind(net_address_mojom.NetAddress addr,[Function responseFactory = null]);
-  dynamic connect(net_address_mojom.NetAddress remoteAddr,[Function responseFactory = null]);
-  dynamic setSendBufferSize(int size,[Function responseFactory = null]);
-  dynamic setReceiveBufferSize(int size,[Function responseFactory = null]);
-  dynamic negotiateMaxPendingSendRequests(int requestedSize,[Function responseFactory = null]);
+  void allowAddressReuse(void callback(network_error_mojom.NetworkError result));
+  void bind(net_address_mojom.NetAddress addr,void callback(network_error_mojom.NetworkError result, net_address_mojom.NetAddress boundAddr, UdpSocketReceiverInterfaceRequest receiver));
+  void connect(net_address_mojom.NetAddress remoteAddr,void callback(network_error_mojom.NetworkError result, net_address_mojom.NetAddress localAddr, UdpSocketReceiverInterfaceRequest receiver));
+  void setSendBufferSize(int size,void callback(network_error_mojom.NetworkError result));
+  void setReceiveBufferSize(int size,void callback(network_error_mojom.NetworkError result));
+  void negotiateMaxPendingSendRequests(int requestedSize,void callback(int actualSize));
   void receiveMore(int datagramNumber);
-  dynamic sendTo(net_address_mojom.NetAddress destAddr,List<int> data,[Function responseFactory = null]);
+  void sendTo(net_address_mojom.NetAddress destAddr,List<int> data,void callback(network_error_mojom.NetworkError result));
 }
 
 abstract class UdpSocketInterface
     implements bindings.MojoInterface<UdpSocket>,
                UdpSocket {
   factory UdpSocketInterface([UdpSocket impl]) =>
       new UdpSocketStub.unbound(impl);
 
   factory UdpSocketInterface.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint,
@@ skipping 29 matching lines @@
 
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       case _udpSocketMethodAllowAddressReuseName:
         var r = UdpSocketAllowAddressReuseResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
         }
-        Completer c = completerMap[message.header.requestId];
-        if (c == null) {
+        Function callback = callbackMap[message.header.requestId];
+        if (callback == null) {
           proxyError(
               "Message had unknown request Id: ${message.header.requestId}");
           return;
         }
-        completerMap.remove(message.header.requestId);
-        if (c.isCompleted) {
-          proxyError("Response completer already completed");
-          return;
-        }
-        c.complete(r);
+        callbackMap.remove(message.header.requestId);
+        callback(r.result );
         break;
       case _udpSocketMethodBindName:
         var r = UdpSocketBindResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
         }
-        Completer c = completerMap[message.header.requestId];
-        if (c == null) {
+        Function callback = callbackMap[message.header.requestId];
+        if (callback == null) {
           proxyError(
               "Message had unknown request Id: ${message.header.requestId}");
           return;
         }
-        completerMap.remove(message.header.requestId);
-        if (c.isCompleted) {
-          proxyError("Response completer already completed");
-          return;
-        }
-        c.complete(r);
+        callbackMap.remove(message.header.requestId);
+        callback(r.result , r.boundAddr , r.receiver );
         break;
       case _udpSocketMethodConnectName:
         var r = UdpSocketConnectResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
         }
-        Completer c = completerMap[message.header.requestId];
-        if (c == null) {
+        Function callback = callbackMap[message.header.requestId];
+        if (callback == null) {
           proxyError(
               "Message had unknown request Id: ${message.header.requestId}");
           return;
         }
-        completerMap.remove(message.header.requestId);
-        if (c.isCompleted) {
-          proxyError("Response completer already completed");
-          return;
-        }
-        c.complete(r);
+        callbackMap.remove(message.header.requestId);
+        callback(r.result , r.localAddr , r.receiver );
         break;
       case _udpSocketMethodSetSendBufferSizeName:
         var r = UdpSocketSetSendBufferSizeResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
         }
-        Completer c = completerMap[message.header.requestId];
-        if (c == null) {
+        Function callback = callbackMap[message.header.requestId];
+        if (callback == null) {
           proxyError(
               "Message had unknown request Id: ${message.header.requestId}");
           return;
         }
-        completerMap.remove(message.header.requestId);
-        if (c.isCompleted) {
-          proxyError("Response completer already completed");
-          return;
-        }
-        c.complete(r);
+        callbackMap.remove(message.header.requestId);
+        callback(r.result );
         break;
       case _udpSocketMethodSetReceiveBufferSizeName:
         var r = UdpSocketSetReceiveBufferSizeResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
         }
-        Completer c = completerMap[message.header.requestId];
-        if (c == null) {
+        Function callback = callbackMap[message.header.requestId];
+        if (callback == null) {
           proxyError(
               "Message had unknown request Id: ${message.header.requestId}");
           return;
         }
-        completerMap.remove(message.header.requestId);
-        if (c.isCompleted) {
-          proxyError("Response completer already completed");
-          return;
-        }
-        c.complete(r);
+        callbackMap.remove(message.header.requestId);
+        callback(r.result );
         break;
       case _udpSocketMethodNegotiateMaxPendingSendRequestsName:
         var r = UdpSocketNegotiateMaxPendingSendRequestsResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
         }
-        Completer c = completerMap[message.header.requestId];
-        if (c == null) {
+        Function callback = callbackMap[message.header.requestId];
+        if (callback == null) {
           proxyError(
               "Message had unknown request Id: ${message.header.requestId}");
           return;
         }
-        completerMap.remove(message.header.requestId);
-        if (c.isCompleted) {
-          proxyError("Response completer already completed");
-          return;
-        }
-        c.complete(r);
+        callbackMap.remove(message.header.requestId);
+        callback(r.actualSize );
         break;
       case _udpSocketMethodSendToName:
         var r = UdpSocketSendToResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
         }
-        Completer c = completerMap[message.header.requestId];
-        if (c == null) {
+        Function callback = callbackMap[message.header.requestId];
+        if (callback == null) {
           proxyError(
               "Message had unknown request Id: ${message.header.requestId}");
           return;
         }
-        completerMap.remove(message.header.requestId);
-        if (c.isCompleted) {
-          proxyError("Response completer already completed");
-          return;
-        }
-        c.complete(r);
+        callbackMap.remove(message.header.requestId);
+        callback(r.result );
         break;
       default:
         proxyError("Unexpected message type: ${message.header.type}");
         close(immediate: true);
         break;
     }
   }
 
   @override
   String toString() {
@@ skipping 24 matching lines @@
     return newMockedProxy;
   }
 
   static UdpSocketProxy newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For UdpSocketProxy"));
     return new UdpSocketProxy.fromEndpoint(endpoint);
   }
 
 
-  dynamic allowAddressReuse([Function responseFactory = null]) {
+  void allowAddressReuse(void callback(network_error_mojom.NetworkError result)) {
     if (impl != null) {
-      return new Future(() => impl.allowAddressReuse(_UdpSocketStubControl._udpSocketAllowAddressReuseResponseParamsFactory));
+      impl.allowAddressReuse(callback);
+      return;
     }
     var params = new _UdpSocketAllowAddressReuseParams();
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _udpSocketMethodAllowAddressReuseName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
   }
-  dynamic bind(net_address_mojom.NetAddress addr,[Function responseFactory = null]) {
+  void bind(net_address_mojom.NetAddress addr,void callback(network_error_mojom.NetworkError result, net_address_mojom.NetAddress boundAddr, UdpSocketReceiverInterfaceRequest receiver)) {
     if (impl != null) {
-      return new Future(() => impl.bind(addr,_UdpSocketStubControl._udpSocketBindResponseParamsFactory));
+      impl.bind(addr,callback);
+      return;
     }
     var params = new _UdpSocketBindParams();
     params.addr = addr;
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _udpSocketMethodBindName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
   }
-  dynamic connect(net_address_mojom.NetAddress remoteAddr,[Function responseFactory = null]) {
+  void connect(net_address_mojom.NetAddress remoteAddr,void callback(network_error_mojom.NetworkError result, net_address_mojom.NetAddress localAddr, UdpSocketReceiverInterfaceRequest receiver)) {
     if (impl != null) {
-      return new Future(() => impl.connect(remoteAddr,_UdpSocketStubControl._udpSocketConnectResponseParamsFactory));
+      impl.connect(remoteAddr,callback);
+      return;
     }
     var params = new _UdpSocketConnectParams();
     params.remoteAddr = remoteAddr;
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _udpSocketMethodConnectName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
   }
-  dynamic setSendBufferSize(int size,[Function responseFactory = null]) {
+  void setSendBufferSize(int size,void callback(network_error_mojom.NetworkError result)) {
     if (impl != null) {
-      return new Future(() => impl.setSendBufferSize(size,_UdpSocketStubControl._udpSocketSetSendBufferSizeResponseParamsFactory));
+      impl.setSendBufferSize(size,callback);
+      return;
     }
     var params = new _UdpSocketSetSendBufferSizeParams();
     params.size = size;
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _udpSocketMethodSetSendBufferSizeName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
   }
-  dynamic setReceiveBufferSize(int size,[Function responseFactory = null]) {
+  void setReceiveBufferSize(int size,void callback(network_error_mojom.NetworkError result)) {
     if (impl != null) {
-      return new Future(() => impl.setReceiveBufferSize(size,_UdpSocketStubControl._udpSocketSetReceiveBufferSizeResponseParamsFactory));
+      impl.setReceiveBufferSize(size,callback);
+      return;
     }
     var params = new _UdpSocketSetReceiveBufferSizeParams();
     params.size = size;
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _udpSocketMethodSetReceiveBufferSizeName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
   }
-  dynamic negotiateMaxPendingSendRequests(int requestedSize,[Function responseFactory = null]) {
+  void negotiateMaxPendingSendRequests(int requestedSize,void callback(int actualSize)) {
     if (impl != null) {
-      return new Future(() => impl.negotiateMaxPendingSendRequests(requestedSize,_UdpSocketStubControl._udpSocketNegotiateMaxPendingSendRequestsResponseParamsFactory));
+      impl.negotiateMaxPendingSendRequests(requestedSize,callback);
+      return;
     }
     var params = new _UdpSocketNegotiateMaxPendingSendRequestsParams();
     params.requestedSize = requestedSize;
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _udpSocketMethodNegotiateMaxPendingSendRequestsName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
   }
   void receiveMore(int datagramNumber) {
     if (impl != null) {
       impl.receiveMore(datagramNumber);
       return;
     }
     if (!ctrl.isBound) {
       ctrl.proxyError("The Proxy is closed.");
       return;
     }
     var params = new _UdpSocketReceiveMoreParams();
     params.datagramNumber = datagramNumber;
     ctrl.sendMessage(params,
         _udpSocketMethodReceiveMoreName);
   }
-  dynamic sendTo(net_address_mojom.NetAddress destAddr,List<int> data,[Function responseFactory = null]) {
+  void sendTo(net_address_mojom.NetAddress destAddr,List<int> data,void callback(network_error_mojom.NetworkError result)) {
     if (impl != null) {
-      return new Future(() => impl.sendTo(destAddr,data,_UdpSocketStubControl._udpSocketSendToResponseParamsFactory));
+      impl.sendTo(destAddr,data,callback);
+      return;
     }
     var params = new _UdpSocketSendToParams();
     params.destAddr = destAddr;
     params.data = data;
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _udpSocketMethodSendToName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
   }
 }
 
 class _UdpSocketStubControl
     extends bindings.StubMessageHandler
     implements bindings.StubControl<UdpSocket> {
   UdpSocket _impl;
 
   _UdpSocketStubControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [UdpSocket impl])
       : super.fromEndpoint(endpoint, autoBegin: impl != null) {
     _impl = impl;
   }
 
   _UdpSocketStubControl.fromHandle(
       core.MojoHandle handle, [UdpSocket impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
   _UdpSocketStubControl.unbound([this._impl]) : super.unbound();
 
   String get serviceName => UdpSocket.serviceName;
 
 
-  static UdpSocketAllowAddressReuseResponseParams _udpSocketAllowAddressReuseResponseParamsFactory(network_error_mojom.NetworkError result) {
-    var result = new UdpSocketAllowAddressReuseResponseParams();
-    result.result = result;
-    return result;
+  Function _udpSocketAllowAddressReuseResponseParamsResponder(
+      int requestId) {
+  return (network_error_mojom.NetworkError result) {
+      var result = new UdpSocketAllowAddressReuseResponseParams();
+      result.result = result;
+      sendResponse(buildResponseWithId(
+          result,
+          _udpSocketMethodAllowAddressReuseName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
   }
-  static UdpSocketBindResponseParams _udpSocketBindResponseParamsFactory(network_error_mojom.NetworkError result, net_address_mojom.NetAddress boundAddr, UdpSocketReceiverInterfaceRequest receiver) {
-    var result = new UdpSocketBindResponseParams();
-    result.result = result;
-    result.boundAddr = boundAddr;
-    result.receiver = receiver;
-    return result;
+  Function _udpSocketBindResponseParamsResponder(
+      int requestId) {
+  return (network_error_mojom.NetworkError result, net_address_mojom.NetAddress boundAddr, UdpSocketReceiverInterfaceRequest receiver) {
+      var result = new UdpSocketBindResponseParams();
+      result.result = result;
+      result.boundAddr = boundAddr;
+      result.receiver = receiver;
+      sendResponse(buildResponseWithId(
+          result,
+          _udpSocketMethodBindName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
   }
-  static UdpSocketConnectResponseParams _udpSocketConnectResponseParamsFactory(network_error_mojom.NetworkError result, net_address_mojom.NetAddress localAddr, UdpSocketReceiverInterfaceRequest receiver) {
-    var result = new UdpSocketConnectResponseParams();
-    result.result = result;
-    result.localAddr = localAddr;
-    result.receiver = receiver;
-    return result;
+  Function _udpSocketConnectResponseParamsResponder(
+      int requestId) {
+  return (network_error_mojom.NetworkError result, net_address_mojom.NetAddress localAddr, UdpSocketReceiverInterfaceRequest receiver) {
+      var result = new UdpSocketConnectResponseParams();
+      result.result = result;
+      result.localAddr = localAddr;
+      result.receiver = receiver;
+      sendResponse(buildResponseWithId(
+          result,
+          _udpSocketMethodConnectName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
   }
-  static UdpSocketSetSendBufferSizeResponseParams _udpSocketSetSendBufferSizeResponseParamsFactory(network_error_mojom.NetworkError result) {
-    var result = new UdpSocketSetSendBufferSizeResponseParams();
-    result.result = result;
-    return result;
+  Function _udpSocketSetSendBufferSizeResponseParamsResponder(
+      int requestId) {
+  return (network_error_mojom.NetworkError result) {
+      var result = new UdpSocketSetSendBufferSizeResponseParams();
+      result.result = result;
+      sendResponse(buildResponseWithId(
+          result,
+          _udpSocketMethodSetSendBufferSizeName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
   }
-  static UdpSocketSetReceiveBufferSizeResponseParams _udpSocketSetReceiveBufferSizeResponseParamsFactory(network_error_mojom.NetworkError result) {
-    var result = new UdpSocketSetReceiveBufferSizeResponseParams();
-    result.result = result;
-    return result;
+  Function _udpSocketSetReceiveBufferSizeResponseParamsResponder(
+      int requestId) {
+  return (network_error_mojom.NetworkError result) {
+      var result = new UdpSocketSetReceiveBufferSizeResponseParams();
+      result.result = result;
+      sendResponse(buildResponseWithId(
+          result,
+          _udpSocketMethodSetReceiveBufferSizeName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
   }
-  static UdpSocketNegotiateMaxPendingSendRequestsResponseParams _udpSocketNegotiateMaxPendingSendRequestsResponseParamsFactory(int actualSize) {
-    var result = new UdpSocketNegotiateMaxPendingSendRequestsResponseParams();
-    result.actualSize = actualSize;
-    return result;
+  Function _udpSocketNegotiateMaxPendingSendRequestsResponseParamsResponder(
+      int requestId) {
+  return (int actualSize) {
+      var result = new UdpSocketNegotiateMaxPendingSendRequestsResponseParams();
+      result.actualSize = actualSize;
+      sendResponse(buildResponseWithId(
+          result,
+          _udpSocketMethodNegotiateMaxPendingSendRequestsName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
   }
-  static UdpSocketSendToResponseParams _udpSocketSendToResponseParamsFactory(network_error_mojom.NetworkError result) {
-    var result = new UdpSocketSendToResponseParams();
-    result.result = result;
-    return result;
+  Function _udpSocketSendToResponseParamsResponder(
+      int requestId) {
+  return (network_error_mojom.NetworkError result) {
+      var result = new UdpSocketSendToResponseParams();
+      result.result = result;
+      sendResponse(buildResponseWithId(
+          result,
+          _udpSocketMethodSendToName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
   }
 
-  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 _udpSocketMethodAllowAddressReuseName:
-        var response = _impl.allowAddressReuse(_udpSocketAllowAddressReuseResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _udpSocketMethodAllowAddressReuseName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _udpSocketMethodAllowAddressReuseName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.allowAddressReuse(_udpSocketAllowAddressReuseResponseParamsResponder(message.header.requestId));
         break;
       case _udpSocketMethodBindName:
         var params = _UdpSocketBindParams.deserialize(
             message.payload);
-        var response = _impl.bind(params.addr,_udpSocketBindResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _udpSocketMethodBindName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _udpSocketMethodBindName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.bind(params.addr, _udpSocketBindResponseParamsResponder(message.header.requestId));
         break;
       case _udpSocketMethodConnectName:
         var params = _UdpSocketConnectParams.deserialize(
             message.payload);
-        var response = _impl.connect(params.remoteAddr,_udpSocketConnectResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _udpSocketMethodConnectName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _udpSocketMethodConnectName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.connect(params.remoteAddr, _udpSocketConnectResponseParamsResponder(message.header.requestId));
         break;
       case _udpSocketMethodSetSendBufferSizeName:
         var params = _UdpSocketSetSendBufferSizeParams.deserialize(
             message.payload);
-        var response = _impl.setSendBufferSize(params.size,_udpSocketSetSendBufferSizeResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _udpSocketMethodSetSendBufferSizeName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _udpSocketMethodSetSendBufferSizeName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.setSendBufferSize(params.size, _udpSocketSetSendBufferSizeResponseParamsResponder(message.header.requestId));
         break;
       case _udpSocketMethodSetReceiveBufferSizeName:
         var params = _UdpSocketSetReceiveBufferSizeParams.deserialize(
             message.payload);
-        var response = _impl.setReceiveBufferSize(params.size,_udpSocketSetReceiveBufferSizeResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _udpSocketMethodSetReceiveBufferSizeName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _udpSocketMethodSetReceiveBufferSizeName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.setReceiveBufferSize(params.size, _udpSocketSetReceiveBufferSizeResponseParamsResponder(message.header.requestId));
         break;
       case _udpSocketMethodNegotiateMaxPendingSendRequestsName:
         var params = _UdpSocketNegotiateMaxPendingSendRequestsParams.deserialize(
             message.payload);
-        var response = _impl.negotiateMaxPendingSendRequests(params.requestedSize,_udpSocketNegotiateMaxPendingSendRequestsResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _udpSocketMethodNegotiateMaxPendingSendRequestsName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _udpSocketMethodNegotiateMaxPendingSendRequestsName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.negotiateMaxPendingSendRequests(params.requestedSize, _udpSocketNegotiateMaxPendingSendRequestsResponseParamsResponder(message.header.requestId));
         break;
       case _udpSocketMethodReceiveMoreName:
         var params = _UdpSocketReceiveMoreParams.deserialize(
             message.payload);
         _impl.receiveMore(params.datagramNumber);
         break;
       case _udpSocketMethodSendToName:
         var params = _UdpSocketSendToParams.deserialize(
             message.payload);
-        var response = _impl.sendTo(params.destAddr,params.data,_udpSocketSendToResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _udpSocketMethodSendToName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _udpSocketMethodSendToName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.sendTo(params.destAddr, params.data, _udpSocketSendToResponseParamsResponder(message.header.requestId));
         break;
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
         break;
     }
-    return null;
   }
 
   UdpSocket get impl => _impl;
   set impl(UdpSocket d) {
     if (d == null) {
       throw new core.MojoApiError("$this: Cannot set a null implementation");
     }
     if (isBound && (_impl == null)) {
       beginHandlingEvents();
     }
@@ skipping 33 matching lines @@
       core.MojoHandle handle, [UdpSocket impl])
       : super(new _UdpSocketStubControl.fromHandle(handle, impl));
 
   static UdpSocketStub newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For UdpSocketStub"));
     return new UdpSocketStub.fromEndpoint(endpoint);
   }
 
 
-  dynamic allowAddressReuse([Function responseFactory = null]) {
-    return impl.allowAddressReuse(responseFactory);
+  void allowAddressReuse(void callback(network_error_mojom.NetworkError result)) {
+    return impl.allowAddressReuse(callback);
   }
-  dynamic bind(net_address_mojom.NetAddress addr,[Function responseFactory = null]) {
-    return impl.bind(addr,responseFactory);
+  void bind(net_address_mojom.NetAddress addr,void callback(network_error_mojom.NetworkError result, net_address_mojom.NetAddress boundAddr, UdpSocketReceiverInterfaceRequest receiver)) {
+    return impl.bind(addr,callback);
   }
-  dynamic connect(net_address_mojom.NetAddress remoteAddr,[Function responseFactory = null]) {
-    return impl.connect(remoteAddr,responseFactory);
+  void connect(net_address_mojom.NetAddress remoteAddr,void callback(network_error_mojom.NetworkError result, net_address_mojom.NetAddress localAddr, UdpSocketReceiverInterfaceRequest receiver)) {
+    return impl.connect(remoteAddr,callback);
   }
-  dynamic setSendBufferSize(int size,[Function responseFactory = null]) {
-    return impl.setSendBufferSize(size,responseFactory);
+  void setSendBufferSize(int size,void callback(network_error_mojom.NetworkError result)) {
+    return impl.setSendBufferSize(size,callback);
   }
-  dynamic setReceiveBufferSize(int size,[Function responseFactory = null]) {
-    return impl.setReceiveBufferSize(size,responseFactory);
+  void setReceiveBufferSize(int size,void callback(network_error_mojom.NetworkError result)) {
+    return impl.setReceiveBufferSize(size,callback);
   }
-  dynamic negotiateMaxPendingSendRequests(int requestedSize,[Function responseFactory = null]) {
-    return impl.negotiateMaxPendingSendRequests(requestedSize,responseFactory);
+  void negotiateMaxPendingSendRequests(int requestedSize,void callback(int actualSize)) {
+    return impl.negotiateMaxPendingSendRequests(requestedSize,callback);
   }
   void receiveMore(int datagramNumber) {
     return impl.receiveMore(datagramNumber);
   }
-  dynamic sendTo(net_address_mojom.NetAddress destAddr,List<int> data,[Function responseFactory = null]) {
-    return impl.sendTo(destAddr,data,responseFactory);
+  void sendTo(net_address_mojom.NetAddress destAddr,List<int> data,void callback(network_error_mojom.NetworkError result)) {
+    return impl.sendTo(destAddr,data,callback);
   }
 }
 
 const int _udpSocketReceiverMethodOnReceivedName = 0;
 
 class _UdpSocketReceiverServiceDescription 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 UdpSocketReceiver {
   static const String serviceName = null;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _UdpSocketReceiverServiceDescription();
     }
@@ skipping 131 matching lines @@
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
   _UdpSocketReceiverStubControl.unbound([this._impl]) : super.unbound();
 
   String get serviceName => UdpSocketReceiver.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 _udpSocketReceiverMethodOnReceivedName:
         var params = _UdpSocketReceiverOnReceivedParams.deserialize(
             message.payload);
         _impl.onReceived(params.result, params.srcAddr, params.data);
         break;
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
         break;
     }
-    return null;
   }
 
   UdpSocketReceiver get impl => _impl;
   set impl(UdpSocketReceiver d) {
     if (d == null) {
       throw new core.MojoApiError("$this: Cannot set a null implementation");
     }
     if (isBound && (_impl == null)) {
       beginHandlingEvents();
     }
@@ skipping 40 matching lines @@
   }
 
 
   void onReceived(network_error_mojom.NetworkError result, net_address_mojom.NetAddress srcAddr, List<int> data) {
     return impl.onReceived(result, srcAddr, data);
   }
 }