Dart: Futures -> Callbacks.

mojo/public/tools/bindings/generators/dart_templates/interface_definition.tmpl

 {%- for method in interface.methods %}
 const int _{{interface|name|lower_camel}}Method{{method|name|upper_camel}}Name = {{method.ordinal}};
 {%- endfor %}
 
 {#--- Interface Enums #}
 {%- from "enum_definition.tmpl" import enum_def -%}
 {%- for enum in interface.enums %}
   {{ enum_def(enum, typepkg, package) }}
 {%-  endfor %}
 
 class _{{interface|name}}ServiceDescription implements {{descpkg}}ServiceDescription {
 {%- if should_gen_mojom_types and interface.service_name %}
-  dynamic getTopLevelInterface([Function responseFactory]){
+  void getTopLevelInterface(Function responder){
     var interfaceTypeKey = getRuntimeTypeInfo().services["{{interface.service_name}}"];
     var userDefinedType = getAllMojomTypeDefinitions()[interfaceTypeKey];
-    return responseFactory(userDefinedType.interfaceType);
+    responder(userDefinedType.interfaceType);
   }
 
-  dynamic getTypeDefinition(String typeKey, [Function responseFactory]) =>
-    responseFactory(getAllMojomTypeDefinitions()[typeKey]);
+  void getTypeDefinition(String typeKey, Function responder) {
+    responder(getAllMojomTypeDefinitions()[typeKey]);
+  }
 
-  dynamic getAllTypeDefinitions([Function responseFactory]) =>
-    responseFactory(getAllMojomTypeDefinitions());
+  void getAllTypeDefinitions(Function responder) {
+    responder(getAllMojomTypeDefinitions());
+  }
 {%- else %}
-  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);
+  }
 {%- endif %}
 }
 
 abstract class {{interface|name}} {
 {%- if interface.service_name %}
   static const String serviceName = "{{interface.service_name}}";
 {%- else %}
   static const String serviceName = null;
 {%- endif %}
 
@@ skipping 18 matching lines @@
   }
 
 {%- for method in interface.methods %}
 {%- if method.response_parameters == None %}
   void {{method|name}}(
     {%- for parameter in method.parameters -%}
       {{parameter.kind|dart_type}} {{parameter|name}}{% if not loop.last %}, {% endif %}
     {%- endfor -%}
     );
 {%- else %}
-  dynamic {{method|name}}(
+  void {{method|name}}(
   {%- for parameter in method.parameters -%}
     {{parameter.kind|dart_type}} {{parameter|name}},
   {%- endfor -%}
-    [Function responseFactory = null]);
+     void callback(
+      {%- for param in method.response_parameters -%}
+        {{param.kind|dart_type}} {{param|name}}{% if not loop.last %}, {% endif %}
+      {%- endfor -%}
+     ));
 {%- endif %}
 {%- endfor %}
 
 {#--- Interface Constants #}
 {%- for constant in interface.constants %}
   static const {{constant.kind|dart_type}} {{constant|name}} = {{constant.resolved_value}};
 {%-   endfor %}
 }
 
 abstract class {{interface|name}}Interface
@@ skipping 32 matching lines @@
 {%- for method in interface.methods %}
 {%- if method.response_parameters != None %}
 {%- set response_struct = method.response_param_struct %}
       case _{{interface|name|lower_camel}}Method{{method|name|upper_camel}}Name:
         var r = {{response_struct|name}}.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(
+          {%- for param in method.response_parameters -%}
+            r.{{param|name}} {% if not loop.last %}, {% endif %}
+          {%- endfor -%}
+        );
         break;
 {%- endif %}
 {%- endfor %}
       default:
         proxyError("Unexpected message type: ${message.header.type}");
         close(immediate: true);
         break;
     }
   }
 
@@ skipping 44 matching lines @@
     }
     var params = new {{request_struct|name}}();
 {%- for parameter in method.parameters %}
     params.{{parameter|name}} = {{parameter|name}};
 {%- endfor %}
     ctrl.sendMessage(params,
         _{{interface|name|lower_camel}}Method{{method|name|upper_camel}}Name);
   }
 {%- else %}
 {%- set request_struct = method.param_struct %}
-  dynamic {{method|name}}(
+  void {{method|name}}(
 {%- for parameter in method.parameters -%}
     {{parameter.kind|dart_type}} {{parameter|name}},
 {%- endfor -%}
-    [Function responseFactory = null]) {
+    void callback(
+      {%- for param in method.response_parameters -%}
+        {{param.kind|dart_type}} {{param|name}}{% if not loop.last %}, {% endif %}
+      {%- endfor -%}
+    )) {
     var params = new {{request_struct|name}}();
 {%- for parameter in method.parameters %}
     params.{{parameter|name}} = {{parameter|name}};
 {%- endfor %}
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _{{interface|name|lower_camel}}Method{{method|name|upper_camel}}Name,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
   }
 {%- endif %}
 {%- endfor %}
 }
 
 class _{{interface|name}}StubControl
     extends bindings.StubMessageHandler
     implements bindings.StubControl<{{interface|name}}> {
   {{interface|name}} _impl;
 
   _{{interface|name}}StubControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [{{interface|name}} impl])
       : super.fromEndpoint(endpoint, autoBegin: impl != null) {
     _impl = impl;
   }
 
   _{{interface|name}}StubControl.fromHandle(
       core.MojoHandle handle, [{{interface|name}} impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
   _{{interface|name}}StubControl.unbound([this._impl]) : super.unbound();
 
   String get serviceName => {{interface|name}}.serviceName;
 
 {% for method in interface.methods %}
 {%- if method.response_parameters != None %}
 {%- set response_struct = method.response_param_struct %}
-  {{response_struct|name}} _{{response_struct|name|lower_camel}}Factory(
-    {%- for param in method.response_parameters -%}
-      {{param.kind|dart_type}} {{param|name}}{% if not loop.last %}, {% endif %}
-    {%- endfor -%}
-  ) {
-    var result = new {{response_struct|name}}();
-    {%- for param in method.response_parameters %}
-    result.{{param|name}} = {{param|name}};
-    {%- endfor %}
-    return result;
+  Function _{{response_struct|name|lower_camel}}Responder(
+      int requestId) {
+  return (
+      {%- for param in method.response_parameters -%}
+        {{param.kind|dart_type}} {{param|name}}{% if not loop.last %}, {% endif %}
+      {%- endfor -%}
+    ) {
+      var result = new {{response_struct|name}}();
+      {%- for param in method.response_parameters %}
+      result.{{param|name}} = {{param|name}};
+      {%- endfor %}
+      sendResponse(buildResponseWithId(
+          result,
+          _{{interface|name|lower_camel}}Method{{method|name|upper_camel}}Name,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
   }
 {%- endif %}
 {%- endfor %}
 
-  dynamic handleMessage(bindings.ServiceMessage message) {
+  void handleMessage(bindings.ServiceMessage message) {
     if (bindings.ControlMessageHandler.isControlMessage(message)) {
-      return bindings.ControlMessageHandler.handleMessage(this,
-                                                          {{interface.version}},
-                                                          message);
+      bindings.ControlMessageHandler.handleMessage(
+          this, {{interface.version}}, message);
+      return;
     }
     if (_impl == null) {
       throw new core.MojoApiError("$this has no implementation set");
     }
     switch (message.header.type) {
 {%- for method in interface.methods %}
 {%- set request_struct = method.param_struct %}
       case _{{interface|name|lower_camel}}Method{{method|name|upper_camel}}Name:
 {%- if method.parameters %}
         var params = {{request_struct|name}}.deserialize(
             message.payload);
 {%- endif %}
 {%- if method.response_parameters == None %}
         _impl.{{method|name}}(
           {%- for parameter in method.parameters -%}
               params.{{parameter|name}}{% if not loop.last %}, {% endif %}
           {%- endfor -%}
         );
 {%- else %}
 {%- set response_struct = method.response_param_struct %}
-        var response = _impl.{{method|name}}(
+        _impl.{{method|name}}(
           {%- for parameter in method.parameters -%}
-              params.{{parameter|name}},
-          {%- endfor -%}
-          _{{response_struct|name|lower_camel}}Factory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _{{interface|name|lower_camel}}Method{{method|name|upper_camel}}Name,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _{{interface|name|lower_camel}}Method{{method|name|upper_camel}}Name,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+              params.{{parameter|name}}, {% endfor -%}
+          _{{response_struct|name|lower_camel}}Responder(message.header.requestId));
 {%- endif %}
         break;
 {%- endfor %}
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
         break;
     }
-    return null;
   }
 
   {{interface|name}} get impl => _impl;
   set impl({{interface|name}} d) {
     if (d == null) {
       throw new core.MojoApiError("$this: Cannot set a null implementation");
     }
     if (isBound && (_impl == null)) {
       beginHandlingEvents();
     }
@@ skipping 46 matching lines @@
     {{parameter.kind|dart_type}} {{parameter|name}}{% if not loop.last %}, {% endif %}
 {%- endfor -%}
   ) {
     return impl.{{method|name}}(
 {%- for parameter in method.parameters -%}
     {{parameter|name}}{% if not loop.last %}, {% endif %}
 {%- endfor -%}
     );
   }
 {%- else %}
-  dynamic {{method|name}}(
+  void {{method|name}}(
 {%- for parameter in method.parameters -%}
     {{parameter.kind|dart_type}} {{parameter|name}},
 {%- endfor -%}
-    [Function responseFactory = null]) {
+    void callback(
+      {%- for param in method.response_parameters -%}
+        {{param.kind|dart_type}} {{param|name}}{% if not loop.last %}, {% endif %}
+      {%- endfor -%}
+    )) {
     return impl.{{method|name}}(
 {%- for parameter in method.parameters -%}
     {{parameter|name}},
 {%- endfor -%}
-    responseFactory);
+    callback);
   }
 {%- endif %}
 {%- endfor %}
 }