Generate Mojom Types in Dart (Take 2)

mojo/dart/packages/mojo_services/lib/activity/activity.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 activity_mojom;
 
 import 'dart:async';
 
 import 'package:mojo/bindings.dart' as bindings;
 import 'package:mojo/core.dart' as core;
+import 'package:mojo/mojo/bindings/types/mojom_types.mojom.dart' as mojom_types;
+import 'package:mojo/mojo/bindings/types/service_describer.mojom.dart' as service_describer;
 
 class SystemUiVisibility extends bindings.MojoEnum {
   static const SystemUiVisibility standard = const SystemUiVisibility._(0);
   static const SystemUiVisibility fullscreen = const SystemUiVisibility._(1);
   static const SystemUiVisibility immersive = const SystemUiVisibility._(2);
 
   const SystemUiVisibility._(int v) : super(v);
 
   static const Map<String, SystemUiVisibility> valuesMap = const {
     "standard": standard,
@@ skipping 32 matching lines @@
   }
 
   String toString() {
     switch(this) {
       case standard:
         return 'SystemUiVisibility.standard';
       case fullscreen:
         return 'SystemUiVisibility.fullscreen';
       case immersive:
         return 'SystemUiVisibility.immersive';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
+
+
 class ScreenOrientation extends bindings.MojoEnum {
   static const ScreenOrientation unspecified = const ScreenOrientation._(0);
   static const ScreenOrientation landscape = const ScreenOrientation._(1);
   static const ScreenOrientation portrait = const ScreenOrientation._(2);
   static const ScreenOrientation nosensor = const ScreenOrientation._(3);
 
   const ScreenOrientation._(int v) : super(v);
 
   static const Map<String, ScreenOrientation> valuesMap = const {
     "unspecified": unspecified,
@@ skipping 38 matching lines @@
   String toString() {
     switch(this) {
       case unspecified:
         return 'ScreenOrientation.unspecified';
       case landscape:
         return 'ScreenOrientation.landscape';
       case portrait:
         return 'ScreenOrientation.portrait';
       case nosensor:
         return 'ScreenOrientation.nosensor';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
+
+
 class HapticFeedbackType extends bindings.MojoEnum {
   static const HapticFeedbackType longPress = const HapticFeedbackType._(0);
   static const HapticFeedbackType virtualKey = const HapticFeedbackType._(1);
   static const HapticFeedbackType keyboardTap = const HapticFeedbackType._(2);
   static const HapticFeedbackType clockTick = const HapticFeedbackType._(3);
 
   const HapticFeedbackType._(int v) : super(v);
 
   static const Map<String, HapticFeedbackType> valuesMap = const {
     "longPress": longPress,
@@ skipping 38 matching lines @@
   String toString() {
     switch(this) {
       case longPress:
         return 'HapticFeedbackType.longPress';
       case virtualKey:
         return 'HapticFeedbackType.virtualKey';
       case keyboardTap:
         return 'HapticFeedbackType.keyboardTap';
       case clockTick:
         return 'HapticFeedbackType.clockTick';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
+
+
 class AuralFeedbackType extends bindings.MojoEnum {
   static const AuralFeedbackType click = const AuralFeedbackType._(0);
   static const AuralFeedbackType navigationLeft = const AuralFeedbackType._(1);
   static const AuralFeedbackType navigationUp = const AuralFeedbackType._(2);
   static const AuralFeedbackType navigationRight = const AuralFeedbackType._(3);
   static const AuralFeedbackType navigationDown = const AuralFeedbackType._(4);
 
   const AuralFeedbackType._(int v) : super(v);
 
   static const Map<String, AuralFeedbackType> valuesMap = const {
@@ skipping 45 matching lines @@
       case click:
         return 'AuralFeedbackType.click';
       case navigationLeft:
         return 'AuralFeedbackType.navigationLeft';
       case navigationUp:
         return 'AuralFeedbackType.navigationUp';
       case navigationRight:
         return 'AuralFeedbackType.navigationRight';
       case navigationDown:
         return 'AuralFeedbackType.navigationDown';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
 
 
+
+
 class StringExtra extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   String name = null;
   String value = null;
 
   StringExtra() : super(kVersions.last.size);
 
   static StringExtra deserialize(bindings.Message message) {
@@ skipping 56 matching lines @@
 
   Map toJson() {
     Map map = new Map();
     map["name"] = name;
     map["value"] = value;
     return map;
   }
 }
 
 
+
+
 class ComponentName extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   String packageName = null;
   String className = null;
 
   ComponentName() : super(kVersions.last.size);
 
   static ComponentName deserialize(bindings.Message message) {
@@ skipping 56 matching lines @@
 
   Map toJson() {
     Map map = new Map();
     map["packageName"] = packageName;
     map["className"] = className;
     return map;
   }
 }
 
 
+
+
 class Intent extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(56, 0)
   ];
   String action = null;
   String url = null;
   int flags = 0;
   ComponentName component = null;
   List<StringExtra> stringExtras = null;
   String type = null;
@@ skipping 112 matching lines @@
     map["url"] = url;
     map["flags"] = flags;
     map["component"] = component;
     map["stringExtras"] = stringExtras;
     map["type"] = type;
     return map;
   }
 }
 
 
+
+
 class TaskDescription extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   String label = null;
   int primaryColor = 0;
 
   TaskDescription() : super(kVersions.last.size);
 
   static TaskDescription deserialize(bindings.Message message) {
@@ skipping 56 matching lines @@
 
   Map toJson() {
     Map map = new Map();
     map["label"] = label;
     map["primaryColor"] = primaryColor;
     return map;
   }
 }
 
 
+
+
 class _ActivityGetUserFeedbackParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   Object userFeedback = null;
 
   _ActivityGetUserFeedbackParams() : super(kVersions.last.size);
 
   static _ActivityGetUserFeedbackParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
@@ skipping 46 matching lines @@
            "userFeedback: $userFeedback" ")";
   }
 
   Map toJson() {
     throw new bindings.MojoCodecError(
         'Object containing handles cannot be encoded to JSON.');
   }
 }
 
 
+
+
 class _ActivityStartActivityParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   Intent intent = null;
 
   _ActivityStartActivityParams() : super(kVersions.last.size);
 
   static _ActivityStartActivityParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
@@ skipping 48 matching lines @@
   }
 
   Map toJson() {
     Map map = new Map();
     map["intent"] = intent;
     return map;
   }
 }
 
 
+
+
 class _ActivityFinishCurrentActivityParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   _ActivityFinishCurrentActivityParams() : super(kVersions.last.size);
 
   static _ActivityFinishCurrentActivityParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
@@ skipping 38 matching lines @@
     return "_ActivityFinishCurrentActivityParams("")";
   }
 
   Map toJson() {
     Map map = new Map();
     return map;
   }
 }
 
 
+
+
 class _ActivitySetTaskDescriptionParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   TaskDescription description = null;
 
   _ActivitySetTaskDescriptionParams() : super(kVersions.last.size);
 
   static _ActivitySetTaskDescriptionParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
@@ skipping 48 matching lines @@
   }
 
   Map toJson() {
     Map map = new Map();
     map["description"] = description;
     return map;
   }
 }
 
 
+
+
 class _ActivitySetSystemUiVisibilityParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   SystemUiVisibility visibility = null;
 
   _ActivitySetSystemUiVisibilityParams() : super(kVersions.last.size);
 
   static _ActivitySetSystemUiVisibilityParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
@@ skipping 51 matching lines @@
   }
 
   Map toJson() {
     Map map = new Map();
     map["visibility"] = visibility;
     return map;
   }
 }
 
 
+
+
 class _ActivitySetRequestedOrientationParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   ScreenOrientation orientation = null;
 
   _ActivitySetRequestedOrientationParams() : super(kVersions.last.size);
 
   static _ActivitySetRequestedOrientationParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
@@ skipping 51 matching lines @@
   }
 
   Map toJson() {
     Map map = new Map();
     map["orientation"] = orientation;
     return map;
   }
 }
 
 
+
+
 class _PathServiceGetAppDataDirParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   _PathServiceGetAppDataDirParams() : super(kVersions.last.size);
 
   static _PathServiceGetAppDataDirParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
@@ skipping 38 matching lines @@
     return "_PathServiceGetAppDataDirParams("")";
   }
 
   Map toJson() {
     Map map = new Map();
     return map;
   }
 }
 
 
+
+
 class PathServiceGetAppDataDirResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   String path = null;
 
   PathServiceGetAppDataDirResponseParams() : super(kVersions.last.size);
 
   static PathServiceGetAppDataDirResponseParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
@@ skipping 47 matching lines @@
   }
 
   Map toJson() {
     Map map = new Map();
     map["path"] = path;
     return map;
   }
 }
 
 
+
+
 class _PathServiceGetFilesDirParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   _PathServiceGetFilesDirParams() : super(kVersions.last.size);
 
   static _PathServiceGetFilesDirParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
@@ skipping 38 matching lines @@
     return "_PathServiceGetFilesDirParams("")";
   }
 
   Map toJson() {
     Map map = new Map();
     return map;
   }
 }
 
 
+
+
 class PathServiceGetFilesDirResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   String path = null;
 
   PathServiceGetFilesDirResponseParams() : super(kVersions.last.size);
 
   static PathServiceGetFilesDirResponseParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
@@ skipping 47 matching lines @@
   }
 
   Map toJson() {
     Map map = new Map();
     map["path"] = path;
     return map;
   }
 }
 
 
+
+
 class _PathServiceGetCacheDirParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(8, 0)
   ];
 
   _PathServiceGetCacheDirParams() : super(kVersions.last.size);
 
   static _PathServiceGetCacheDirParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
@@ skipping 38 matching lines @@
     return "_PathServiceGetCacheDirParams("")";
   }
 
   Map toJson() {
     Map map = new Map();
     return map;
   }
 }
 
 
+
+
 class PathServiceGetCacheDirResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   String path = null;
 
   PathServiceGetCacheDirResponseParams() : super(kVersions.last.size);
 
   static PathServiceGetCacheDirResponseParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
@@ skipping 47 matching lines @@
   }
 
   Map toJson() {
     Map map = new Map();
     map["path"] = path;
     return map;
   }
 }
 
 
+
+
 class _UserFeedbackPerformHapticFeedbackParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   HapticFeedbackType type = null;
 
   _UserFeedbackPerformHapticFeedbackParams() : super(kVersions.last.size);
 
   static _UserFeedbackPerformHapticFeedbackParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
@@ skipping 51 matching lines @@
   }
 
   Map toJson() {
     Map map = new Map();
     map["type"] = type;
     return map;
   }
 }
 
 
+
+
 class _UserFeedbackPerformAuralFeedbackParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   AuralFeedbackType type = null;
 
   _UserFeedbackPerformAuralFeedbackParams() : super(kVersions.last.size);
 
   static _UserFeedbackPerformAuralFeedbackParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
@@ skipping 50 matching lines @@
            "type: $type" ")";
   }
 
   Map toJson() {
     Map map = new Map();
     map["type"] = type;
     return map;
   }
 }
 
+
+
+
 const int _Activity_getUserFeedbackName = 0;
 const int _Activity_startActivityName = 1;
 const int _Activity_finishCurrentActivityName = 2;
 const int _Activity_setTaskDescriptionName = 3;
 const int _Activity_setSystemUiVisibilityName = 4;
 const int _Activity_setRequestedOrientationName = 5;
 
+
+
+class _ActivityServiceDescription implements service_describer.ServiceDescription {
+  dynamic getTopLevelInterface([Function responseFactory]) => null;
+
+  dynamic getTypeDefinition(String typeKey, [Function responseFactory]) => null;
+
+  dynamic getAllTypeDefinitions([Function responseFactory]) => null;
+}
+
 abstract class Activity {
   static const String serviceName = "activity::Activity";
   void getUserFeedback(Object userFeedback);
   void startActivity(Intent intent);
   void finishCurrentActivity();
   void setTaskDescription(TaskDescription description);
   void setSystemUiVisibility(SystemUiVisibility visibility);
   void setRequestedOrientation(ScreenOrientation orientation);
 }
 
 
 class _ActivityProxyImpl extends bindings.Proxy {
   _ActivityProxyImpl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _ActivityProxyImpl.fromHandle(core.MojoHandle handle) :
       super.fromHandle(handle);
 
   _ActivityProxyImpl.unbound() : super.unbound();
 
   static _ActivityProxyImpl newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For _ActivityProxyImpl"));
     return new _ActivityProxyImpl.fromEndpoint(endpoint);
   }
 
+  service_describer.ServiceDescription get serviceDescription =>
+    new _ActivityServiceDescription();
+
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       default:
         proxyError("Unexpected message type: ${message.header.type}");
         close(immediate: true);
         break;
     }
   }
 
   String toString() {
@@ skipping 192 matching lines @@
     assert(_impl == null);
     _impl = d;
   }
 
   String toString() {
     var superString = super.toString();
     return "ActivityStub($superString)";
   }
 
   int get version => 0;
+
+  service_describer.ServiceDescription get serviceDescription =>
+    new _ActivityServiceDescription();
 }
 
 const int _PathService_getAppDataDirName = 0;
 const int _PathService_getFilesDirName = 1;
 const int _PathService_getCacheDirName = 2;
 
+
+
+class _PathServiceServiceDescription implements service_describer.ServiceDescription {
+  dynamic getTopLevelInterface([Function responseFactory]) => null;
+
+  dynamic getTypeDefinition(String typeKey, [Function responseFactory]) => null;
+
+  dynamic getAllTypeDefinitions([Function responseFactory]) => null;
+}
+
 abstract class PathService {
   static const String serviceName = "activity::PathService";
   dynamic getAppDataDir([Function responseFactory = null]);
   dynamic getFilesDir([Function responseFactory = null]);
   dynamic getCacheDir([Function responseFactory = null]);
 }
 
 
 class _PathServiceProxyImpl extends bindings.Proxy {
   _PathServiceProxyImpl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _PathServiceProxyImpl.fromHandle(core.MojoHandle handle) :
       super.fromHandle(handle);
 
   _PathServiceProxyImpl.unbound() : super.unbound();
 
   static _PathServiceProxyImpl newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For _PathServiceProxyImpl"));
     return new _PathServiceProxyImpl.fromEndpoint(endpoint);
   }
 
+  service_describer.ServiceDescription get serviceDescription =>
+    new _PathServiceServiceDescription();
+
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       case _PathService_getAppDataDirName:
         var r = PathServiceGetAppDataDirResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
           return;
         }
         Completer c = completerMap[message.header.requestId];
@@ skipping 274 matching lines @@
     assert(_impl == null);
     _impl = d;
   }
 
   String toString() {
     var superString = super.toString();
     return "PathServiceStub($superString)";
   }
 
   int get version => 0;
+
+  service_describer.ServiceDescription get serviceDescription =>
+    new _PathServiceServiceDescription();
 }
 
 const int _UserFeedback_performHapticFeedbackName = 0;
 const int _UserFeedback_performAuralFeedbackName = 1;
 
+
+
+class _UserFeedbackServiceDescription implements service_describer.ServiceDescription {
+  dynamic getTopLevelInterface([Function responseFactory]) => null;
+
+  dynamic getTypeDefinition(String typeKey, [Function responseFactory]) => null;
+
+  dynamic getAllTypeDefinitions([Function responseFactory]) => null;
+}
+
 abstract class UserFeedback {
   static const String serviceName = null;
   void performHapticFeedback(HapticFeedbackType type);
   void performAuralFeedback(AuralFeedbackType type);
 }
 
 
 class _UserFeedbackProxyImpl extends bindings.Proxy {
   _UserFeedbackProxyImpl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
   _UserFeedbackProxyImpl.fromHandle(core.MojoHandle handle) :
       super.fromHandle(handle);
 
   _UserFeedbackProxyImpl.unbound() : super.unbound();
 
   static _UserFeedbackProxyImpl newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
     assert(endpoint.setDescription("For _UserFeedbackProxyImpl"));
     return new _UserFeedbackProxyImpl.fromEndpoint(endpoint);
   }
 
+  service_describer.ServiceDescription get serviceDescription =>
+    new _UserFeedbackServiceDescription();
+
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       default:
         proxyError("Unexpected message type: ${message.header.type}");
         close(immediate: true);
         break;
     }
   }
 
   String toString() {
@@ skipping 137 matching lines @@
     assert(_impl == null);
     _impl = d;
   }
 
   String toString() {
     var superString = super.toString();
     return "UserFeedbackStub($superString)";
   }
 
   int get version => 0;
+
+  service_describer.ServiceDescription get serviceDescription =>
+    new _UserFeedbackServiceDescription();
 }
 
 
+