Mojom updates for Motown.

mojo/dart/packages/mojo_services/lib/mojo/media/audio_track.mojom.dart

Index: mojo/dart/packages/mojo_services/lib/mojo/media/audio_track.mojom.dart
diff --git a/mojo/dart/packages/mojo_services/lib/mojo/terminal/terminal.mojom.dart b/mojo/dart/packages/mojo_services/lib/mojo/media/audio_track.mojom.dart
similarity index 56%
copy from mojo/dart/packages/mojo_services/lib/mojo/terminal/terminal.mojom.dart
copy to mojo/dart/packages/mojo_services/lib/mojo/media/audio_track.mojom.dart
index d07f1234f8f50311890009566bc1c6814ae72c2b..d777e296d702ea27d539df62924d2f6627202ce8 100644
--- a/mojo/dart/packages/mojo_services/lib/mojo/terminal/terminal.mojom.dart
+++ b/mojo/dart/packages/mojo_services/lib/mojo/media/audio_track.mojom.dart
@@ -2,28 +2,28 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-library terminal_mojom;
+library audio_track_mojom;
 
 import 'dart:async';
 
 import 'package:mojo/bindings.dart' as bindings;
 import 'package:mojo/core.dart' as core;
-import 'package:mojo_services/mojo/files/file.mojom.dart' as file_mojom;
-import 'package:mojo_services/mojo/files/types.mojom.dart' as types_mojom;
-import 'package:mojo_services/mojo/terminal/terminal_client.mojom.dart' as terminal_client_mojom;
+import 'package:mojo_services/mojo/media/media_common.mojom.dart' as media_common_mojom;
+import 'package:mojo_services/mojo/media/media_pipe.mojom.dart' as media_pipe_mojom;
+import 'package:mojo_services/mojo/media/media_types.mojom.dart' as media_types_mojom;
+import 'package:mojo_services/mojo/media/rate_control.mojom.dart' as rate_control_mojom;
 
 
 
-class _TerminalConnectParams extends bindings.Struct {
+class AudioTrackDescriptor extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
-  Object terminalFile = null;
-  bool force = false;
+  List<media_types_mojom.MediaTypeSet> supportedMediaTypes = null;
 
-  _TerminalConnectParams() : super(kVersions.last.size);
+  AudioTrackDescriptor() : super(kVersions.last.size);
 
-  static _TerminalConnectParams deserialize(bindings.Message message) {
+  static AudioTrackDescriptor deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -32,11 +32,11 @@ class _TerminalConnectParams extends bindings.Struct {
     return result;
   }
 
-  static _TerminalConnectParams decode(bindings.Decoder decoder0) {
+  static AudioTrackDescriptor decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    _TerminalConnectParams result = new _TerminalConnectParams();
+    AudioTrackDescriptor result = new AudioTrackDescriptor();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -58,11 +58,16 @@ class _TerminalConnectParams extends bindings.Struct {
     }
     if (mainDataHeader.version >= 0) {
       
-      result.terminalFile = decoder0.decodeInterfaceRequest(8, false, file_mojom.FileStub.newFromEndpoint);
-    }
-    if (mainDataHeader.version >= 0) {
-      
-      result.force = decoder0.decodeBool(12, 0);
+      var decoder1 = decoder0.decodePointer(8, false);
+      {
+        var si1 = decoder1.decodeDataHeaderForPointerArray(bindings.kUnspecifiedArrayLength);
+        result.supportedMediaTypes = new List<media_types_mojom.MediaTypeSet>(si1.numElements);
+        for (int i1 = 0; i1 < si1.numElements; ++i1) {
+          
+          var decoder2 = decoder1.decodePointer(bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i1, false);
+          result.supportedMediaTypes[i1] = media_types_mojom.MediaTypeSet.decode(decoder2);
+        }
+      }
     }
     return result;
   }
@@ -70,33 +75,42 @@ class _TerminalConnectParams extends bindings.Struct {
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     
-    encoder0.encodeInterfaceRequest(terminalFile, 8, false);
-    
-    encoder0.encodeBool(force, 12, 0);
+    if (supportedMediaTypes == null) {
+      encoder0.encodeNullPointer(8, false);
+    } else {
+      var encoder1 = encoder0.encodePointerArray(supportedMediaTypes.length, 8, bindings.kUnspecifiedArrayLength);
+      for (int i0 = 0; i0 < supportedMediaTypes.length; ++i0) {
+        
+        encoder1.encodeStruct(supportedMediaTypes[i0], bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i0, false);
+      }
+    }
   }
 
   String toString() {
-    return "_TerminalConnectParams("
-           "terminalFile: $terminalFile" ", "
-           "force: $force" ")";
+    return "AudioTrackDescriptor("
+           "supportedMediaTypes: $supportedMediaTypes" ")";
   }
 
   Map toJson() {
-    throw new bindings.MojoCodecError(
-        'Object containing handles cannot be encoded to JSON.');
+    Map map = new Map();
+    map["supportedMediaTypes"] = supportedMediaTypes;
+    return map;
   }
 }
 
 
-class TerminalConnectResponseParams extends bindings.Struct {
+class AudioTrackConfiguration extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(16, 0)
+    const bindings.StructDataHeader(32, 0)
   ];
-  types_mojom.Error error = null;
+  media_types_mojom.MediaType mediaType = null;
+  int maxFrames = 0;
+  int audioFrameRatio = 1;
+  int mediaTimeRatio = 1;
 
-  TerminalConnectResponseParams() : super(kVersions.last.size);
+  AudioTrackConfiguration() : super(kVersions.last.size);
 
-  static TerminalConnectResponseParams deserialize(bindings.Message message) {
+  static AudioTrackConfiguration deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -105,11 +119,11 @@ class TerminalConnectResponseParams extends bindings.Struct {
     return result;
   }
 
-  static TerminalConnectResponseParams decode(bindings.Decoder decoder0) {
+  static AudioTrackConfiguration decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    TerminalConnectResponseParams result = new TerminalConnectResponseParams();
+    AudioTrackConfiguration result = new AudioTrackConfiguration();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -131,11 +145,20 @@ class TerminalConnectResponseParams extends bindings.Struct {
     }
     if (mainDataHeader.version >= 0) {
       
-        result.error = types_mojom.Error.decode(decoder0, 8);
-        if (result.error == null) {
-          throw new bindings.MojoCodecError(
-            'Trying to decode null union for non-nullable types_mojom.Error.');
-        }
+      var decoder1 = decoder0.decodePointer(8, false);
+      result.mediaType = media_types_mojom.MediaType.decode(decoder1);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.maxFrames = decoder0.decodeUint64(16);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.audioFrameRatio = decoder0.decodeUint32(24);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.mediaTimeRatio = decoder0.decodeUint32(28);
     }
     return result;
   }
@@ -143,32 +166,42 @@ class TerminalConnectResponseParams extends bindings.Struct {
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     
-    encoder0.encodeEnum(error, 8);
+    encoder0.encodeStruct(mediaType, 8, false);
+    
+    encoder0.encodeUint64(maxFrames, 16);
+    
+    encoder0.encodeUint32(audioFrameRatio, 24);
+    
+    encoder0.encodeUint32(mediaTimeRatio, 28);
   }
 
   String toString() {
-    return "TerminalConnectResponseParams("
-           "error: $error" ")";
+    return "AudioTrackConfiguration("
+           "mediaType: $mediaType" ", "
+           "maxFrames: $maxFrames" ", "
+           "audioFrameRatio: $audioFrameRatio" ", "
+           "mediaTimeRatio: $mediaTimeRatio" ")";
   }
 
   Map toJson() {
     Map map = new Map();
-    map["error"] = error;
+    map["mediaType"] = mediaType;
+    map["maxFrames"] = maxFrames;
+    map["audioFrameRatio"] = audioFrameRatio;
+    map["mediaTimeRatio"] = mediaTimeRatio;
     return map;
   }
 }
 
 
-class _TerminalConnectToClientParams extends bindings.Struct {
+class _AudioTrackDescribeParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(24, 0)
+    const bindings.StructDataHeader(8, 0)
   ];
-  Object terminalClient = null;
-  bool force = false;
 
-  _TerminalConnectToClientParams() : super(kVersions.last.size);
+  _AudioTrackDescribeParams() : super(kVersions.last.size);
 
-  static _TerminalConnectToClientParams deserialize(bindings.Message message) {
+  static _AudioTrackDescribeParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -177,11 +210,11 @@ class _TerminalConnectToClientParams extends bindings.Struct {
     return result;
   }
 
-  static _TerminalConnectToClientParams decode(bindings.Decoder decoder0) {
+  static _AudioTrackDescribeParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    _TerminalConnectToClientParams result = new _TerminalConnectToClientParams();
+    _AudioTrackDescribeParams result = new _AudioTrackDescribeParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -201,47 +234,33 @@ class _TerminalConnectToClientParams extends bindings.Struct {
         'Message newer than the last known version cannot be shorter than '
         'required by the last known version.');
     }
-    if (mainDataHeader.version >= 0) {
-      
-      result.terminalClient = decoder0.decodeServiceInterface(8, false, terminal_client_mojom.TerminalClientProxy.newFromEndpoint);
-    }
-    if (mainDataHeader.version >= 0) {
-      
-      result.force = decoder0.decodeBool(16, 0);
-    }
     return result;
   }
 
   void encode(bindings.Encoder encoder) {
-    var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
-    
-    encoder0.encodeInterface(terminalClient, 8, false);
-    
-    encoder0.encodeBool(force, 16, 0);
+    encoder.getStructEncoderAtOffset(kVersions.last);
   }
 
   String toString() {
-    return "_TerminalConnectToClientParams("
-           "terminalClient: $terminalClient" ", "
-           "force: $force" ")";
+    return "_AudioTrackDescribeParams("")";
   }
 
   Map toJson() {
-    throw new bindings.MojoCodecError(
-        'Object containing handles cannot be encoded to JSON.');
+    Map map = new Map();
+    return map;
   }
 }
 
 
-class TerminalConnectToClientResponseParams extends bindings.Struct {
+class AudioTrackDescribeResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
-  types_mojom.Error error = null;
+  AudioTrackDescriptor descriptor = null;
 
-  TerminalConnectToClientResponseParams() : super(kVersions.last.size);
+  AudioTrackDescribeResponseParams() : super(kVersions.last.size);
 
-  static TerminalConnectToClientResponseParams deserialize(bindings.Message message) {
+  static AudioTrackDescribeResponseParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -250,11 +269,11 @@ class TerminalConnectToClientResponseParams extends bindings.Struct {
     return result;
   }
 
-  static TerminalConnectToClientResponseParams decode(bindings.Decoder decoder0) {
+  static AudioTrackDescribeResponseParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    TerminalConnectToClientResponseParams result = new TerminalConnectToClientResponseParams();
+    AudioTrackDescribeResponseParams result = new AudioTrackDescribeResponseParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -276,11 +295,8 @@ class TerminalConnectToClientResponseParams extends bindings.Struct {
     }
     if (mainDataHeader.version >= 0) {
       
-        result.error = types_mojom.Error.decode(decoder0, 8);
-        if (result.error == null) {
-          throw new bindings.MojoCodecError(
-            'Trying to decode null union for non-nullable types_mojom.Error.');
-        }
+      var decoder1 = decoder0.decodePointer(8, false);
+      result.descriptor = AudioTrackDescriptor.decode(decoder1);
     }
     return result;
   }
@@ -288,30 +304,32 @@ class TerminalConnectToClientResponseParams extends bindings.Struct {
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     
-    encoder0.encodeEnum(error, 8);
+    encoder0.encodeStruct(descriptor, 8, false);
   }
 
   String toString() {
-    return "TerminalConnectToClientResponseParams("
-           "error: $error" ")";
+    return "AudioTrackDescribeResponseParams("
+           "descriptor: $descriptor" ")";
   }
 
   Map toJson() {
     Map map = new Map();
-    map["error"] = error;
+    map["descriptor"] = descriptor;
     return map;
   }
 }
 
 
-class _TerminalGetSizeParams extends bindings.Struct {
+class _AudioTrackConfigureParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(8, 0)
+    const bindings.StructDataHeader(24, 0)
   ];
+  AudioTrackConfiguration configuration = null;
+  Object pipe = null;
 
-  _TerminalGetSizeParams() : super(kVersions.last.size);
+  _AudioTrackConfigureParams() : super(kVersions.last.size);
 
-  static _TerminalGetSizeParams deserialize(bindings.Message message) {
+  static _AudioTrackConfigureParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -320,11 +338,11 @@ class _TerminalGetSizeParams extends bindings.Struct {
     return result;
   }
 
-  static _TerminalGetSizeParams decode(bindings.Decoder decoder0) {
+  static _AudioTrackConfigureParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    _TerminalGetSizeParams result = new _TerminalGetSizeParams();
+    _AudioTrackConfigureParams result = new _AudioTrackConfigureParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -344,35 +362,48 @@ class _TerminalGetSizeParams extends bindings.Struct {
         'Message newer than the last known version cannot be shorter than '
         'required by the last known version.');
     }
+    if (mainDataHeader.version >= 0) {
+      
+      var decoder1 = decoder0.decodePointer(8, false);
+      result.configuration = AudioTrackConfiguration.decode(decoder1);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.pipe = decoder0.decodeInterfaceRequest(16, false, media_pipe_mojom.MediaPipeStub.newFromEndpoint);
+    }
     return result;
   }
 
   void encode(bindings.Encoder encoder) {
-    encoder.getStructEncoderAtOffset(kVersions.last);
+    var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
+    
+    encoder0.encodeStruct(configuration, 8, false);
+    
+    encoder0.encodeInterfaceRequest(pipe, 16, false);
   }
 
   String toString() {
-    return "_TerminalGetSizeParams("")";
+    return "_AudioTrackConfigureParams("
+           "configuration: $configuration" ", "
+           "pipe: $pipe" ")";
   }
 
   Map toJson() {
-    Map map = new Map();
-    return map;
+    throw new bindings.MojoCodecError(
+        'Object containing handles cannot be encoded to JSON.');
   }
 }
 
 
-class TerminalGetSizeResponseParams extends bindings.Struct {
+class AudioTrackConfigureResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(24, 0)
+    const bindings.StructDataHeader(16, 0)
   ];
-  types_mojom.Error error = null;
-  int rows = 0;
-  int columns = 0;
+  media_common_mojom.MediaResult result = null;
 
-  TerminalGetSizeResponseParams() : super(kVersions.last.size);
+  AudioTrackConfigureResponseParams() : super(kVersions.last.size);
 
-  static TerminalGetSizeResponseParams deserialize(bindings.Message message) {
+  static AudioTrackConfigureResponseParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -381,11 +412,11 @@ class TerminalGetSizeResponseParams extends bindings.Struct {
     return result;
   }
 
-  static TerminalGetSizeResponseParams decode(bindings.Decoder decoder0) {
+  static AudioTrackConfigureResponseParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    TerminalGetSizeResponseParams result = new TerminalGetSizeResponseParams();
+    AudioTrackConfigureResponseParams result = new AudioTrackConfigureResponseParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -407,61 +438,43 @@ class TerminalGetSizeResponseParams extends bindings.Struct {
     }
     if (mainDataHeader.version >= 0) {
       
-        result.error = types_mojom.Error.decode(decoder0, 8);
-        if (result.error == null) {
+        result.result = media_common_mojom.MediaResult.decode(decoder0, 8);
+        if (result.result == null) {
           throw new bindings.MojoCodecError(
-            'Trying to decode null union for non-nullable types_mojom.Error.');
+            'Trying to decode null union for non-nullable media_common_mojom.MediaResult.');
         }
     }
-    if (mainDataHeader.version >= 0) {
-      
-      result.rows = decoder0.decodeUint32(12);
-    }
-    if (mainDataHeader.version >= 0) {
-      
-      result.columns = decoder0.decodeUint32(16);
-    }
     return result;
   }
 
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     
-    encoder0.encodeEnum(error, 8);
-    
-    encoder0.encodeUint32(rows, 12);
-    
-    encoder0.encodeUint32(columns, 16);
+    encoder0.encodeEnum(result, 8);
   }
 
   String toString() {
-    return "TerminalGetSizeResponseParams("
-           "error: $error" ", "
-           "rows: $rows" ", "
-           "columns: $columns" ")";
+    return "AudioTrackConfigureResponseParams("
+           "result: $result" ")";
   }
 
   Map toJson() {
     Map map = new Map();
-    map["error"] = error;
-    map["rows"] = rows;
-    map["columns"] = columns;
+    map["result"] = result;
     return map;
   }
 }
 
 
-class _TerminalSetSizeParams extends bindings.Struct {
+class _AudioTrackGetRateControlParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(24, 0)
+    const bindings.StructDataHeader(16, 0)
   ];
-  int rows = 0;
-  int columns = 0;
-  bool reset = false;
+  Object rateControl = null;
 
-  _TerminalSetSizeParams() : super(kVersions.last.size);
+  _AudioTrackGetRateControlParams() : super(kVersions.last.size);
 
-  static _TerminalSetSizeParams deserialize(bindings.Message message) {
+  static _AudioTrackGetRateControlParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -470,11 +483,11 @@ class _TerminalSetSizeParams extends bindings.Struct {
     return result;
   }
 
-  static _TerminalSetSizeParams decode(bindings.Decoder decoder0) {
+  static _AudioTrackGetRateControlParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    _TerminalSetSizeParams result = new _TerminalSetSizeParams();
+    _AudioTrackGetRateControlParams result = new _AudioTrackGetRateControlParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -496,15 +509,7 @@ class _TerminalSetSizeParams extends bindings.Struct {
     }
     if (mainDataHeader.version >= 0) {
       
-      result.rows = decoder0.decodeUint32(8);
-    }
-    if (mainDataHeader.version >= 0) {
-      
-      result.columns = decoder0.decodeUint32(12);
-    }
-    if (mainDataHeader.version >= 0) {
-      
-      result.reset = decoder0.decodeBool(16, 0);
+      result.rateControl = decoder0.decodeInterfaceRequest(8, false, rate_control_mojom.RateControlStub.newFromEndpoint);
     }
     return result;
   }
@@ -512,41 +517,30 @@ class _TerminalSetSizeParams extends bindings.Struct {
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     
-    encoder0.encodeUint32(rows, 8);
-    
-    encoder0.encodeUint32(columns, 12);
-    
-    encoder0.encodeBool(reset, 16, 0);
+    encoder0.encodeInterfaceRequest(rateControl, 8, false);
   }
 
   String toString() {
-    return "_TerminalSetSizeParams("
-           "rows: $rows" ", "
-           "columns: $columns" ", "
-           "reset: $reset" ")";
+    return "_AudioTrackGetRateControlParams("
+           "rateControl: $rateControl" ")";
   }
 
   Map toJson() {
-    Map map = new Map();
-    map["rows"] = rows;
-    map["columns"] = columns;
-    map["reset"] = reset;
-    return map;
+    throw new bindings.MojoCodecError(
+        'Object containing handles cannot be encoded to JSON.');
   }
 }
 
 
-class TerminalSetSizeResponseParams extends bindings.Struct {
+class AudioTrackGetRateControlResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(24, 0)
+    const bindings.StructDataHeader(16, 0)
   ];
-  types_mojom.Error error = null;
-  int rows = 0;
-  int columns = 0;
+  media_common_mojom.MediaResult result = null;
 
-  TerminalSetSizeResponseParams() : super(kVersions.last.size);
+  AudioTrackGetRateControlResponseParams() : super(kVersions.last.size);
 
-  static TerminalSetSizeResponseParams deserialize(bindings.Message message) {
+  static AudioTrackGetRateControlResponseParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -555,11 +549,11 @@ class TerminalSetSizeResponseParams extends bindings.Struct {
     return result;
   }
 
-  static TerminalSetSizeResponseParams decode(bindings.Decoder decoder0) {
+  static AudioTrackGetRateControlResponseParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    TerminalSetSizeResponseParams result = new TerminalSetSizeResponseParams();
+    AudioTrackGetRateControlResponseParams result = new AudioTrackGetRateControlResponseParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -581,82 +575,64 @@ class TerminalSetSizeResponseParams extends bindings.Struct {
     }
     if (mainDataHeader.version >= 0) {
       
-        result.error = types_mojom.Error.decode(decoder0, 8);
-        if (result.error == null) {
+        result.result = media_common_mojom.MediaResult.decode(decoder0, 8);
+        if (result.result == null) {
           throw new bindings.MojoCodecError(
-            'Trying to decode null union for non-nullable types_mojom.Error.');
+            'Trying to decode null union for non-nullable media_common_mojom.MediaResult.');
         }
     }
-    if (mainDataHeader.version >= 0) {
-      
-      result.rows = decoder0.decodeUint32(12);
-    }
-    if (mainDataHeader.version >= 0) {
-      
-      result.columns = decoder0.decodeUint32(16);
-    }
     return result;
   }
 
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     
-    encoder0.encodeEnum(error, 8);
-    
-    encoder0.encodeUint32(rows, 12);
-    
-    encoder0.encodeUint32(columns, 16);
+    encoder0.encodeEnum(result, 8);
   }
 
   String toString() {
-    return "TerminalSetSizeResponseParams("
-           "error: $error" ", "
-           "rows: $rows" ", "
-           "columns: $columns" ")";
+    return "AudioTrackGetRateControlResponseParams("
+           "result: $result" ")";
   }
 
   Map toJson() {
     Map map = new Map();
-    map["error"] = error;
-    map["rows"] = rows;
-    map["columns"] = columns;
+    map["result"] = result;
     return map;
   }
 }
 
-const int _Terminal_connectName = 0;
-const int _Terminal_connectToClientName = 1;
-const int _Terminal_getSizeName = 2;
-const int _Terminal_setSizeName = 3;
-
-abstract class Terminal {
-  static const String serviceName = "mojo::terminal::Terminal";
-  dynamic connect(Object terminalFile,bool force,[Function responseFactory = null]);
-  dynamic connectToClient(Object terminalClient,bool force,[Function responseFactory = null]);
-  dynamic getSize([Function responseFactory = null]);
-  dynamic setSize(int rows,int columns,bool reset,[Function responseFactory = null]);
+const int _AudioTrack_describeName = 0;
+const int _AudioTrack_configureName = 1;
+const int _AudioTrack_getRateControlName = 2;
+
+abstract class AudioTrack {
+  static const String serviceName = null;
+  dynamic describe([Function responseFactory = null]);
+  dynamic configure(AudioTrackConfiguration configuration,Object pipe,[Function responseFactory = null]);
+  dynamic getRateControl(Object rateControl,[Function responseFactory = null]);
 }
 
 
-class _TerminalProxyImpl extends bindings.Proxy {
-  _TerminalProxyImpl.fromEndpoint(
+class _AudioTrackProxyImpl extends bindings.Proxy {
+  _AudioTrackProxyImpl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
-  _TerminalProxyImpl.fromHandle(core.MojoHandle handle) :
+  _AudioTrackProxyImpl.fromHandle(core.MojoHandle handle) :
       super.fromHandle(handle);
 
-  _TerminalProxyImpl.unbound() : super.unbound();
+  _AudioTrackProxyImpl.unbound() : super.unbound();
 
-  static _TerminalProxyImpl newFromEndpoint(
+  static _AudioTrackProxyImpl newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For _TerminalProxyImpl"));
-    return new _TerminalProxyImpl.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For _AudioTrackProxyImpl"));
+    return new _AudioTrackProxyImpl.fromEndpoint(endpoint);
   }
 
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
-      case _Terminal_connectName:
-        var r = TerminalConnectResponseParams.deserialize(
+      case _AudioTrack_describeName:
+        var r = AudioTrackDescribeResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
@@ -675,8 +651,8 @@ class _TerminalProxyImpl extends bindings.Proxy {
         }
         c.complete(r);
         break;
-      case _Terminal_connectToClientName:
-        var r = TerminalConnectToClientResponseParams.deserialize(
+      case _AudioTrack_configureName:
+        var r = AudioTrackConfigureResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
@@ -695,28 +671,8 @@ class _TerminalProxyImpl extends bindings.Proxy {
         }
         c.complete(r);
         break;
-      case _Terminal_getSizeName:
-        var r = TerminalGetSizeResponseParams.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) {
-          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);
-        break;
-      case _Terminal_setSizeName:
-        var r = TerminalSetSizeResponseParams.deserialize(
+      case _AudioTrack_getRateControlName:
+        var r = AudioTrackGetRateControlResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
@@ -744,95 +700,83 @@ class _TerminalProxyImpl extends bindings.Proxy {
 
   String toString() {
     var superString = super.toString();
-    return "_TerminalProxyImpl($superString)";
+    return "_AudioTrackProxyImpl($superString)";
   }
 }
 
 
-class _TerminalProxyCalls implements Terminal {
-  _TerminalProxyImpl _proxyImpl;
+class _AudioTrackProxyCalls implements AudioTrack {
+  _AudioTrackProxyImpl _proxyImpl;
 
-  _TerminalProxyCalls(this._proxyImpl);
-    dynamic connect(Object terminalFile,bool force,[Function responseFactory = null]) {
-      var params = new _TerminalConnectParams();
-      params.terminalFile = terminalFile;
-      params.force = force;
-      return _proxyImpl.sendMessageWithRequestId(
-          params,
-          _Terminal_connectName,
-          -1,
-          bindings.MessageHeader.kMessageExpectsResponse);
-    }
-    dynamic connectToClient(Object terminalClient,bool force,[Function responseFactory = null]) {
-      var params = new _TerminalConnectToClientParams();
-      params.terminalClient = terminalClient;
-      params.force = force;
+  _AudioTrackProxyCalls(this._proxyImpl);
+    dynamic describe([Function responseFactory = null]) {
+      var params = new _AudioTrackDescribeParams();
       return _proxyImpl.sendMessageWithRequestId(
           params,
-          _Terminal_connectToClientName,
+          _AudioTrack_describeName,
           -1,
           bindings.MessageHeader.kMessageExpectsResponse);
     }
-    dynamic getSize([Function responseFactory = null]) {
-      var params = new _TerminalGetSizeParams();
+    dynamic configure(AudioTrackConfiguration configuration,Object pipe,[Function responseFactory = null]) {
+      var params = new _AudioTrackConfigureParams();
+      params.configuration = configuration;
+      params.pipe = pipe;
       return _proxyImpl.sendMessageWithRequestId(
           params,
-          _Terminal_getSizeName,
+          _AudioTrack_configureName,
           -1,
           bindings.MessageHeader.kMessageExpectsResponse);
     }
-    dynamic setSize(int rows,int columns,bool reset,[Function responseFactory = null]) {
-      var params = new _TerminalSetSizeParams();
-      params.rows = rows;
-      params.columns = columns;
-      params.reset = reset;
+    dynamic getRateControl(Object rateControl,[Function responseFactory = null]) {
+      var params = new _AudioTrackGetRateControlParams();
+      params.rateControl = rateControl;
       return _proxyImpl.sendMessageWithRequestId(
           params,
-          _Terminal_setSizeName,
+          _AudioTrack_getRateControlName,
           -1,
           bindings.MessageHeader.kMessageExpectsResponse);
     }
 }
 
 
-class TerminalProxy implements bindings.ProxyBase {
+class AudioTrackProxy implements bindings.ProxyBase {
   final bindings.Proxy impl;
-  Terminal ptr;
+  AudioTrack ptr;
 
-  TerminalProxy(_TerminalProxyImpl proxyImpl) :
+  AudioTrackProxy(_AudioTrackProxyImpl proxyImpl) :
       impl = proxyImpl,
-      ptr = new _TerminalProxyCalls(proxyImpl);
+      ptr = new _AudioTrackProxyCalls(proxyImpl);
 
-  TerminalProxy.fromEndpoint(
+  AudioTrackProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) :
-      impl = new _TerminalProxyImpl.fromEndpoint(endpoint) {
-    ptr = new _TerminalProxyCalls(impl);
+      impl = new _AudioTrackProxyImpl.fromEndpoint(endpoint) {
+    ptr = new _AudioTrackProxyCalls(impl);
   }
 
-  TerminalProxy.fromHandle(core.MojoHandle handle) :
-      impl = new _TerminalProxyImpl.fromHandle(handle) {
-    ptr = new _TerminalProxyCalls(impl);
+  AudioTrackProxy.fromHandle(core.MojoHandle handle) :
+      impl = new _AudioTrackProxyImpl.fromHandle(handle) {
+    ptr = new _AudioTrackProxyCalls(impl);
   }
 
-  TerminalProxy.unbound() :
-      impl = new _TerminalProxyImpl.unbound() {
-    ptr = new _TerminalProxyCalls(impl);
+  AudioTrackProxy.unbound() :
+      impl = new _AudioTrackProxyImpl.unbound() {
+    ptr = new _AudioTrackProxyCalls(impl);
   }
 
-  factory TerminalProxy.connectToService(
+  factory AudioTrackProxy.connectToService(
       bindings.ServiceConnector s, String url, [String serviceName]) {
-    TerminalProxy p = new TerminalProxy.unbound();
+    AudioTrackProxy p = new AudioTrackProxy.unbound();
     s.connectToService(url, p, serviceName);
     return p;
   }
 
-  static TerminalProxy newFromEndpoint(
+  static AudioTrackProxy newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For TerminalProxy"));
-    return new TerminalProxy.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For AudioTrackProxy"));
+    return new AudioTrackProxy.fromEndpoint(endpoint);
   }
 
-  String get serviceName => Terminal.serviceName;
+  String get serviceName => AudioTrack.serviceName;
 
   Future close({bool immediate: false}) => impl.close(immediate: immediate);
 
@@ -849,52 +793,43 @@ class TerminalProxy implements bindings.ProxyBase {
   }
 
   String toString() {
-    return "TerminalProxy($impl)";
+    return "AudioTrackProxy($impl)";
   }
 }
 
 
-class TerminalStub extends bindings.Stub {
-  Terminal _impl = null;
+class AudioTrackStub extends bindings.Stub {
+  AudioTrack _impl = null;
 
-  TerminalStub.fromEndpoint(
+  AudioTrackStub.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [this._impl])
       : super.fromEndpoint(endpoint);
 
-  TerminalStub.fromHandle(core.MojoHandle handle, [this._impl])
+  AudioTrackStub.fromHandle(core.MojoHandle handle, [this._impl])
       : super.fromHandle(handle);
 
-  TerminalStub.unbound() : super.unbound();
+  AudioTrackStub.unbound() : super.unbound();
 
-  static TerminalStub newFromEndpoint(
+  static AudioTrackStub newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For TerminalStub"));
-    return new TerminalStub.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For AudioTrackStub"));
+    return new AudioTrackStub.fromEndpoint(endpoint);
   }
 
 
-  TerminalConnectResponseParams _TerminalConnectResponseParamsFactory(types_mojom.Error error) {
-    var mojo_factory_result = new TerminalConnectResponseParams();
-    mojo_factory_result.error = error;
-    return mojo_factory_result;
-  }
-  TerminalConnectToClientResponseParams _TerminalConnectToClientResponseParamsFactory(types_mojom.Error error) {
-    var mojo_factory_result = new TerminalConnectToClientResponseParams();
-    mojo_factory_result.error = error;
+  AudioTrackDescribeResponseParams _AudioTrackDescribeResponseParamsFactory(AudioTrackDescriptor descriptor) {
+    var mojo_factory_result = new AudioTrackDescribeResponseParams();
+    mojo_factory_result.descriptor = descriptor;
     return mojo_factory_result;
   }
-  TerminalGetSizeResponseParams _TerminalGetSizeResponseParamsFactory(types_mojom.Error error, int rows, int columns) {
-    var mojo_factory_result = new TerminalGetSizeResponseParams();
-    mojo_factory_result.error = error;
-    mojo_factory_result.rows = rows;
-    mojo_factory_result.columns = columns;
+  AudioTrackConfigureResponseParams _AudioTrackConfigureResponseParamsFactory(media_common_mojom.MediaResult result) {
+    var mojo_factory_result = new AudioTrackConfigureResponseParams();
+    mojo_factory_result.result = result;
     return mojo_factory_result;
   }
-  TerminalSetSizeResponseParams _TerminalSetSizeResponseParamsFactory(types_mojom.Error error, int rows, int columns) {
-    var mojo_factory_result = new TerminalSetSizeResponseParams();
-    mojo_factory_result.error = error;
-    mojo_factory_result.rows = rows;
-    mojo_factory_result.columns = columns;
+  AudioTrackGetRateControlResponseParams _AudioTrackGetRateControlResponseParamsFactory(media_common_mojom.MediaResult result) {
+    var mojo_factory_result = new AudioTrackGetRateControlResponseParams();
+    mojo_factory_result.result = result;
     return mojo_factory_result;
   }
 
@@ -906,38 +841,16 @@ class TerminalStub extends bindings.Stub {
     }
     assert(_impl != null);
     switch (message.header.type) {
-      case _Terminal_connectName:
-        var params = _TerminalConnectParams.deserialize(
-            message.payload);
-        var response = _impl.connect(params.terminalFile,params.force,_TerminalConnectResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  _Terminal_connectName,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              _Terminal_connectName,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
-        break;
-      case _Terminal_connectToClientName:
-        var params = _TerminalConnectToClientParams.deserialize(
+      case _AudioTrack_describeName:
+        var params = _AudioTrackDescribeParams.deserialize(
             message.payload);
-        var response = _impl.connectToClient(params.terminalClient,params.force,_TerminalConnectToClientResponseParamsFactory);
+        var response = _impl.describe(_AudioTrackDescribeResponseParamsFactory);
         if (response is Future) {
           return response.then((response) {
             if (response != null) {
               return buildResponseWithId(
                   response,
-                  _Terminal_connectToClientName,
+                  _AudioTrack_describeName,
                   message.header.requestId,
                   bindings.MessageHeader.kMessageIsResponse);
             }
@@ -945,21 +858,21 @@ class TerminalStub extends bindings.Stub {
         } else if (response != null) {
           return buildResponseWithId(
               response,
-              _Terminal_connectToClientName,
+              _AudioTrack_describeName,
               message.header.requestId,
               bindings.MessageHeader.kMessageIsResponse);
         }
         break;
-      case _Terminal_getSizeName:
-        var params = _TerminalGetSizeParams.deserialize(
+      case _AudioTrack_configureName:
+        var params = _AudioTrackConfigureParams.deserialize(
             message.payload);
-        var response = _impl.getSize(_TerminalGetSizeResponseParamsFactory);
+        var response = _impl.configure(params.configuration,params.pipe,_AudioTrackConfigureResponseParamsFactory);
         if (response is Future) {
           return response.then((response) {
             if (response != null) {
               return buildResponseWithId(
                   response,
-                  _Terminal_getSizeName,
+                  _AudioTrack_configureName,
                   message.header.requestId,
                   bindings.MessageHeader.kMessageIsResponse);
             }
@@ -967,21 +880,21 @@ class TerminalStub extends bindings.Stub {
         } else if (response != null) {
           return buildResponseWithId(
               response,
-              _Terminal_getSizeName,
+              _AudioTrack_configureName,
               message.header.requestId,
               bindings.MessageHeader.kMessageIsResponse);
         }
         break;
-      case _Terminal_setSizeName:
-        var params = _TerminalSetSizeParams.deserialize(
+      case _AudioTrack_getRateControlName:
+        var params = _AudioTrackGetRateControlParams.deserialize(
             message.payload);
-        var response = _impl.setSize(params.rows,params.columns,params.reset,_TerminalSetSizeResponseParamsFactory);
+        var response = _impl.getRateControl(params.rateControl,_AudioTrackGetRateControlResponseParamsFactory);
         if (response is Future) {
           return response.then((response) {
             if (response != null) {
               return buildResponseWithId(
                   response,
-                  _Terminal_setSizeName,
+                  _AudioTrack_getRateControlName,
                   message.header.requestId,
                   bindings.MessageHeader.kMessageIsResponse);
             }
@@ -989,7 +902,7 @@ class TerminalStub extends bindings.Stub {
         } else if (response != null) {
           return buildResponseWithId(
               response,
-              _Terminal_setSizeName,
+              _AudioTrack_getRateControlName,
               message.header.requestId,
               bindings.MessageHeader.kMessageIsResponse);
         }
@@ -1001,15 +914,15 @@ class TerminalStub extends bindings.Stub {
     return null;
   }
 
-  Terminal get impl => _impl;
-  set impl(Terminal d) {
+  AudioTrack get impl => _impl;
+  set impl(AudioTrack d) {
     assert(_impl == null);
     _impl = d;
   }
 
   String toString() {
     var superString = super.toString();
-    return "TerminalStub($superString)";
+    return "AudioTrackStub($superString)";
   }
 
   int get version => 0;