Mojom updates for Motown.

mojo/dart/packages/mojo_services/lib/mojo/media/audio_track.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 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) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     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) {
       // Scan in reverse order to optimize for more recent versions.
       for (int i = kVersions.length - 1; i >= 0; --i) {
         if (mainDataHeader.version >= kVersions[i].version) {
           if (mainDataHeader.size == kVersions[i].size) {
             // Found a match.
             break;
           }
           throw new bindings.MojoCodecError(
               'Header size doesn\'t correspond to known version size.');
         }
       }
     } else if (mainDataHeader.size < kVersions.last.size) {
       throw new bindings.MojoCodecError(
         'Message newer than the last known version cannot be shorter than '
         'required by the last known version.');
     }
     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;
   }
 
   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) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     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) {
       // Scan in reverse order to optimize for more recent versions.
       for (int i = kVersions.length - 1; i >= 0; --i) {
         if (mainDataHeader.version >= kVersions[i].version) {
           if (mainDataHeader.size == kVersions[i].size) {
             // Found a match.
             break;
           }
           throw new bindings.MojoCodecError(
               'Header size doesn\'t correspond to known version size.');
         }
       }
     } else if (mainDataHeader.size < kVersions.last.size) {
       throw new bindings.MojoCodecError(
         'Message newer than the last known version cannot be shorter than '
         'required by the last known version.');
     }
     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;
   }
 
   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) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     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) {
       // Scan in reverse order to optimize for more recent versions.
       for (int i = kVersions.length - 1; i >= 0; --i) {
         if (mainDataHeader.version >= kVersions[i].version) {
           if (mainDataHeader.size == kVersions[i].size) {
             // Found a match.
             break;
           }
           throw new bindings.MojoCodecError(
               'Header size doesn\'t correspond to known version size.');
         }
       }
     } else if (mainDataHeader.size < kVersions.last.size) {
       throw new bindings.MojoCodecError(
         '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) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     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) {
       // Scan in reverse order to optimize for more recent versions.
       for (int i = kVersions.length - 1; i >= 0; --i) {
         if (mainDataHeader.version >= kVersions[i].version) {
           if (mainDataHeader.size == kVersions[i].size) {
             // Found a match.
             break;
           }
           throw new bindings.MojoCodecError(
               'Header size doesn\'t correspond to known version size.');
         }
       }
     } else if (mainDataHeader.size < kVersions.last.size) {
       throw new bindings.MojoCodecError(
         'Message newer than the last known version cannot be shorter than '
         'required by the last known version.');
     }
     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;
   }
 
   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) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     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) {
       // Scan in reverse order to optimize for more recent versions.
       for (int i = kVersions.length - 1; i >= 0; --i) {
         if (mainDataHeader.version >= kVersions[i].version) {
           if (mainDataHeader.size == kVersions[i].size) {
             // Found a match.
             break;
           }
           throw new bindings.MojoCodecError(
               'Header size doesn\'t correspond to known version size.');
         }
       }
     } else if (mainDataHeader.size < kVersions.last.size) {
       throw new bindings.MojoCodecError(
         '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) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     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) {
       // Scan in reverse order to optimize for more recent versions.
       for (int i = kVersions.length - 1; i >= 0; --i) {
         if (mainDataHeader.version >= kVersions[i].version) {
           if (mainDataHeader.size == kVersions[i].size) {
             // Found a match.
             break;
           }
           throw new bindings.MojoCodecError(
               'Header size doesn\'t correspond to known version size.');
         }
       }
     } else if (mainDataHeader.size < kVersions.last.size) {
       throw new bindings.MojoCodecError(
         'Message newer than the last known version cannot be shorter than '
         'required by the last known version.');
     }
     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) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     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) {
       // Scan in reverse order to optimize for more recent versions.
       for (int i = kVersions.length - 1; i >= 0; --i) {
         if (mainDataHeader.version >= kVersions[i].version) {
           if (mainDataHeader.size == kVersions[i].size) {
             // Found a match.
             break;
           }
           throw new bindings.MojoCodecError(
               'Header size doesn\'t correspond to known version size.');
         }
       }
     } else if (mainDataHeader.size < kVersions.last.size) {
       throw new bindings.MojoCodecError(
         'Message newer than the last known version cannot be shorter than '
         'required by the last known version.');
     }
     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;
   }
 
   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) {
       decoder.excessHandles.forEach((h) => h.close());
     }
     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) {
       // Scan in reverse order to optimize for more recent versions.
       for (int i = kVersions.length - 1; i >= 0; --i) {
         if (mainDataHeader.version >= kVersions[i].version) {
           if (mainDataHeader.size == kVersions[i].size) {
             // Found a match.
             break;
           }
           throw new bindings.MojoCodecError(
               'Header size doesn\'t correspond to known version size.');
         }
       }
     } else if (mainDataHeader.size < kVersions.last.size) {
       throw new bindings.MojoCodecError(
         'Message newer than the last known version cannot be shorter than '
         'required by the last known version.');
     }
     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 kTerminal_connect_name = 0;
-const int kTerminal_connectToClient_name = 1;
-const int kTerminal_getSize_name = 2;
-const int kTerminal_setSize_name = 3;
-const String TerminalName = "mojo::terminal::Terminal";
+const int kAudioTrack_describe_name = 0;
+const int kAudioTrack_configure_name = 1;
+const int kAudioTrack_getRateControl_name = 2;
+const String AudioTrackName = null;
 
-abstract class 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]);
+abstract class AudioTrack {
+  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);
   }
 
-  String get name => TerminalName;
+  String get name => AudioTrackName;
 
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
-      case kTerminal_connect_name:
-        var r = TerminalConnectResponseParams.deserialize(
+      case kAudioTrack_describe_name:
+        var r = AudioTrackDescribeResponseParams.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 kTerminal_connectToClient_name:
-        var r = TerminalConnectToClientResponseParams.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 kTerminal_getSize_name:
-        var r = TerminalGetSizeResponseParams.deserialize(
+      case kAudioTrack_configure_name:
+        var r = AudioTrackConfigureResponseParams.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 kTerminal_setSize_name:
-        var r = TerminalSetSizeResponseParams.deserialize(
+      case kAudioTrack_getRateControl_name:
+        var r = AudioTrackGetRateControlResponseParams.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;
       default:
         proxyError("Unexpected message type: ${message.header.type}");
         close(immediate: true);
         break;
     }
   }
 
   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;
+  _AudioTrackProxyCalls(this._proxyImpl);
+    dynamic describe([Function responseFactory = null]) {
+      var params = new AudioTrackDescribeParams();
       return _proxyImpl.sendMessageWithRequestId(
           params,
-          kTerminal_connect_name,
+          kAudioTrack_describe_name,
           -1,
           bindings.MessageHeader.kMessageExpectsResponse);
     }
-    dynamic connectToClient(Object terminalClient,bool force,[Function responseFactory = null]) {
-      var params = new TerminalConnectToClientParams();
-      params.terminalClient = terminalClient;
-      params.force = force;
+    dynamic configure(AudioTrackConfiguration configuration,Object pipe,[Function responseFactory = null]) {
+      var params = new AudioTrackConfigureParams();
+      params.configuration = configuration;
+      params.pipe = pipe;
       return _proxyImpl.sendMessageWithRequestId(
           params,
-          kTerminal_connectToClient_name,
+          kAudioTrack_configure_name,
           -1,
           bindings.MessageHeader.kMessageExpectsResponse);
     }
-    dynamic getSize([Function responseFactory = null]) {
-      var params = new TerminalGetSizeParams();
+    dynamic getRateControl(Object rateControl,[Function responseFactory = null]) {
+      var params = new AudioTrackGetRateControlParams();
+      params.rateControl = rateControl;
       return _proxyImpl.sendMessageWithRequestId(
           params,
-          kTerminal_getSize_name,
-          -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;
-      return _proxyImpl.sendMessageWithRequestId(
-          params,
-          kTerminal_setSize_name,
+          kAudioTrack_getRateControl_name,
           -1,
           bindings.MessageHeader.kMessageExpectsResponse);
     }
 }
 
 
-class TerminalProxy implements bindings.ProxyBase {
+class AudioTrackProxy implements bindings.ProxyBase {
   final bindings.Proxy impl;
-  Terminal ptr;
-  final String name = TerminalName;
+  AudioTrack ptr;
+  final String name = AudioTrackName;
 
-  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(
-      bindings.ServiceConnector s, String url, [String serviceName]) {
-    TerminalProxy p = new TerminalProxy.unbound();
-    s.connectToService(url, p, serviceName);
+  factory AudioTrackProxy.connectToService(
+      bindings.ServiceConnector s, String url) {
+    AudioTrackProxy p = new AudioTrackProxy.unbound();
+    s.connectToService(url, p);
     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);
   }
 
   Future close({bool immediate: false}) => impl.close(immediate: immediate);
 
   Future responseOrError(Future f) => impl.responseOrError(f);
 
   Future get errorFuture => impl.errorFuture;
 
   int get version => impl.version;
 
   Future<int> queryVersion() => impl.queryVersion();
 
   void requireVersion(int requiredVersion) {
     impl.requireVersion(requiredVersion);
   }
 
   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);
   }
 
-  static const String name = TerminalName;
+  static const String name = AudioTrackName;
 
 
-  TerminalConnectResponseParams _TerminalConnectResponseParamsFactory(types_mojom.Error error) {
-    var mojo_factory_result = new TerminalConnectResponseParams();
-    mojo_factory_result.error = error;
+  AudioTrackDescribeResponseParams _AudioTrackDescribeResponseParamsFactory(AudioTrackDescriptor descriptor) {
+    var mojo_factory_result = new AudioTrackDescribeResponseParams();
+    mojo_factory_result.descriptor = descriptor;
     return mojo_factory_result;
   }
-  TerminalConnectToClientResponseParams _TerminalConnectToClientResponseParamsFactory(types_mojom.Error error) {
-    var mojo_factory_result = new TerminalConnectToClientResponseParams();
-    mojo_factory_result.error = error;
+  AudioTrackConfigureResponseParams _AudioTrackConfigureResponseParamsFactory(media_common_mojom.MediaResult result) {
+    var mojo_factory_result = new AudioTrackConfigureResponseParams();
+    mojo_factory_result.result = result;
     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;
-    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;
   }
 
   dynamic handleMessage(bindings.ServiceMessage message) {
     if (bindings.ControlMessageHandler.isControlMessage(message)) {
       return bindings.ControlMessageHandler.handleMessage(this,
                                                           0,
                                                           message);
     }
     assert(_impl != null);
     switch (message.header.type) {
-      case kTerminal_connect_name:
-        var params = TerminalConnectParams.deserialize(
+      case kAudioTrack_describe_name:
+        var params = AudioTrackDescribeParams.deserialize(
             message.payload);
-        var response = _impl.connect(params.terminalFile,params.force,_TerminalConnectResponseParamsFactory);
+        var response = _impl.describe(_AudioTrackDescribeResponseParamsFactory);
         if (response is Future) {
           return response.then((response) {
             if (response != null) {
               return buildResponseWithId(
                   response,
-                  kTerminal_connect_name,
+                  kAudioTrack_describe_name,
                   message.header.requestId,
                   bindings.MessageHeader.kMessageIsResponse);
             }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              kTerminal_connect_name,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
-        break;
-      case kTerminal_connectToClient_name:
-        var params = TerminalConnectToClientParams.deserialize(
-            message.payload);
-        var response = _impl.connectToClient(params.terminalClient,params.force,_TerminalConnectToClientResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  kTerminal_connectToClient_name,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
           });
         } else if (response != null) {
           return buildResponseWithId(
               response,
-              kTerminal_connectToClient_name,
+              kAudioTrack_describe_name,
               message.header.requestId,
               bindings.MessageHeader.kMessageIsResponse);
         }
         break;
-      case kTerminal_getSize_name:
-        var params = TerminalGetSizeParams.deserialize(
+      case kAudioTrack_configure_name:
+        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,
-                  kTerminal_getSize_name,
+                  kAudioTrack_configure_name,
                   message.header.requestId,
                   bindings.MessageHeader.kMessageIsResponse);
             }
           });
         } else if (response != null) {
           return buildResponseWithId(
               response,
-              kTerminal_getSize_name,
+              kAudioTrack_configure_name,
               message.header.requestId,
               bindings.MessageHeader.kMessageIsResponse);
         }
         break;
-      case kTerminal_setSize_name:
-        var params = TerminalSetSizeParams.deserialize(
+      case kAudioTrack_getRateControl_name:
+        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,
-                  kTerminal_setSize_name,
+                  kAudioTrack_getRateControl_name,
                   message.header.requestId,
                   bindings.MessageHeader.kMessageIsResponse);
             }
           });
         } else if (response != null) {
           return buildResponseWithId(
               response,
-              kTerminal_setSize_name,
+              kAudioTrack_getRateControl_name,
               message.header.requestId,
               bindings.MessageHeader.kMessageIsResponse);
         }
         break;
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
         break;
     }
     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;
 }