Dart: Futures -> Callbacks.

mojo/dart/packages/mojo_services/lib/mojo/files/file.mojom.dart

 // WARNING: DO NOT EDIT. This file was generated by a program.
 // See $MOJO_SDK/tools/bindings/mojom_bindings_generator.py.
 
 library file_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/files/types.mojom.dart' as types_mojom;
 
 
 
 class _FileCloseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   _FileCloseParams() : super(kVersions.last.size);
 
+  _FileCloseParams.init(
+  ) : super(kVersions.last.size);
+
   static _FileCloseParams 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 _FileCloseParams decode(bindings.Decoder decoder0) {
@@ skipping 39 matching lines @@
 
 
 class FileCloseResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   types_mojom.Error err = null;
 
   FileCloseResponseParams() : super(kVersions.last.size);
 
+  FileCloseResponseParams.init(
+    types_mojom.Error this.err
+  ) : super(kVersions.last.size);
+
   static FileCloseResponseParams 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 FileCloseResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 58 matching lines @@
 class _FileReadParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   int numBytesToRead = 0;
   types_mojom.Whence whence = null;
   int offset = 0;
 
   _FileReadParams() : super(kVersions.last.size);
 
+  _FileReadParams.init(
+    int this.numBytesToRead, 
+    types_mojom.Whence this.whence, 
+    int this.offset
+  ) : super(kVersions.last.size);
+
   static _FileReadParams 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 _FileReadParams decode(bindings.Decoder decoder0) {
@@ skipping 83 matching lines @@
 
 class FileReadResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   types_mojom.Error error = null;
   List<int> bytesRead = null;
 
   FileReadResponseParams() : super(kVersions.last.size);
 
+  FileReadResponseParams.init(
+    types_mojom.Error this.error, 
+    List<int> this.bytesRead
+  ) : super(kVersions.last.size);
+
   static FileReadResponseParams 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 FileReadResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 71 matching lines @@
 class _FileWriteParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(32, 0)
   ];
   List<int> bytesToWrite = null;
   int offset = 0;
   types_mojom.Whence whence = null;
 
   _FileWriteParams() : super(kVersions.last.size);
 
+  _FileWriteParams.init(
+    List<int> this.bytesToWrite, 
+    int this.offset, 
+    types_mojom.Whence this.whence
+  ) : super(kVersions.last.size);
+
   static _FileWriteParams 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 _FileWriteParams decode(bindings.Decoder decoder0) {
@@ skipping 83 matching lines @@
 
 class FileWriteResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   types_mojom.Error error = null;
   int numBytesWritten = 0;
 
   FileWriteResponseParams() : super(kVersions.last.size);
 
+  FileWriteResponseParams.init(
+    types_mojom.Error this.error, 
+    int this.numBytesWritten
+  ) : super(kVersions.last.size);
+
   static FileWriteResponseParams 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 FileWriteResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 72 matching lines @@
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(32, 0)
   ];
   core.MojoDataPipeProducer source = null;
   types_mojom.Whence whence = null;
   int offset = 0;
   int numBytesToRead = 0;
 
   _FileReadToStreamParams() : super(kVersions.last.size);
 
+  _FileReadToStreamParams.init(
+    core.MojoDataPipeProducer this.source, 
+    types_mojom.Whence this.whence, 
+    int this.offset, 
+    int this.numBytesToRead
+  ) : super(kVersions.last.size);
+
   static _FileReadToStreamParams 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 _FileReadToStreamParams decode(bindings.Decoder decoder0) {
@@ skipping 91 matching lines @@
 
 
 class FileReadToStreamResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   types_mojom.Error error = null;
 
   FileReadToStreamResponseParams() : super(kVersions.last.size);
 
+  FileReadToStreamResponseParams.init(
+    types_mojom.Error this.error
+  ) : super(kVersions.last.size);
+
   static FileReadToStreamResponseParams 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 FileReadToStreamResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 58 matching lines @@
 class _FileWriteFromStreamParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   core.MojoDataPipeConsumer sink = null;
   types_mojom.Whence whence = null;
   int offset = 0;
 
   _FileWriteFromStreamParams() : super(kVersions.last.size);
 
+  _FileWriteFromStreamParams.init(
+    core.MojoDataPipeConsumer this.sink, 
+    types_mojom.Whence this.whence, 
+    int this.offset
+  ) : super(kVersions.last.size);
+
   static _FileWriteFromStreamParams 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 _FileWriteFromStreamParams decode(bindings.Decoder decoder0) {
@@ skipping 79 matching lines @@
 
 
 class FileWriteFromStreamResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   types_mojom.Error error = null;
 
   FileWriteFromStreamResponseParams() : super(kVersions.last.size);
 
+  FileWriteFromStreamResponseParams.init(
+    types_mojom.Error this.error
+  ) : super(kVersions.last.size);
+
   static FileWriteFromStreamResponseParams 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 FileWriteFromStreamResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 55 matching lines @@
 }
 
 
 class _FileTellParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   _FileTellParams() : super(kVersions.last.size);
 
+  _FileTellParams.init(
+  ) : super(kVersions.last.size);
+
   static _FileTellParams 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 _FileTellParams decode(bindings.Decoder decoder0) {
@@ skipping 40 matching lines @@
 
 class FileTellResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   types_mojom.Error error = null;
   int position = 0;
 
   FileTellResponseParams() : super(kVersions.last.size);
 
+  FileTellResponseParams.init(
+    types_mojom.Error this.error, 
+    int this.position
+  ) : super(kVersions.last.size);
+
   static FileTellResponseParams 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 FileTellResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 70 matching lines @@
 
 class _FileSeekParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   int offset = 0;
   types_mojom.Whence whence = null;
 
   _FileSeekParams() : super(kVersions.last.size);
 
+  _FileSeekParams.init(
+    int this.offset, 
+    types_mojom.Whence this.whence
+  ) : super(kVersions.last.size);
+
   static _FileSeekParams 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 _FileSeekParams decode(bindings.Decoder decoder0) {
@@ skipping 70 matching lines @@
 
 class FileSeekResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   types_mojom.Error error = null;
   int position = 0;
 
   FileSeekResponseParams() : super(kVersions.last.size);
 
+  FileSeekResponseParams.init(
+    types_mojom.Error this.error, 
+    int this.position
+  ) : super(kVersions.last.size);
+
   static FileSeekResponseParams 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 FileSeekResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 68 matching lines @@
 }
 
 
 class _FileStatParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   _FileStatParams() : super(kVersions.last.size);
 
+  _FileStatParams.init(
+  ) : super(kVersions.last.size);
+
   static _FileStatParams 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 _FileStatParams decode(bindings.Decoder decoder0) {
@@ skipping 40 matching lines @@
 
 class FileStatResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   types_mojom.Error error = null;
   types_mojom.FileInformation fileInformation = null;
 
   FileStatResponseParams() : super(kVersions.last.size);
 
+  FileStatResponseParams.init(
+    types_mojom.Error this.error, 
+    types_mojom.FileInformation this.fileInformation
+  ) : super(kVersions.last.size);
+
   static FileStatResponseParams 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 FileStatResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 70 matching lines @@
 
 
 class _FileTruncateParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   int size = 0;
 
   _FileTruncateParams() : super(kVersions.last.size);
 
+  _FileTruncateParams.init(
+    int this.size
+  ) : super(kVersions.last.size);
+
   static _FileTruncateParams 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 _FileTruncateParams decode(bindings.Decoder decoder0) {
@@ skipping 52 matching lines @@
 
 
 class FileTruncateResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   types_mojom.Error error = null;
 
   FileTruncateResponseParams() : super(kVersions.last.size);
 
+  FileTruncateResponseParams.init(
+    types_mojom.Error this.error
+  ) : super(kVersions.last.size);
+
   static FileTruncateResponseParams 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 FileTruncateResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 57 matching lines @@
 
 class _FileTouchParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   types_mojom.TimespecOrNow atime = null;
   types_mojom.TimespecOrNow mtime = null;
 
   _FileTouchParams() : super(kVersions.last.size);
 
+  _FileTouchParams.init(
+    types_mojom.TimespecOrNow this.atime, 
+    types_mojom.TimespecOrNow this.mtime
+  ) : super(kVersions.last.size);
+
   static _FileTouchParams 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 _FileTouchParams decode(bindings.Decoder decoder0) {
@@ skipping 67 matching lines @@
 
 
 class FileTouchResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   types_mojom.Error error = null;
 
   FileTouchResponseParams() : super(kVersions.last.size);
 
+  FileTouchResponseParams.init(
+    types_mojom.Error this.error
+  ) : super(kVersions.last.size);
+
   static FileTouchResponseParams 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 FileTouchResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 56 matching lines @@
 
 
 class _FileDupParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   FileInterfaceRequest file = null;
 
   _FileDupParams() : super(kVersions.last.size);
 
+  _FileDupParams.init(
+    FileInterfaceRequest this.file
+  ) : super(kVersions.last.size);
+
   static _FileDupParams 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 _FileDupParams decode(bindings.Decoder decoder0) {
@@ skipping 51 matching lines @@
 
 
 class FileDupResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   types_mojom.Error error = null;
 
   FileDupResponseParams() : super(kVersions.last.size);
 
+  FileDupResponseParams.init(
+    types_mojom.Error this.error
+  ) : super(kVersions.last.size);
+
   static FileDupResponseParams 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 FileDupResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 57 matching lines @@
 
 class _FileReopenParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   FileInterfaceRequest file = null;
   int openFlags = 0;
 
   _FileReopenParams() : super(kVersions.last.size);
 
+  _FileReopenParams.init(
+    FileInterfaceRequest this.file, 
+    int this.openFlags
+  ) : super(kVersions.last.size);
+
   static _FileReopenParams 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 _FileReopenParams decode(bindings.Decoder decoder0) {
@@ skipping 63 matching lines @@
 
 
 class FileReopenResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   types_mojom.Error error = null;
 
   FileReopenResponseParams() : super(kVersions.last.size);
 
+  FileReopenResponseParams.init(
+    types_mojom.Error this.error
+  ) : super(kVersions.last.size);
+
   static FileReopenResponseParams 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 FileReopenResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 55 matching lines @@
 }
 
 
 class _FileAsBufferParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   _FileAsBufferParams() : super(kVersions.last.size);
 
+  _FileAsBufferParams.init(
+  ) : super(kVersions.last.size);
+
   static _FileAsBufferParams 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 _FileAsBufferParams decode(bindings.Decoder decoder0) {
@@ skipping 40 matching lines @@
 
 class FileAsBufferResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   types_mojom.Error error = null;
   core.MojoSharedBuffer buffer = null;
 
   FileAsBufferResponseParams() : super(kVersions.last.size);
 
+  FileAsBufferResponseParams.init(
+    types_mojom.Error this.error, 
+    core.MojoSharedBuffer this.buffer
+  ) : super(kVersions.last.size);
+
   static FileAsBufferResponseParams 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 FileAsBufferResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 68 matching lines @@
 
 class _FileIoctlParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   int request = 0;
   List<int> inValues = null;
 
   _FileIoctlParams() : super(kVersions.last.size);
 
+  _FileIoctlParams.init(
+    int this.request, 
+    List<int> this.inValues
+  ) : super(kVersions.last.size);
+
   static _FileIoctlParams 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 _FileIoctlParams decode(bindings.Decoder decoder0) {
@@ skipping 66 matching lines @@
 
 class FileIoctlResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   types_mojom.Error error = null;
   List<int> outValues = null;
 
   FileIoctlResponseParams() : super(kVersions.last.size);
 
+  FileIoctlResponseParams.init(
+    types_mojom.Error this.error, 
+    List<int> this.outValues
+  ) : super(kVersions.last.size);
+
   static FileIoctlResponseParams 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 FileIoctlResponseParams decode(bindings.Decoder decoder0) {
@@ skipping 76 matching lines @@
 const int _fileMethodSeekName = 6;
 const int _fileMethodStatName = 7;
 const int _fileMethodTruncateName = 8;
 const int _fileMethodTouchName = 9;
 const int _fileMethodDupName = 10;
 const int _fileMethodReopenName = 11;
 const int _fileMethodAsBufferName = 12;
 const int _fileMethodIoctlName = 13;
 
 class _FileServiceDescription 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 File {
   static const String serviceName = null;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _FileServiceDescription();
     }
     return _cachedServiceDescription;
   }
 
   static FileProxy connectToService(
       bindings.ServiceConnector s, String url, [String serviceName]) {
     FileProxy p = new FileProxy.unbound();
     String name = serviceName ?? File.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 close_([Function responseFactory = null]);
-  dynamic read(int numBytesToRead,int offset,types_mojom.Whence whence,[Function responseFactory = null]);
-  dynamic write(List<int> bytesToWrite,int offset,types_mojom.Whence whence,[Function responseFactory = null]);
-  dynamic readToStream(core.MojoDataPipeProducer source,int offset,types_mojom.Whence whence,int numBytesToRead,[Function responseFactory = null]);
-  dynamic writeFromStream(core.MojoDataPipeConsumer sink,int offset,types_mojom.Whence whence,[Function responseFactory = null]);
-  dynamic tell([Function responseFactory = null]);
-  dynamic seek(int offset,types_mojom.Whence whence,[Function responseFactory = null]);
-  dynamic stat([Function responseFactory = null]);
-  dynamic truncate(int size,[Function responseFactory = null]);
-  dynamic touch(types_mojom.TimespecOrNow atime,types_mojom.TimespecOrNow mtime,[Function responseFactory = null]);
-  dynamic dup(FileInterfaceRequest file,[Function responseFactory = null]);
-  dynamic reopen(FileInterfaceRequest file,int openFlags,[Function responseFactory = null]);
-  dynamic asBuffer([Function responseFactory = null]);
-  dynamic ioctl(int request,List<int> inValues,[Function responseFactory = null]);
+  void close_(void callback(types_mojom.Error err));
+  void read(int numBytesToRead,int offset,types_mojom.Whence whence,void callback(types_mojom.Error error, List<int> bytesRead));
+  void write(List<int> bytesToWrite,int offset,types_mojom.Whence whence,void callback(types_mojom.Error error, int numBytesWritten));
+  void readToStream(core.MojoDataPipeProducer source,int offset,types_mojom.Whence whence,int numBytesToRead,void callback(types_mojom.Error error));
+  void writeFromStream(core.MojoDataPipeConsumer sink,int offset,types_mojom.Whence whence,void callback(types_mojom.Error error));
+  void tell(void callback(types_mojom.Error error, int position));
+  void seek(int offset,types_mojom.Whence whence,void callback(types_mojom.Error error, int position));
+  void stat(void callback(types_mojom.Error error, types_mojom.FileInformation fileInformation));
+  void truncate(int size,void callback(types_mojom.Error error));
+  void touch(types_mojom.TimespecOrNow atime,types_mojom.TimespecOrNow mtime,void callback(types_mojom.Error error));
+  void dup(FileInterfaceRequest file,void callback(types_mojom.Error error));
+  void reopen(FileInterfaceRequest file,int openFlags,void callback(types_mojom.Error error));
+  void asBuffer(void callback(types_mojom.Error error, core.MojoSharedBuffer buffer));
+  void ioctl(int request,List<int> inValues,void callback(types_mojom.Error error, List<int> outValues));
 }
 
 abstract class FileInterface
     implements bindings.MojoInterface<File>,
                File {
   factory FileInterface([File impl]) =>
       new FileStub.unbound(impl);
 
   factory FileInterface.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint,
@@ skipping 29 matching lines @@
 
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       case _fileMethodCloseName:
         var r = FileCloseResponseParams.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.err );
         break;
       case _fileMethodReadName:
         var r = FileReadResponseParams.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.error , r.bytesRead );
         break;
       case _fileMethodWriteName:
         var r = FileWriteResponseParams.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.error , r.numBytesWritten );
         break;
       case _fileMethodReadToStreamName:
         var r = FileReadToStreamResponseParams.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.error );
         break;
       case _fileMethodWriteFromStreamName:
         var r = FileWriteFromStreamResponseParams.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.error );
         break;
       case _fileMethodTellName:
         var r = FileTellResponseParams.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.error , r.position );
         break;
       case _fileMethodSeekName:
         var r = FileSeekResponseParams.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.error , r.position );
         break;
       case _fileMethodStatName:
         var r = FileStatResponseParams.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.error , r.fileInformation );
         break;
       case _fileMethodTruncateName:
         var r = FileTruncateResponseParams.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.error );
         break;
       case _fileMethodTouchName:
         var r = FileTouchResponseParams.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.error );
         break;
       case _fileMethodDupName:
         var r = FileDupResponseParams.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.error );
         break;
       case _fileMethodReopenName:
         var r = FileReopenResponseParams.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.error );
         break;
       case _fileMethodAsBufferName:
         var r = FileAsBufferResponseParams.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.error , r.buffer );
         break;
       case _fileMethodIoctlName:
         var r = FileIoctlResponseParams.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.error , r.outValues );
         break;
       default:
         proxyError("Unexpected message type: ${message.header.type}");
         close(immediate: true);
         break;
     }
   }
 
   @override
   String toString() {
@@ skipping 24 matching lines @@
     return newMockedProxy;
   }
 
   static FileProxy newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For FileProxy"));
     return new FileProxy.fromEndpoint(endpoint);
   }
 
 
-  dynamic close_([Function responseFactory = null]) {
-    if (impl != null) {
-      return new Future(() => impl.close_(_FileStubControl._fileCloseResponseParamsFactory));
+  void close_(void callback(types_mojom.Error err)) {
+    if (impl != null) {
+      impl.close_(callback);
+      return;
     }
     var params = new _FileCloseParams();
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _fileMethodCloseName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
-  }
-  dynamic read(int numBytesToRead,int offset,types_mojom.Whence whence,[Function responseFactory = null]) {
-    if (impl != null) {
-      return new Future(() => impl.read(numBytesToRead,offset,whence,_FileStubControl._fileReadResponseParamsFactory));
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
+  }
+  void read(int numBytesToRead,int offset,types_mojom.Whence whence,void callback(types_mojom.Error error, List<int> bytesRead)) {
+    if (impl != null) {
+      impl.read(numBytesToRead,offset,whence,callback);
+      return;
     }
     var params = new _FileReadParams();
     params.numBytesToRead = numBytesToRead;
     params.offset = offset;
     params.whence = whence;
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _fileMethodReadName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
-  }
-  dynamic write(List<int> bytesToWrite,int offset,types_mojom.Whence whence,[Function responseFactory = null]) {
-    if (impl != null) {
-      return new Future(() => impl.write(bytesToWrite,offset,whence,_FileStubControl._fileWriteResponseParamsFactory));
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
+  }
+  void write(List<int> bytesToWrite,int offset,types_mojom.Whence whence,void callback(types_mojom.Error error, int numBytesWritten)) {
+    if (impl != null) {
+      impl.write(bytesToWrite,offset,whence,callback);
+      return;
     }
     var params = new _FileWriteParams();
     params.bytesToWrite = bytesToWrite;
     params.offset = offset;
     params.whence = whence;
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _fileMethodWriteName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
-  }
-  dynamic readToStream(core.MojoDataPipeProducer source,int offset,types_mojom.Whence whence,int numBytesToRead,[Function responseFactory = null]) {
-    if (impl != null) {
-      return new Future(() => impl.readToStream(source,offset,whence,numBytesToRead,_FileStubControl._fileReadToStreamResponseParamsFactory));
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
+  }
+  void readToStream(core.MojoDataPipeProducer source,int offset,types_mojom.Whence whence,int numBytesToRead,void callback(types_mojom.Error error)) {
+    if (impl != null) {
+      impl.readToStream(source,offset,whence,numBytesToRead,callback);
+      return;
     }
     var params = new _FileReadToStreamParams();
     params.source = source;
     params.offset = offset;
     params.whence = whence;
     params.numBytesToRead = numBytesToRead;
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _fileMethodReadToStreamName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
-  }
-  dynamic writeFromStream(core.MojoDataPipeConsumer sink,int offset,types_mojom.Whence whence,[Function responseFactory = null]) {
-    if (impl != null) {
-      return new Future(() => impl.writeFromStream(sink,offset,whence,_FileStubControl._fileWriteFromStreamResponseParamsFactory));
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
+  }
+  void writeFromStream(core.MojoDataPipeConsumer sink,int offset,types_mojom.Whence whence,void callback(types_mojom.Error error)) {
+    if (impl != null) {
+      impl.writeFromStream(sink,offset,whence,callback);
+      return;
     }
     var params = new _FileWriteFromStreamParams();
     params.sink = sink;
     params.offset = offset;
     params.whence = whence;
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _fileMethodWriteFromStreamName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
-  }
-  dynamic tell([Function responseFactory = null]) {
-    if (impl != null) {
-      return new Future(() => impl.tell(_FileStubControl._fileTellResponseParamsFactory));
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
+  }
+  void tell(void callback(types_mojom.Error error, int position)) {
+    if (impl != null) {
+      impl.tell(callback);
+      return;
     }
     var params = new _FileTellParams();
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _fileMethodTellName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
-  }
-  dynamic seek(int offset,types_mojom.Whence whence,[Function responseFactory = null]) {
-    if (impl != null) {
-      return new Future(() => impl.seek(offset,whence,_FileStubControl._fileSeekResponseParamsFactory));
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
+  }
+  void seek(int offset,types_mojom.Whence whence,void callback(types_mojom.Error error, int position)) {
+    if (impl != null) {
+      impl.seek(offset,whence,callback);
+      return;
     }
     var params = new _FileSeekParams();
     params.offset = offset;
     params.whence = whence;
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _fileMethodSeekName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
-  }
-  dynamic stat([Function responseFactory = null]) {
-    if (impl != null) {
-      return new Future(() => impl.stat(_FileStubControl._fileStatResponseParamsFactory));
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
+  }
+  void stat(void callback(types_mojom.Error error, types_mojom.FileInformation fileInformation)) {
+    if (impl != null) {
+      impl.stat(callback);
+      return;
     }
     var params = new _FileStatParams();
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _fileMethodStatName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
-  }
-  dynamic truncate(int size,[Function responseFactory = null]) {
-    if (impl != null) {
-      return new Future(() => impl.truncate(size,_FileStubControl._fileTruncateResponseParamsFactory));
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
+  }
+  void truncate(int size,void callback(types_mojom.Error error)) {
+    if (impl != null) {
+      impl.truncate(size,callback);
+      return;
     }
     var params = new _FileTruncateParams();
     params.size = size;
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _fileMethodTruncateName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
-  }
-  dynamic touch(types_mojom.TimespecOrNow atime,types_mojom.TimespecOrNow mtime,[Function responseFactory = null]) {
-    if (impl != null) {
-      return new Future(() => impl.touch(atime,mtime,_FileStubControl._fileTouchResponseParamsFactory));
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
+  }
+  void touch(types_mojom.TimespecOrNow atime,types_mojom.TimespecOrNow mtime,void callback(types_mojom.Error error)) {
+    if (impl != null) {
+      impl.touch(atime,mtime,callback);
+      return;
     }
     var params = new _FileTouchParams();
     params.atime = atime;
     params.mtime = mtime;
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _fileMethodTouchName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
-  }
-  dynamic dup(FileInterfaceRequest file,[Function responseFactory = null]) {
-    if (impl != null) {
-      return new Future(() => impl.dup(file,_FileStubControl._fileDupResponseParamsFactory));
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
+  }
+  void dup(FileInterfaceRequest file,void callback(types_mojom.Error error)) {
+    if (impl != null) {
+      impl.dup(file,callback);
+      return;
     }
     var params = new _FileDupParams();
     params.file = file;
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _fileMethodDupName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
-  }
-  dynamic reopen(FileInterfaceRequest file,int openFlags,[Function responseFactory = null]) {
-    if (impl != null) {
-      return new Future(() => impl.reopen(file,openFlags,_FileStubControl._fileReopenResponseParamsFactory));
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
+  }
+  void reopen(FileInterfaceRequest file,int openFlags,void callback(types_mojom.Error error)) {
+    if (impl != null) {
+      impl.reopen(file,openFlags,callback);
+      return;
     }
     var params = new _FileReopenParams();
     params.file = file;
     params.openFlags = openFlags;
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _fileMethodReopenName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
-  }
-  dynamic asBuffer([Function responseFactory = null]) {
-    if (impl != null) {
-      return new Future(() => impl.asBuffer(_FileStubControl._fileAsBufferResponseParamsFactory));
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
+  }
+  void asBuffer(void callback(types_mojom.Error error, core.MojoSharedBuffer buffer)) {
+    if (impl != null) {
+      impl.asBuffer(callback);
+      return;
     }
     var params = new _FileAsBufferParams();
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _fileMethodAsBufferName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
-  }
-  dynamic ioctl(int request,List<int> inValues,[Function responseFactory = null]) {
-    if (impl != null) {
-      return new Future(() => impl.ioctl(request,inValues,_FileStubControl._fileIoctlResponseParamsFactory));
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
+  }
+  void ioctl(int request,List<int> inValues,void callback(types_mojom.Error error, List<int> outValues)) {
+    if (impl != null) {
+      impl.ioctl(request,inValues,callback);
+      return;
     }
     var params = new _FileIoctlParams();
     params.request = request;
     params.inValues = inValues;
-    return ctrl.sendMessageWithRequestId(
+    ctrl.sendMessageWithRequestId(
         params,
         _fileMethodIoctlName,
         -1,
-        bindings.MessageHeader.kMessageExpectsResponse);
+        bindings.MessageHeader.kMessageExpectsResponse,
+        callback);
   }
 }
 
 class _FileStubControl
     extends bindings.StubMessageHandler
     implements bindings.StubControl<File> {
   File _impl;
 
   _FileStubControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [File impl])
       : super.fromEndpoint(endpoint, autoBegin: impl != null) {
     _impl = impl;
   }
 
   _FileStubControl.fromHandle(
       core.MojoHandle handle, [File impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
   _FileStubControl.unbound([this._impl]) : super.unbound();
 
   String get serviceName => File.serviceName;
 
 
-  static FileCloseResponseParams _fileCloseResponseParamsFactory(types_mojom.Error err) {
-    var result = new FileCloseResponseParams();
-    result.err = err;
-    return result;
-  }
-  static FileReadResponseParams _fileReadResponseParamsFactory(types_mojom.Error error, List<int> bytesRead) {
-    var result = new FileReadResponseParams();
-    result.error = error;
-    result.bytesRead = bytesRead;
-    return result;
-  }
-  static FileWriteResponseParams _fileWriteResponseParamsFactory(types_mojom.Error error, int numBytesWritten) {
-    var result = new FileWriteResponseParams();
-    result.error = error;
-    result.numBytesWritten = numBytesWritten;
-    return result;
-  }
-  static FileReadToStreamResponseParams _fileReadToStreamResponseParamsFactory(types_mojom.Error error) {
-    var result = new FileReadToStreamResponseParams();
-    result.error = error;
-    return result;
-  }
-  static FileWriteFromStreamResponseParams _fileWriteFromStreamResponseParamsFactory(types_mojom.Error error) {
-    var result = new FileWriteFromStreamResponseParams();
-    result.error = error;
-    return result;
-  }
-  static FileTellResponseParams _fileTellResponseParamsFactory(types_mojom.Error error, int position) {
-    var result = new FileTellResponseParams();
-    result.error = error;
-    result.position = position;
-    return result;
-  }
-  static FileSeekResponseParams _fileSeekResponseParamsFactory(types_mojom.Error error, int position) {
-    var result = new FileSeekResponseParams();
-    result.error = error;
-    result.position = position;
-    return result;
-  }
-  static FileStatResponseParams _fileStatResponseParamsFactory(types_mojom.Error error, types_mojom.FileInformation fileInformation) {
-    var result = new FileStatResponseParams();
-    result.error = error;
-    result.fileInformation = fileInformation;
-    return result;
-  }
-  static FileTruncateResponseParams _fileTruncateResponseParamsFactory(types_mojom.Error error) {
-    var result = new FileTruncateResponseParams();
-    result.error = error;
-    return result;
-  }
-  static FileTouchResponseParams _fileTouchResponseParamsFactory(types_mojom.Error error) {
-    var result = new FileTouchResponseParams();
-    result.error = error;
-    return result;
-  }
-  static FileDupResponseParams _fileDupResponseParamsFactory(types_mojom.Error error) {
-    var result = new FileDupResponseParams();
-    result.error = error;
-    return result;
-  }
-  static FileReopenResponseParams _fileReopenResponseParamsFactory(types_mojom.Error error) {
-    var result = new FileReopenResponseParams();
-    result.error = error;
-    return result;
-  }
-  static FileAsBufferResponseParams _fileAsBufferResponseParamsFactory(types_mojom.Error error, core.MojoSharedBuffer buffer) {
-    var result = new FileAsBufferResponseParams();
-    result.error = error;
-    result.buffer = buffer;
-    return result;
-  }
-  static FileIoctlResponseParams _fileIoctlResponseParamsFactory(types_mojom.Error error, List<int> outValues) {
-    var result = new FileIoctlResponseParams();
-    result.error = error;
-    result.outValues = outValues;
-    return result;
-  }
-
-  dynamic handleMessage(bindings.ServiceMessage message) {
+  Function _fileCloseResponseParamsResponder(
+      int requestId) {
+  return (types_mojom.Error err) {
+      var result = new FileCloseResponseParams();
+      result.err = err;
+      sendResponse(buildResponseWithId(
+          result,
+          _fileMethodCloseName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
+  }
+  Function _fileReadResponseParamsResponder(
+      int requestId) {
+  return (types_mojom.Error error, List<int> bytesRead) {
+      var result = new FileReadResponseParams();
+      result.error = error;
+      result.bytesRead = bytesRead;
+      sendResponse(buildResponseWithId(
+          result,
+          _fileMethodReadName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
+  }
+  Function _fileWriteResponseParamsResponder(
+      int requestId) {
+  return (types_mojom.Error error, int numBytesWritten) {
+      var result = new FileWriteResponseParams();
+      result.error = error;
+      result.numBytesWritten = numBytesWritten;
+      sendResponse(buildResponseWithId(
+          result,
+          _fileMethodWriteName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
+  }
+  Function _fileReadToStreamResponseParamsResponder(
+      int requestId) {
+  return (types_mojom.Error error) {
+      var result = new FileReadToStreamResponseParams();
+      result.error = error;
+      sendResponse(buildResponseWithId(
+          result,
+          _fileMethodReadToStreamName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
+  }
+  Function _fileWriteFromStreamResponseParamsResponder(
+      int requestId) {
+  return (types_mojom.Error error) {
+      var result = new FileWriteFromStreamResponseParams();
+      result.error = error;
+      sendResponse(buildResponseWithId(
+          result,
+          _fileMethodWriteFromStreamName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
+  }
+  Function _fileTellResponseParamsResponder(
+      int requestId) {
+  return (types_mojom.Error error, int position) {
+      var result = new FileTellResponseParams();
+      result.error = error;
+      result.position = position;
+      sendResponse(buildResponseWithId(
+          result,
+          _fileMethodTellName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
+  }
+  Function _fileSeekResponseParamsResponder(
+      int requestId) {
+  return (types_mojom.Error error, int position) {
+      var result = new FileSeekResponseParams();
+      result.error = error;
+      result.position = position;
+      sendResponse(buildResponseWithId(
+          result,
+          _fileMethodSeekName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
+  }
+  Function _fileStatResponseParamsResponder(
+      int requestId) {
+  return (types_mojom.Error error, types_mojom.FileInformation fileInformation) {
+      var result = new FileStatResponseParams();
+      result.error = error;
+      result.fileInformation = fileInformation;
+      sendResponse(buildResponseWithId(
+          result,
+          _fileMethodStatName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
+  }
+  Function _fileTruncateResponseParamsResponder(
+      int requestId) {
+  return (types_mojom.Error error) {
+      var result = new FileTruncateResponseParams();
+      result.error = error;
+      sendResponse(buildResponseWithId(
+          result,
+          _fileMethodTruncateName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
+  }
+  Function _fileTouchResponseParamsResponder(
+      int requestId) {
+  return (types_mojom.Error error) {
+      var result = new FileTouchResponseParams();
+      result.error = error;
+      sendResponse(buildResponseWithId(
+          result,
+          _fileMethodTouchName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
+  }
+  Function _fileDupResponseParamsResponder(
+      int requestId) {
+  return (types_mojom.Error error) {
+      var result = new FileDupResponseParams();
+      result.error = error;
+      sendResponse(buildResponseWithId(
+          result,
+          _fileMethodDupName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
+  }
+  Function _fileReopenResponseParamsResponder(
+      int requestId) {
+  return (types_mojom.Error error) {
+      var result = new FileReopenResponseParams();
+      result.error = error;
+      sendResponse(buildResponseWithId(
+          result,
+          _fileMethodReopenName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
+  }
+  Function _fileAsBufferResponseParamsResponder(
+      int requestId) {
+  return (types_mojom.Error error, core.MojoSharedBuffer buffer) {
+      var result = new FileAsBufferResponseParams();
+      result.error = error;
+      result.buffer = buffer;
+      sendResponse(buildResponseWithId(
+          result,
+          _fileMethodAsBufferName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
+  }
+  Function _fileIoctlResponseParamsResponder(
+      int requestId) {
+  return (types_mojom.Error error, List<int> outValues) {
+      var result = new FileIoctlResponseParams();
+      result.error = error;
+      result.outValues = outValues;
+      sendResponse(buildResponseWithId(
+          result,
+          _fileMethodIoctlName,
+          requestId,
+          bindings.MessageHeader.kMessageIsResponse));
+    };
+  }
+
+  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 _fileMethodCloseName:
-        var response = _impl.close_(_fileCloseResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _fileMethodCloseName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _fileMethodCloseName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.close_(_fileCloseResponseParamsResponder(message.header.requestId));
         break;
       case _fileMethodReadName:
         var params = _FileReadParams.deserialize(
             message.payload);
-        var response = _impl.read(params.numBytesToRead,params.offset,params.whence,_fileReadResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _fileMethodReadName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _fileMethodReadName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.read(params.numBytesToRead, params.offset, params.whence, _fileReadResponseParamsResponder(message.header.requestId));
         break;
       case _fileMethodWriteName:
         var params = _FileWriteParams.deserialize(
             message.payload);
-        var response = _impl.write(params.bytesToWrite,params.offset,params.whence,_fileWriteResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _fileMethodWriteName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _fileMethodWriteName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.write(params.bytesToWrite, params.offset, params.whence, _fileWriteResponseParamsResponder(message.header.requestId));
         break;
       case _fileMethodReadToStreamName:
         var params = _FileReadToStreamParams.deserialize(
             message.payload);
-        var response = _impl.readToStream(params.source,params.offset,params.whence,params.numBytesToRead,_fileReadToStreamResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _fileMethodReadToStreamName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _fileMethodReadToStreamName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.readToStream(params.source, params.offset, params.whence, params.numBytesToRead, _fileReadToStreamResponseParamsResponder(message.header.requestId));
         break;
       case _fileMethodWriteFromStreamName:
         var params = _FileWriteFromStreamParams.deserialize(
             message.payload);
-        var response = _impl.writeFromStream(params.sink,params.offset,params.whence,_fileWriteFromStreamResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _fileMethodWriteFromStreamName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _fileMethodWriteFromStreamName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.writeFromStream(params.sink, params.offset, params.whence, _fileWriteFromStreamResponseParamsResponder(message.header.requestId));
         break;
       case _fileMethodTellName:
-        var response = _impl.tell(_fileTellResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _fileMethodTellName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _fileMethodTellName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.tell(_fileTellResponseParamsResponder(message.header.requestId));
         break;
       case _fileMethodSeekName:
         var params = _FileSeekParams.deserialize(
             message.payload);
-        var response = _impl.seek(params.offset,params.whence,_fileSeekResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _fileMethodSeekName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _fileMethodSeekName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.seek(params.offset, params.whence, _fileSeekResponseParamsResponder(message.header.requestId));
         break;
       case _fileMethodStatName:
-        var response = _impl.stat(_fileStatResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _fileMethodStatName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _fileMethodStatName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.stat(_fileStatResponseParamsResponder(message.header.requestId));
         break;
       case _fileMethodTruncateName:
         var params = _FileTruncateParams.deserialize(
             message.payload);
-        var response = _impl.truncate(params.size,_fileTruncateResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _fileMethodTruncateName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _fileMethodTruncateName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.truncate(params.size, _fileTruncateResponseParamsResponder(message.header.requestId));
         break;
       case _fileMethodTouchName:
         var params = _FileTouchParams.deserialize(
             message.payload);
-        var response = _impl.touch(params.atime,params.mtime,_fileTouchResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _fileMethodTouchName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _fileMethodTouchName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.touch(params.atime, params.mtime, _fileTouchResponseParamsResponder(message.header.requestId));
         break;
       case _fileMethodDupName:
         var params = _FileDupParams.deserialize(
             message.payload);
-        var response = _impl.dup(params.file,_fileDupResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _fileMethodDupName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _fileMethodDupName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.dup(params.file, _fileDupResponseParamsResponder(message.header.requestId));
         break;
       case _fileMethodReopenName:
         var params = _FileReopenParams.deserialize(
             message.payload);
-        var response = _impl.reopen(params.file,params.openFlags,_fileReopenResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _fileMethodReopenName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _fileMethodReopenName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.reopen(params.file, params.openFlags, _fileReopenResponseParamsResponder(message.header.requestId));
         break;
       case _fileMethodAsBufferName:
-        var response = _impl.asBuffer(_fileAsBufferResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _fileMethodAsBufferName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _fileMethodAsBufferName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.asBuffer(_fileAsBufferResponseParamsResponder(message.header.requestId));
         break;
       case _fileMethodIoctlName:
         var params = _FileIoctlParams.deserialize(
             message.payload);
-        var response = _impl.ioctl(params.request,params.inValues,_fileIoctlResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _fileMethodIoctlName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _fileMethodIoctlName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.ioctl(params.request, params.inValues, _fileIoctlResponseParamsResponder(message.header.requestId));
         break;
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
         break;
     }
-    return null;
   }
 
   File get impl => _impl;
   set impl(File 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, [File impl])
       : super(new _FileStubControl.fromHandle(handle, impl));
 
   static FileStub newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For FileStub"));
     return new FileStub.fromEndpoint(endpoint);
   }
 
 
-  dynamic close_([Function responseFactory = null]) {
-    return impl.close_(responseFactory);
+  void close_(void callback(types_mojom.Error err)) {
+    return impl.close_(callback);
   }
-  dynamic read(int numBytesToRead,int offset,types_mojom.Whence whence,[Function responseFactory = null]) {
-    return impl.read(numBytesToRead,offset,whence,responseFactory);
+  void read(int numBytesToRead,int offset,types_mojom.Whence whence,void callback(types_mojom.Error error, List<int> bytesRead)) {
+    return impl.read(numBytesToRead,offset,whence,callback);
   }
-  dynamic write(List<int> bytesToWrite,int offset,types_mojom.Whence whence,[Function responseFactory = null]) {
-    return impl.write(bytesToWrite,offset,whence,responseFactory);
+  void write(List<int> bytesToWrite,int offset,types_mojom.Whence whence,void callback(types_mojom.Error error, int numBytesWritten)) {
+    return impl.write(bytesToWrite,offset,whence,callback);
   }
-  dynamic readToStream(core.MojoDataPipeProducer source,int offset,types_mojom.Whence whence,int numBytesToRead,[Function responseFactory = null]) {
-    return impl.readToStream(source,offset,whence,numBytesToRead,responseFactory);
+  void readToStream(core.MojoDataPipeProducer source,int offset,types_mojom.Whence whence,int numBytesToRead,void callback(types_mojom.Error error)) {
+    return impl.readToStream(source,offset,whence,numBytesToRead,callback);
   }
-  dynamic writeFromStream(core.MojoDataPipeConsumer sink,int offset,types_mojom.Whence whence,[Function responseFactory = null]) {
-    return impl.writeFromStream(sink,offset,whence,responseFactory);
+  void writeFromStream(core.MojoDataPipeConsumer sink,int offset,types_mojom.Whence whence,void callback(types_mojom.Error error)) {
+    return impl.writeFromStream(sink,offset,whence,callback);
   }
-  dynamic tell([Function responseFactory = null]) {
-    return impl.tell(responseFactory);
+  void tell(void callback(types_mojom.Error error, int position)) {
+    return impl.tell(callback);
   }
-  dynamic seek(int offset,types_mojom.Whence whence,[Function responseFactory = null]) {
-    return impl.seek(offset,whence,responseFactory);
+  void seek(int offset,types_mojom.Whence whence,void callback(types_mojom.Error error, int position)) {
+    return impl.seek(offset,whence,callback);
   }
-  dynamic stat([Function responseFactory = null]) {
-    return impl.stat(responseFactory);
+  void stat(void callback(types_mojom.Error error, types_mojom.FileInformation fileInformation)) {
+    return impl.stat(callback);
   }
-  dynamic truncate(int size,[Function responseFactory = null]) {
-    return impl.truncate(size,responseFactory);
+  void truncate(int size,void callback(types_mojom.Error error)) {
+    return impl.truncate(size,callback);
   }
-  dynamic touch(types_mojom.TimespecOrNow atime,types_mojom.TimespecOrNow mtime,[Function responseFactory = null]) {
-    return impl.touch(atime,mtime,responseFactory);
+  void touch(types_mojom.TimespecOrNow atime,types_mojom.TimespecOrNow mtime,void callback(types_mojom.Error error)) {
+    return impl.touch(atime,mtime,callback);
   }
-  dynamic dup(FileInterfaceRequest file,[Function responseFactory = null]) {
-    return impl.dup(file,responseFactory);
+  void dup(FileInterfaceRequest file,void callback(types_mojom.Error error)) {
+    return impl.dup(file,callback);
   }
-  dynamic reopen(FileInterfaceRequest file,int openFlags,[Function responseFactory = null]) {
-    return impl.reopen(file,openFlags,responseFactory);
+  void reopen(FileInterfaceRequest file,int openFlags,void callback(types_mojom.Error error)) {
+    return impl.reopen(file,openFlags,callback);
   }
-  dynamic asBuffer([Function responseFactory = null]) {
-    return impl.asBuffer(responseFactory);
+  void asBuffer(void callback(types_mojom.Error error, core.MojoSharedBuffer buffer)) {
+    return impl.asBuffer(callback);
   }
-  dynamic ioctl(int request,List<int> inValues,[Function responseFactory = null]) {
-    return impl.ioctl(request,inValues,responseFactory);
+  void ioctl(int request,List<int> inValues,void callback(types_mojom.Error error, List<int> outValues)) {
+    return impl.ioctl(request,inValues,callback);
   }
 }