Generate Mojom Types in Dart (Take 2)

mojo/dart/packages/mojo_services/lib/mojo/media/media_types.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 media_types_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;
+
 
 class MediaTypeScheme extends bindings.MojoEnum {
   static const MediaTypeScheme unknown = const MediaTypeScheme._(0);
   static const MediaTypeScheme none = const MediaTypeScheme._(1);
   static const MediaTypeScheme anyElementary = const MediaTypeScheme._(2);
   static const MediaTypeScheme anyAudio = const MediaTypeScheme._(3);
   static const MediaTypeScheme anyVideo = const MediaTypeScheme._(4);
   static const MediaTypeScheme anySubpicture = const MediaTypeScheme._(5);
   static const MediaTypeScheme anyText = const MediaTypeScheme._(6);
   static const MediaTypeScheme anyMultiplexed = const MediaTypeScheme._(7);
@@ skipping 102 matching lines @@
       case any:
         return 'MediaTypeScheme.any';
       case multiplexed:
         return 'MediaTypeScheme.multiplexed';
       case lpcm:
         return 'MediaTypeScheme.lpcm';
       case compressedAudio:
         return 'MediaTypeScheme.compressedAudio';
       case video:
         return 'MediaTypeScheme.video';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
+
+
 class LpcmSampleFormat extends bindings.MojoEnum {
   static const LpcmSampleFormat unknown = const LpcmSampleFormat._(0);
   static const LpcmSampleFormat any = const LpcmSampleFormat._(1);
   static const LpcmSampleFormat unsigned8 = const LpcmSampleFormat._(2);
   static const LpcmSampleFormat signed16 = const LpcmSampleFormat._(3);
   static const LpcmSampleFormat signed24In32 = const LpcmSampleFormat._(4);
   static const LpcmSampleFormat float = const LpcmSampleFormat._(5);
 
   const LpcmSampleFormat._(int v) : super(v);
 
@@ skipping 52 matching lines @@
       case any:
         return 'LpcmSampleFormat.any';
       case unsigned8:
         return 'LpcmSampleFormat.unsigned8';
       case signed16:
         return 'LpcmSampleFormat.signed16';
       case signed24In32:
         return 'LpcmSampleFormat.signed24In32';
       case float:
         return 'LpcmSampleFormat.float';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
+
+
 class AudioEncoding extends bindings.MojoEnum {
   static const AudioEncoding unknown = const AudioEncoding._(0);
   static const AudioEncoding any = const AudioEncoding._(1);
   static const AudioEncoding vorbis = const AudioEncoding._(2);
 
   const AudioEncoding._(int v) : super(v);
 
   static const Map<String, AudioEncoding> valuesMap = const {
     "unknown": unknown,
     "any": any,
@@ skipping 31 matching lines @@
   }
 
   String toString() {
     switch(this) {
       case unknown:
         return 'AudioEncoding.unknown';
       case any:
         return 'AudioEncoding.any';
       case vorbis:
         return 'AudioEncoding.vorbis';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
+
+
 class VideoEncoding extends bindings.MojoEnum {
   static const VideoEncoding unknown = const VideoEncoding._(0);
   static const VideoEncoding any = const VideoEncoding._(1);
   static const VideoEncoding theora = const VideoEncoding._(2);
   static const VideoEncoding vp8 = const VideoEncoding._(3);
 
   const VideoEncoding._(int v) : super(v);
 
   static const Map<String, VideoEncoding> valuesMap = const {
     "unknown": unknown,
@@ skipping 38 matching lines @@
   String toString() {
     switch(this) {
       case unknown:
         return 'VideoEncoding.unknown';
       case any:
         return 'VideoEncoding.any';
       case theora:
         return 'VideoEncoding.theora';
       case vp8:
         return 'VideoEncoding.vp8';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
+
+
 class VideoProfile extends bindings.MojoEnum {
   static const VideoProfile unknown = const VideoProfile._(0);
   static const VideoProfile notApplicable = const VideoProfile._(1);
   static const VideoProfile h264Baseline = const VideoProfile._(2);
   static const VideoProfile h264Main = const VideoProfile._(3);
   static const VideoProfile h264Extended = const VideoProfile._(4);
   static const VideoProfile h264High = const VideoProfile._(5);
   static const VideoProfile h264High10 = const VideoProfile._(6);
   static const VideoProfile h264High422 = const VideoProfile._(7);
   static const VideoProfile h264High444Predictive = const VideoProfile._(8);
@@ skipping 101 matching lines @@
       case h264High444Predictive:
         return 'VideoProfile.h264High444Predictive';
       case h264ScalableBaseline:
         return 'VideoProfile.h264ScalableBaseline';
       case h264ScalableHigh:
         return 'VideoProfile.h264ScalableHigh';
       case h264StereoHigh:
         return 'VideoProfile.h264StereoHigh';
       case h264MultiviewHigh:
         return 'VideoProfile.h264MultiviewHigh';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
+
+
 class PixelFormat extends bindings.MojoEnum {
   static const PixelFormat unknown = const PixelFormat._(0);
   static const PixelFormat i420 = const PixelFormat._(1);
   static const PixelFormat yv12 = const PixelFormat._(2);
   static const PixelFormat yv16 = const PixelFormat._(3);
   static const PixelFormat yv12A = const PixelFormat._(4);
   static const PixelFormat yv24 = const PixelFormat._(5);
   static const PixelFormat nv12 = const PixelFormat._(6);
   static const PixelFormat nv21 = const PixelFormat._(7);
   static const PixelFormat uyvy = const PixelFormat._(8);
@@ skipping 122 matching lines @@
       case xrgb:
         return 'PixelFormat.xrgb';
       case rgb24:
         return 'PixelFormat.rgb24';
       case rgb32:
         return 'PixelFormat.rgb32';
       case mjpeg:
         return 'PixelFormat.mjpeg';
       case mt21:
         return 'PixelFormat.mt21';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
+
+
 class ColorSpace extends bindings.MojoEnum {
   static const ColorSpace unknown = const ColorSpace._(0);
   static const ColorSpace notApplicable = const ColorSpace._(1);
   static const ColorSpace jpeg = const ColorSpace._(2);
   static const ColorSpace hdRec709 = const ColorSpace._(3);
   static const ColorSpace sdRec601 = const ColorSpace._(4);
 
   const ColorSpace._(int v) : super(v);
 
   static const Map<String, ColorSpace> valuesMap = const {
@@ skipping 45 matching lines @@
       case unknown:
         return 'ColorSpace.unknown';
       case notApplicable:
         return 'ColorSpace.notApplicable';
       case jpeg:
         return 'ColorSpace.jpeg';
       case hdRec709:
         return 'ColorSpace.hdRec709';
       case sdRec601:
         return 'ColorSpace.sdRec601';
+      default:
+        return null;
     }
   }
 
   int toJson() => mojoEnumValue;
 }
 
 
 
+
+
 class MediaType extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(32, 0)
   ];
   MediaTypeScheme scheme = null;
   MediaTypeDetails details = null;
 
   MediaType() : super(kVersions.last.size);
 
   static MediaType deserialize(bindings.Message message) {
@@ skipping 60 matching lines @@
 
   Map toJson() {
     Map map = new Map();
     map["scheme"] = scheme;
     map["details"] = details;
     return map;
   }
 }
 
 
+
+
 class MediaTypeSet extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(32, 0)
   ];
   MediaTypeScheme scheme = null;
   MediaTypeSetDetails details = null;
 
   MediaTypeSet() : super(kVersions.last.size);
 
   static MediaTypeSet deserialize(bindings.Message message) {
@@ skipping 60 matching lines @@
 
   Map toJson() {
     Map map = new Map();
     map["scheme"] = scheme;
     map["details"] = details;
     return map;
   }
 }
 
 
+
+
 class LpcmMediaTypeDetails extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   LpcmSampleFormat sampleFormat = null;
   int channels = 0;
   int framesPerSecond = 0;
 
   LpcmMediaTypeDetails() : super(kVersions.last.size);
 
@@ skipping 69 matching lines @@
   Map toJson() {
     Map map = new Map();
     map["sampleFormat"] = sampleFormat;
     map["channels"] = channels;
     map["framesPerSecond"] = framesPerSecond;
     return map;
   }
 }
 
 
+
+
 class LpcmMediaTypeSetDetails extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(32, 0)
   ];
   LpcmSampleFormat sampleFormat = null;
   int minChannels = 0;
   int maxChannels = 0;
   int minFramesPerSecond = 0;
   int maxFramesPerSecond = 0;
 
@@ skipping 87 matching lines @@
     map["sampleFormat"] = sampleFormat;
     map["minChannels"] = minChannels;
     map["maxChannels"] = maxChannels;
     map["minFramesPerSecond"] = minFramesPerSecond;
     map["maxFramesPerSecond"] = maxFramesPerSecond;
     return map;
   }
 }
 
 
+
+
 class MultiplexedMediaTypeDetails extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   MediaType multiplexType = null;
   List<MediaType> substreamTypes = null;
 
   MultiplexedMediaTypeDetails() : super(kVersions.last.size);
 
   static MultiplexedMediaTypeDetails deserialize(bindings.Message message) {
@@ skipping 74 matching lines @@
 
   Map toJson() {
     Map map = new Map();
     map["multiplexType"] = multiplexType;
     map["substreamTypes"] = substreamTypes;
     return map;
   }
 }
 
 
+
+
 class MultiplexedMediaTypeSetDetails extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(24, 0)
   ];
   MediaTypeSet multiplexTypeSet = null;
   List<MediaTypeSet> substreamTypeSets = null;
 
   MultiplexedMediaTypeSetDetails() : super(kVersions.last.size);
 
   static MultiplexedMediaTypeSetDetails deserialize(bindings.Message message) {
@@ skipping 74 matching lines @@
 
   Map toJson() {
     Map map = new Map();
     map["multiplexTypeSet"] = multiplexTypeSet;
     map["substreamTypeSets"] = substreamTypeSets;
     return map;
   }
 }
 
 
+
+
 class CompressedAudioMediaTypeDetails extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(32, 0)
   ];
   AudioEncoding encoding = null;
   LpcmSampleFormat sampleFormat = null;
   int channels = 0;
   int framesPerSecond = 0;
   String extraDataBase64 = null;
 
@@ skipping 91 matching lines @@
     map["encoding"] = encoding;
     map["sampleFormat"] = sampleFormat;
     map["channels"] = channels;
     map["framesPerSecond"] = framesPerSecond;
     map["extraDataBase64"] = extraDataBase64;
     return map;
   }
 }
 
 
+
+
 class CompressedAudioMediaTypeSetDetails extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(32, 0)
   ];
   AudioEncoding encoding = null;
   LpcmSampleFormat sampleFormat = null;
   int minChannels = 0;
   int maxChannels = 0;
   int minFramesPerSecond = 0;
   int maxFramesPerSecond = 0;
@@ skipping 100 matching lines @@
     map["sampleFormat"] = sampleFormat;
     map["minChannels"] = minChannels;
     map["maxChannels"] = maxChannels;
     map["minFramesPerSecond"] = minFramesPerSecond;
     map["maxFramesPerSecond"] = maxFramesPerSecond;
     return map;
   }
 }
 
 
+
+
 class VideoMediaTypeDetails extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(48, 0)
   ];
   VideoEncoding encoding = null;
   VideoProfile profile = null;
   PixelFormat pixelFormat = null;
   ColorSpace colorSpace = null;
   int width = 0;
   int height = 0;
@@ skipping 135 matching lines @@
     map["width"] = width;
     map["height"] = height;
     map["codedWidth"] = codedWidth;
     map["codedHeight"] = codedHeight;
     map["extraDataBase64"] = extraDataBase64;
     return map;
   }
 }
 
 
+
+
 class VideoMediaTypeSetDetails extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(32, 0)
   ];
   VideoEncoding encoding = null;
   int minWidth = 0;
   int maxWidth = 0;
   int minHeight = 0;
   int maxHeight = 0;
 
@@ skipping 88 matching lines @@
     map["minWidth"] = minWidth;
     map["maxWidth"] = maxWidth;
     map["minHeight"] = minHeight;
     map["maxHeight"] = maxHeight;
     return map;
   }
 }
 
 
 
+
+
 enum MediaTypeDetailsTag {
   multiplexed,
   lpcm,
   compressedAudio,
   video,
   unknown
 }
 
 class MediaTypeDetails extends bindings.Union {
   static final _tag_to_int = const {
@@ skipping 139 matching lines @@
         break;
       default:
         result += "unknown";
     }
     result += ": $_data)";
     return result;
   }
 }
 
 
+
+
 enum MediaTypeSetDetailsTag {
   multiplexed,
   lpcm,
   compressedAudio,
   video,
   unknown
 }
 
 class MediaTypeSetDetails extends bindings.Union {
   static final _tag_to_int = const {
@@ skipping 138 matching lines @@
         result += "video";
         break;
       default:
         result += "unknown";
     }
     result += ": $_data)";
     return result;
   }
 }
 
+
+
+
+