Dart: Futures -> Callbacks.

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

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 library keyboard_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/native_viewport_event_dispatcher.mojom.dart' as native_viewport_event_dispatcher_mojom;
@@ skipping 115 matching lines @@
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(40, 0)
   ];
   int id = 0;
   int position = 0;
   String text = null;
   String label = null;
 
   CompletionData() : super(kVersions.last.size);
 
+  CompletionData.init(
+    int this.id, 
+    int this.position, 
+    String this.text, 
+    String this.label
+  ) : super(kVersions.last.size);
+
   static CompletionData 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 CompletionData decode(bindings.Decoder decoder0) {
@@ skipping 93 matching lines @@
 class CorrectionData extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(32, 0)
   ];
   int offset = 0;
   String oldText = null;
   String newText = null;
 
   CorrectionData() : super(kVersions.last.size);
 
+  CorrectionData.init(
+    int this.offset, 
+    String this.oldText, 
+    String this.newText
+  ) : super(kVersions.last.size);
+
   static CorrectionData 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 CorrectionData decode(bindings.Decoder decoder0) {
@@ skipping 78 matching lines @@
 
 
 class _KeyboardClientCommitCompletionParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   CompletionData completion = null;
 
   _KeyboardClientCommitCompletionParams() : super(kVersions.last.size);
 
+  _KeyboardClientCommitCompletionParams.init(
+    CompletionData this.completion
+  ) : super(kVersions.last.size);
+
   static _KeyboardClientCommitCompletionParams 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 _KeyboardClientCommitCompletionParams decode(bindings.Decoder decoder0) {
@@ skipping 53 matching lines @@
 
 
 class _KeyboardClientCommitCorrectionParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   CorrectionData correction = null;
 
   _KeyboardClientCommitCorrectionParams() : super(kVersions.last.size);
 
+  _KeyboardClientCommitCorrectionParams.init(
+    CorrectionData this.correction
+  ) : super(kVersions.last.size);
+
   static _KeyboardClientCommitCorrectionParams 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 _KeyboardClientCommitCorrectionParams decode(bindings.Decoder decoder0) {
@@ skipping 54 matching lines @@
 
 class _KeyboardClientCommitTextParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   String text = null;
   int newCursorPosition = 0;
 
   _KeyboardClientCommitTextParams() : super(kVersions.last.size);
 
+  _KeyboardClientCommitTextParams.init(
+    String this.text, 
+    int this.newCursorPosition
+  ) : super(kVersions.last.size);
+
   static _KeyboardClientCommitTextParams 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 _KeyboardClientCommitTextParams decode(bindings.Decoder decoder0) {
@@ skipping 66 matching lines @@
 
 class _KeyboardClientDeleteSurroundingTextParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   int beforeLength = 0;
   int afterLength = 0;
 
   _KeyboardClientDeleteSurroundingTextParams() : super(kVersions.last.size);
 
+  _KeyboardClientDeleteSurroundingTextParams.init(
+    int this.beforeLength, 
+    int this.afterLength
+  ) : super(kVersions.last.size);
+
   static _KeyboardClientDeleteSurroundingTextParams 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 _KeyboardClientDeleteSurroundingTextParams decode(bindings.Decoder decoder0) {
@@ skipping 66 matching lines @@
 
 class _KeyboardClientSetComposingRegionParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   int start = 0;
   int end = 0;
 
   _KeyboardClientSetComposingRegionParams() : super(kVersions.last.size);
 
+  _KeyboardClientSetComposingRegionParams.init(
+    int this.start, 
+    int this.end
+  ) : super(kVersions.last.size);
+
   static _KeyboardClientSetComposingRegionParams 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 _KeyboardClientSetComposingRegionParams decode(bindings.Decoder decoder0) {
@@ skipping 66 matching lines @@
 
 class _KeyboardClientSetComposingTextParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   String text = null;
   int newCursorPosition = 0;
 
   _KeyboardClientSetComposingTextParams() : super(kVersions.last.size);
 
+  _KeyboardClientSetComposingTextParams.init(
+    String this.text, 
+    int this.newCursorPosition
+  ) : super(kVersions.last.size);
+
   static _KeyboardClientSetComposingTextParams 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 _KeyboardClientSetComposingTextParams decode(bindings.Decoder decoder0) {
@@ skipping 66 matching lines @@
 
 class _KeyboardClientSetSelectionParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   int start = 0;
   int end = 0;
 
   _KeyboardClientSetSelectionParams() : super(kVersions.last.size);
 
+  _KeyboardClientSetSelectionParams.init(
+    int this.start, 
+    int this.end
+  ) : super(kVersions.last.size);
+
   static _KeyboardClientSetSelectionParams 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 _KeyboardClientSetSelectionParams decode(bindings.Decoder decoder0) {
@@ skipping 65 matching lines @@
 
 
 class _KeyboardClientSubmitParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   SubmitAction action = null;
 
   _KeyboardClientSubmitParams() : super(kVersions.last.size);
 
+  _KeyboardClientSubmitParams.init(
+    SubmitAction this.action
+  ) : super(kVersions.last.size);
+
   static _KeyboardClientSubmitParams 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 _KeyboardClientSubmitParams decode(bindings.Decoder decoder0) {
@@ skipping 57 matching lines @@
 
 class _KeyboardServiceShowParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   KeyboardClientInterface client = null;
   KeyboardType type = null;
 
   _KeyboardServiceShowParams() : super(kVersions.last.size);
 
+  _KeyboardServiceShowParams.init(
+    KeyboardClientInterface this.client, 
+    KeyboardType this.type
+  ) : super(kVersions.last.size);
+
   static _KeyboardServiceShowParams 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 _KeyboardServiceShowParams decode(bindings.Decoder decoder0) {
@@ skipping 66 matching lines @@
 }
 
 
 class _KeyboardServiceShowByRequestParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   _KeyboardServiceShowByRequestParams() : super(kVersions.last.size);
 
+  _KeyboardServiceShowByRequestParams.init(
+  ) : super(kVersions.last.size);
+
   static _KeyboardServiceShowByRequestParams 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 _KeyboardServiceShowByRequestParams decode(bindings.Decoder decoder0) {
@@ skipping 38 matching lines @@
 }
 
 
 class _KeyboardServiceHideParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   _KeyboardServiceHideParams() : super(kVersions.last.size);
 
+  _KeyboardServiceHideParams.init(
+  ) : super(kVersions.last.size);
+
   static _KeyboardServiceHideParams 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 _KeyboardServiceHideParams decode(bindings.Decoder decoder0) {
@@ skipping 39 matching lines @@
 
 
 class _KeyboardServiceSetTextParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   String text = null;
 
   _KeyboardServiceSetTextParams() : super(kVersions.last.size);
 
+  _KeyboardServiceSetTextParams.init(
+    String this.text
+  ) : super(kVersions.last.size);
+
   static _KeyboardServiceSetTextParams 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 _KeyboardServiceSetTextParams decode(bindings.Decoder decoder0) {
@@ skipping 53 matching lines @@
 
 class _KeyboardServiceSetSelectionParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   int start = 0;
   int end = 0;
 
   _KeyboardServiceSetSelectionParams() : super(kVersions.last.size);
 
+  _KeyboardServiceSetSelectionParams.init(
+    int this.start, 
+    int this.end
+  ) : super(kVersions.last.size);
+
   static _KeyboardServiceSetSelectionParams 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 _KeyboardServiceSetSelectionParams decode(bindings.Decoder decoder0) {
@@ skipping 66 matching lines @@
 
 class _KeyboardServiceFactoryCreateKeyboardServiceParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   native_viewport_event_dispatcher_mojom.NativeViewportEventDispatcherInterfaceRequest keyEventDispatcher = null;
   KeyboardServiceInterfaceRequest serviceRequest = null;
 
   _KeyboardServiceFactoryCreateKeyboardServiceParams() : super(kVersions.last.size);
 
+  _KeyboardServiceFactoryCreateKeyboardServiceParams.init(
+    native_viewport_event_dispatcher_mojom.NativeViewportEventDispatcherInterfaceRequest this.keyEventDispatcher, 
+    KeyboardServiceInterfaceRequest this.serviceRequest
+  ) : super(kVersions.last.size);
+
   static _KeyboardServiceFactoryCreateKeyboardServiceParams 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 _KeyboardServiceFactoryCreateKeyboardServiceParams decode(bindings.Decoder decoder0) {
@@ skipping 64 matching lines @@
 const int _keyboardClientMethodCommitCompletionName = 0;
 const int _keyboardClientMethodCommitCorrectionName = 1;
 const int _keyboardClientMethodCommitTextName = 2;
 const int _keyboardClientMethodDeleteSurroundingTextName = 3;
 const int _keyboardClientMethodSetComposingRegionName = 4;
 const int _keyboardClientMethodSetComposingTextName = 5;
 const int _keyboardClientMethodSetSelectionName = 6;
 const int _keyboardClientMethodSubmitName = 7;
 
 class _KeyboardClientServiceDescription 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 KeyboardClient {
   static const String serviceName = null;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _KeyboardClientServiceDescription();
     }
@@ skipping 198 matching lines @@
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
   _KeyboardClientStubControl.unbound([this._impl]) : super.unbound();
 
   String get serviceName => KeyboardClient.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 _keyboardClientMethodCommitCompletionName:
         var params = _KeyboardClientCommitCompletionParams.deserialize(
             message.payload);
         _impl.commitCompletion(params.completion);
         break;
@@ skipping 29 matching lines @@
         break;
       case _keyboardClientMethodSubmitName:
         var params = _KeyboardClientSubmitParams.deserialize(
             message.payload);
         _impl.submit(params.action);
         break;
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
         break;
     }
-    return null;
   }
 
   KeyboardClient get impl => _impl;
   set impl(KeyboardClient d) {
     if (d == null) {
       throw new core.MojoApiError("$this: Cannot set a null implementation");
     }
     if (isBound && (_impl == null)) {
       beginHandlingEvents();
     }
@@ skipping 66 matching lines @@
   }
 }
 
 const int _keyboardServiceMethodShowName = 0;
 const int _keyboardServiceMethodShowByRequestName = 1;
 const int _keyboardServiceMethodHideName = 2;
 const int _keyboardServiceMethodSetTextName = 3;
 const int _keyboardServiceMethodSetSelectionName = 4;
 
 class _KeyboardServiceServiceDescription 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 KeyboardService {
   static const String serviceName = "keyboard::KeyboardService";
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _KeyboardServiceServiceDescription();
     }
@@ skipping 160 matching lines @@
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
   _KeyboardServiceStubControl.unbound([this._impl]) : super.unbound();
 
   String get serviceName => KeyboardService.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 _keyboardServiceMethodShowName:
         var params = _KeyboardServiceShowParams.deserialize(
             message.payload);
         _impl.show(params.client, params.type);
         break;
@@ skipping 10 matching lines @@
         break;
       case _keyboardServiceMethodSetSelectionName:
         var params = _KeyboardServiceSetSelectionParams.deserialize(
             message.payload);
         _impl.setSelection(params.start, params.end);
         break;
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
         break;
     }
-    return null;
   }
 
   KeyboardService get impl => _impl;
   set impl(KeyboardService d) {
     if (d == null) {
       throw new core.MojoApiError("$this: Cannot set a null implementation");
     }
     if (isBound && (_impl == null)) {
       beginHandlingEvents();
     }
@@ skipping 53 matching lines @@
     return impl.setText(text);
   }
   void setSelection(int start, int end) {
     return impl.setSelection(start, end);
   }
 }
 
 const int _keyboardServiceFactoryMethodCreateKeyboardServiceName = 0;
 
 class _KeyboardServiceFactoryServiceDescription 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 KeyboardServiceFactory {
   static const String serviceName = "keyboard::KeyboardServiceFactory";
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
       _cachedServiceDescription = new _KeyboardServiceFactoryServiceDescription();
     }
@@ skipping 117 matching lines @@
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
   _KeyboardServiceFactoryStubControl.unbound([this._impl]) : super.unbound();
 
   String get serviceName => KeyboardServiceFactory.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 _keyboardServiceFactoryMethodCreateKeyboardServiceName:
         var params = _KeyboardServiceFactoryCreateKeyboardServiceParams.deserialize(
             message.payload);
         _impl.createKeyboardService(params.keyEventDispatcher, params.serviceRequest);
         break;
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
         break;
     }
-    return null;
   }
 
   KeyboardServiceFactory get impl => _impl;
   set impl(KeyboardServiceFactory d) {
     if (d == null) {
       throw new core.MojoApiError("$this: Cannot set a null implementation");
     }
     if (isBound && (_impl == null)) {
       beginHandlingEvents();
     }
@@ skipping 40 matching lines @@
   }
 
 
   void createKeyboardService(native_viewport_event_dispatcher_mojom.NativeViewportEventDispatcherInterfaceRequest keyEventDispatcher, KeyboardServiceInterfaceRequest serviceRequest) {
     return impl.createKeyboardService(keyEventDispatcher, serviceRequest);
   }
 }