Motown: Define MediaRenderer and make it the way we identify renderers.

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

Index: mojo/dart/packages/mojo_services/lib/mojo/media/media_renderer.mojom.dart
diff --git a/mojo/dart/packages/mojo_services/lib/mojo/media/audio_track.mojom.dart b/mojo/dart/packages/mojo_services/lib/mojo/media/media_renderer.mojom.dart
similarity index 50%
copy from mojo/dart/packages/mojo_services/lib/mojo/media/audio_track.mojom.dart
copy to mojo/dart/packages/mojo_services/lib/mojo/media/media_renderer.mojom.dart
index c707c591f0828ac25564e894fef1835691284779..424a13b6cea5090a6dd35a8d4e8aec7b7b1a73e1 100644
--- a/mojo/dart/packages/mojo_services/lib/mojo/media/audio_track.mojom.dart
+++ b/mojo/dart/packages/mojo_services/lib/mojo/media/media_renderer.mojom.dart
@@ -1,7 +1,7 @@
 // WARNING: DO NOT EDIT. This file was generated by a program.
 // See $MOJO_SDK/tools/bindings/mojom_bindings_generator.py.
 
-library audio_track_mojom;
+library media_renderer_mojom;
 import 'dart:async';
 import 'package:mojo/bindings.dart' as bindings;
 import 'package:mojo/core.dart' as core;
@@ -12,19 +12,17 @@ import 'package:mojo_services/mojo/media/timeline_controller.mojom.dart' as time
 
 
 
-class AudioTrackDescriptor extends bindings.Struct {
+class _MediaRendererGetSupportedMediaTypesParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(16, 0)
+    const bindings.StructDataHeader(8, 0)
   ];
-  List<media_types_mojom.MediaTypeSet> supportedMediaTypes = null;
 
-  AudioTrackDescriptor() : super(kVersions.last.size);
+  _MediaRendererGetSupportedMediaTypesParams() : super(kVersions.last.size);
 
-  AudioTrackDescriptor.init(
-    List<media_types_mojom.MediaTypeSet> this.supportedMediaTypes
+  _MediaRendererGetSupportedMediaTypesParams.init(
   ) : super(kVersions.last.size);
 
-  static AudioTrackDescriptor deserialize(bindings.Message message) {
+  static _MediaRendererGetSupportedMediaTypesParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -33,11 +31,11 @@ class AudioTrackDescriptor extends bindings.Struct {
     return result;
   }
 
-  static AudioTrackDescriptor decode(bindings.Decoder decoder0) {
+  static _MediaRendererGetSupportedMediaTypesParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    AudioTrackDescriptor result = new AudioTrackDescriptor();
+    _MediaRendererGetSupportedMediaTypesParams result = new _MediaRendererGetSupportedMediaTypesParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -57,70 +55,37 @@ class AudioTrackDescriptor 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);
-      {
-        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);
-    try {
-      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);
-        }
-      }
-    } on bindings.MojoCodecError catch(e) {
-      e.message = "Error encountered while encoding field "
-          "supportedMediaTypes of struct AudioTrackDescriptor: $e";
-      rethrow;
-    }
+    encoder.getStructEncoderAtOffset(kVersions.last);
   }
 
   String toString() {
-    return "AudioTrackDescriptor("
-           "supportedMediaTypes: $supportedMediaTypes" ")";
+    return "_MediaRendererGetSupportedMediaTypesParams("")";
   }
 
   Map toJson() {
     Map map = new Map();
-    map["supportedMediaTypes"] = supportedMediaTypes;
     return map;
   }
 }
 
 
-class AudioTrackConfiguration extends bindings.Struct {
+class MediaRendererGetSupportedMediaTypesResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(24, 0)
+    const bindings.StructDataHeader(16, 0)
   ];
-  media_types_mojom.MediaType mediaType = null;
-  int audioFrameRatio = 1;
-  int mediaTimeRatio = 1;
+  List<media_types_mojom.MediaTypeSet> supportedMediaTypes = null;
 
-  AudioTrackConfiguration() : super(kVersions.last.size);
+  MediaRendererGetSupportedMediaTypesResponseParams() : super(kVersions.last.size);
 
-  AudioTrackConfiguration.init(
-    media_types_mojom.MediaType this.mediaType, 
-    int this.audioFrameRatio, 
-    int this.mediaTimeRatio
+  MediaRendererGetSupportedMediaTypesResponseParams.init(
+    List<media_types_mojom.MediaTypeSet> this.supportedMediaTypes
   ) : super(kVersions.last.size);
 
-  static AudioTrackConfiguration deserialize(bindings.Message message) {
+  static MediaRendererGetSupportedMediaTypesResponseParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -129,11 +94,11 @@ class AudioTrackConfiguration extends bindings.Struct {
     return result;
   }
 
-  static AudioTrackConfiguration decode(bindings.Decoder decoder0) {
+  static MediaRendererGetSupportedMediaTypesResponseParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    AudioTrackConfiguration result = new AudioTrackConfiguration();
+    MediaRendererGetSupportedMediaTypesResponseParams result = new MediaRendererGetSupportedMediaTypesResponseParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -156,15 +121,15 @@ class AudioTrackConfiguration extends bindings.Struct {
     if (mainDataHeader.version >= 0) {
       
       var decoder1 = decoder0.decodePointer(8, false);
-      result.mediaType = media_types_mojom.MediaType.decode(decoder1);
-    }
-    if (mainDataHeader.version >= 0) {
-      
-      result.audioFrameRatio = decoder0.decodeUint32(16);
-    }
-    if (mainDataHeader.version >= 0) {
-      
-      result.mediaTimeRatio = decoder0.decodeUint32(20);
+      {
+        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;
   }
@@ -172,119 +137,47 @@ class AudioTrackConfiguration extends bindings.Struct {
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     try {
-      encoder0.encodeStruct(mediaType, 8, false);
-    } on bindings.MojoCodecError catch(e) {
-      e.message = "Error encountered while encoding field "
-          "mediaType of struct AudioTrackConfiguration: $e";
-      rethrow;
-    }
-    try {
-      encoder0.encodeUint32(audioFrameRatio, 16);
-    } on bindings.MojoCodecError catch(e) {
-      e.message = "Error encountered while encoding field "
-          "audioFrameRatio of struct AudioTrackConfiguration: $e";
-      rethrow;
-    }
-    try {
-      encoder0.encodeUint32(mediaTimeRatio, 20);
+      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);
+        }
+      }
     } on bindings.MojoCodecError catch(e) {
       e.message = "Error encountered while encoding field "
-          "mediaTimeRatio of struct AudioTrackConfiguration: $e";
+          "supportedMediaTypes of struct MediaRendererGetSupportedMediaTypesResponseParams: $e";
       rethrow;
     }
   }
 
   String toString() {
-    return "AudioTrackConfiguration("
-           "mediaType: $mediaType" ", "
-           "audioFrameRatio: $audioFrameRatio" ", "
-           "mediaTimeRatio: $mediaTimeRatio" ")";
-  }
-
-  Map toJson() {
-    Map map = new Map();
-    map["mediaType"] = mediaType;
-    map["audioFrameRatio"] = audioFrameRatio;
-    map["mediaTimeRatio"] = mediaTimeRatio;
-    return map;
-  }
-}
-
-
-class _AudioTrackDescribeParams extends bindings.Struct {
-  static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(8, 0)
-  ];
-
-  _AudioTrackDescribeParams() : super(kVersions.last.size);
-
-  _AudioTrackDescribeParams.init(
-  ) : super(kVersions.last.size);
-
-  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 _AudioTrackDescribeParams decode(bindings.Decoder decoder0) {
-    if (decoder0 == null) {
-      return null;
-    }
-    _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.');
-    }
-    return result;
-  }
-
-  void encode(bindings.Encoder encoder) {
-    encoder.getStructEncoderAtOffset(kVersions.last);
-  }
-
-  String toString() {
-    return "_AudioTrackDescribeParams("")";
+    return "MediaRendererGetSupportedMediaTypesResponseParams("
+           "supportedMediaTypes: $supportedMediaTypes" ")";
   }
 
   Map toJson() {
     Map map = new Map();
+    map["supportedMediaTypes"] = supportedMediaTypes;
     return map;
   }
 }
 
 
-class AudioTrackDescribeResponseParams extends bindings.Struct {
+class _MediaRendererSetMediaTypeParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
-  AudioTrackDescriptor descriptor = null;
+  media_types_mojom.MediaType mediaType = null;
 
-  AudioTrackDescribeResponseParams() : super(kVersions.last.size);
+  _MediaRendererSetMediaTypeParams() : super(kVersions.last.size);
 
-  AudioTrackDescribeResponseParams.init(
-    AudioTrackDescriptor this.descriptor
+  _MediaRendererSetMediaTypeParams.init(
+    media_types_mojom.MediaType this.mediaType
   ) : super(kVersions.last.size);
 
-  static AudioTrackDescribeResponseParams deserialize(bindings.Message message) {
+  static _MediaRendererSetMediaTypeParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -293,11 +186,11 @@ class AudioTrackDescribeResponseParams extends bindings.Struct {
     return result;
   }
 
-  static AudioTrackDescribeResponseParams decode(bindings.Decoder decoder0) {
+  static _MediaRendererSetMediaTypeParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    AudioTrackDescribeResponseParams result = new AudioTrackDescribeResponseParams();
+    _MediaRendererSetMediaTypeParams result = new _MediaRendererSetMediaTypeParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -320,7 +213,7 @@ class AudioTrackDescribeResponseParams extends bindings.Struct {
     if (mainDataHeader.version >= 0) {
       
       var decoder1 = decoder0.decodePointer(8, false);
-      result.descriptor = AudioTrackDescriptor.decode(decoder1);
+      result.mediaType = media_types_mojom.MediaType.decode(decoder1);
     }
     return result;
   }
@@ -328,42 +221,40 @@ class AudioTrackDescribeResponseParams extends bindings.Struct {
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     try {
-      encoder0.encodeStruct(descriptor, 8, false);
+      encoder0.encodeStruct(mediaType, 8, false);
     } on bindings.MojoCodecError catch(e) {
       e.message = "Error encountered while encoding field "
-          "descriptor of struct AudioTrackDescribeResponseParams: $e";
+          "mediaType of struct _MediaRendererSetMediaTypeParams: $e";
       rethrow;
     }
   }
 
   String toString() {
-    return "AudioTrackDescribeResponseParams("
-           "descriptor: $descriptor" ")";
+    return "_MediaRendererSetMediaTypeParams("
+           "mediaType: $mediaType" ")";
   }
 
   Map toJson() {
     Map map = new Map();
-    map["descriptor"] = descriptor;
+    map["mediaType"] = mediaType;
     return map;
   }
 }
 
 
-class _AudioTrackConfigureParams extends bindings.Struct {
+class _MediaRendererGetConsumerParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(24, 0)
+    const bindings.StructDataHeader(16, 0)
   ];
-  AudioTrackConfiguration configuration = null;
-  media_transport_mojom.MediaConsumerInterfaceRequest pipe = null;
+  media_transport_mojom.MediaConsumerInterfaceRequest consumer = null;
 
-  _AudioTrackConfigureParams() : super(kVersions.last.size);
+  _MediaRendererGetConsumerParams() : super(kVersions.last.size);
 
-  _AudioTrackConfigureParams.init(
-    AudioTrackConfiguration this.configuration, 
-    media_transport_mojom.MediaConsumerInterfaceRequest this.pipe
+  _MediaRendererGetConsumerParams.init(
+    media_transport_mojom.MediaConsumerInterfaceRequest this.consumer
   ) : super(kVersions.last.size);
 
-  static _AudioTrackConfigureParams deserialize(bindings.Message message) {
+  static _MediaRendererGetConsumerParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -372,11 +263,11 @@ class _AudioTrackConfigureParams extends bindings.Struct {
     return result;
   }
 
-  static _AudioTrackConfigureParams decode(bindings.Decoder decoder0) {
+  static _MediaRendererGetConsumerParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    _AudioTrackConfigureParams result = new _AudioTrackConfigureParams();
+    _MediaRendererGetConsumerParams result = new _MediaRendererGetConsumerParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -398,12 +289,7 @@ class _AudioTrackConfigureParams extends bindings.Struct {
     }
     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_transport_mojom.MediaConsumerStub.newFromEndpoint);
+      result.consumer = decoder0.decodeInterfaceRequest(8, false, media_transport_mojom.MediaConsumerStub.newFromEndpoint);
     }
     return result;
   }
@@ -411,25 +297,17 @@ class _AudioTrackConfigureParams extends bindings.Struct {
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     try {
-      encoder0.encodeStruct(configuration, 8, false);
-    } on bindings.MojoCodecError catch(e) {
-      e.message = "Error encountered while encoding field "
-          "configuration of struct _AudioTrackConfigureParams: $e";
-      rethrow;
-    }
-    try {
-      encoder0.encodeInterfaceRequest(pipe, 16, false);
+      encoder0.encodeInterfaceRequest(consumer, 8, false);
     } on bindings.MojoCodecError catch(e) {
       e.message = "Error encountered while encoding field "
-          "pipe of struct _AudioTrackConfigureParams: $e";
+          "consumer of struct _MediaRendererGetConsumerParams: $e";
       rethrow;
     }
   }
 
   String toString() {
-    return "_AudioTrackConfigureParams("
-           "configuration: $configuration" ", "
-           "pipe: $pipe" ")";
+    return "_MediaRendererGetConsumerParams("
+           "consumer: $consumer" ")";
   }
 
   Map toJson() {
@@ -439,19 +317,19 @@ class _AudioTrackConfigureParams extends bindings.Struct {
 }
 
 
-class _AudioTrackGetTimelineControlSiteParams extends bindings.Struct {
+class _MediaRendererGetTimelineControlSiteParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
   timeline_controller_mojom.MediaTimelineControlSiteInterfaceRequest timelineControlSite = null;
 
-  _AudioTrackGetTimelineControlSiteParams() : super(kVersions.last.size);
+  _MediaRendererGetTimelineControlSiteParams() : super(kVersions.last.size);
 
-  _AudioTrackGetTimelineControlSiteParams.init(
+  _MediaRendererGetTimelineControlSiteParams.init(
     timeline_controller_mojom.MediaTimelineControlSiteInterfaceRequest this.timelineControlSite
   ) : super(kVersions.last.size);
 
-  static _AudioTrackGetTimelineControlSiteParams deserialize(bindings.Message message) {
+  static _MediaRendererGetTimelineControlSiteParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -460,11 +338,11 @@ class _AudioTrackGetTimelineControlSiteParams extends bindings.Struct {
     return result;
   }
 
-  static _AudioTrackGetTimelineControlSiteParams decode(bindings.Decoder decoder0) {
+  static _MediaRendererGetTimelineControlSiteParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    _AudioTrackGetTimelineControlSiteParams result = new _AudioTrackGetTimelineControlSiteParams();
+    _MediaRendererGetTimelineControlSiteParams result = new _MediaRendererGetTimelineControlSiteParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -497,13 +375,13 @@ class _AudioTrackGetTimelineControlSiteParams extends bindings.Struct {
       encoder0.encodeInterfaceRequest(timelineControlSite, 8, false);
     } on bindings.MojoCodecError catch(e) {
       e.message = "Error encountered while encoding field "
-          "timelineControlSite of struct _AudioTrackGetTimelineControlSiteParams: $e";
+          "timelineControlSite of struct _MediaRendererGetTimelineControlSiteParams: $e";
       rethrow;
     }
   }
 
   String toString() {
-    return "_AudioTrackGetTimelineControlSiteParams("
+    return "_MediaRendererGetTimelineControlSiteParams("
            "timelineControlSite: $timelineControlSite" ")";
   }
 
@@ -513,88 +391,12 @@ class _AudioTrackGetTimelineControlSiteParams extends bindings.Struct {
   }
 }
 
+const int _mediaRendererMethodGetSupportedMediaTypesName = 0;
+const int _mediaRendererMethodSetMediaTypeName = 1;
+const int _mediaRendererMethodGetConsumerName = 2;
+const int _mediaRendererMethodGetTimelineControlSiteName = 3;
 
-class _AudioTrackSetGainParams extends bindings.Struct {
-  static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(16, 0)
-  ];
-  double dbGain = 0.0;
-
-  _AudioTrackSetGainParams() : super(kVersions.last.size);
-
-  _AudioTrackSetGainParams.init(
-    double this.dbGain
-  ) : super(kVersions.last.size);
-
-  static _AudioTrackSetGainParams 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 _AudioTrackSetGainParams decode(bindings.Decoder decoder0) {
-    if (decoder0 == null) {
-      return null;
-    }
-    _AudioTrackSetGainParams result = new _AudioTrackSetGainParams();
-
-    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.dbGain = decoder0.decodeFloat(8);
-    }
-    return result;
-  }
-
-  void encode(bindings.Encoder encoder) {
-    var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
-    try {
-      encoder0.encodeFloat(dbGain, 8);
-    } on bindings.MojoCodecError catch(e) {
-      e.message = "Error encountered while encoding field "
-          "dbGain of struct _AudioTrackSetGainParams: $e";
-      rethrow;
-    }
-  }
-
-  String toString() {
-    return "_AudioTrackSetGainParams("
-           "dbGain: $dbGain" ")";
-  }
-
-  Map toJson() {
-    Map map = new Map();
-    map["dbGain"] = dbGain;
-    return map;
-  }
-}
-
-const int _audioTrackMethodDescribeName = 0;
-const int _audioTrackMethodConfigureName = 1;
-const int _audioTrackMethodGetTimelineControlSiteName = 2;
-const int _audioTrackMethodSetGainName = 3;
-
-class _AudioTrackServiceDescription implements service_describer.ServiceDescription {
+class _MediaRendererServiceDescription implements service_describer.ServiceDescription {
   void getTopLevelInterface(Function responder) {
     responder(null);
   }
@@ -608,21 +410,21 @@ class _AudioTrackServiceDescription implements service_describer.ServiceDescript
   }
 }
 
-abstract class AudioTrack {
+abstract class MediaRenderer {
   static const String serviceName = null;
 
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
-      _cachedServiceDescription = new _AudioTrackServiceDescription();
+      _cachedServiceDescription = new _MediaRendererServiceDescription();
     }
     return _cachedServiceDescription;
   }
 
-  static AudioTrackProxy connectToService(
+  static MediaRendererProxy connectToService(
       bindings.ServiceConnector s, String url, [String serviceName]) {
-    AudioTrackProxy p = new AudioTrackProxy.unbound();
-    String name = serviceName ?? AudioTrack.serviceName;
+    MediaRendererProxy p = new MediaRendererProxy.unbound();
+    String name = serviceName ?? MediaRenderer.serviceName;
     if ((name == null) || name.isEmpty) {
       throw new core.MojoApiError(
           "If an interface has no ServiceName, then one must be provided.");
@@ -630,56 +432,54 @@ abstract class AudioTrack {
     s.connectToService(url, p, name);
     return p;
   }
-  void describe(void callback(AudioTrackDescriptor descriptor));
-  void configure(AudioTrackConfiguration configuration, media_transport_mojom.MediaConsumerInterfaceRequest pipe);
+  void getSupportedMediaTypes(void callback(List<media_types_mojom.MediaTypeSet> supportedMediaTypes));
+  void setMediaType(media_types_mojom.MediaType mediaType);
+  void getConsumer(media_transport_mojom.MediaConsumerInterfaceRequest consumer);
   void getTimelineControlSite(timeline_controller_mojom.MediaTimelineControlSiteInterfaceRequest timelineControlSite);
-  void setGain(double dbGain);
-  static const double kMutedGain = -160.0;
-  static const double kMaxGain = 20.0;
 }
 
-abstract class AudioTrackInterface
-    implements bindings.MojoInterface<AudioTrack>,
-               AudioTrack {
-  factory AudioTrackInterface([AudioTrack impl]) =>
-      new AudioTrackStub.unbound(impl);
+abstract class MediaRendererInterface
+    implements bindings.MojoInterface<MediaRenderer>,
+               MediaRenderer {
+  factory MediaRendererInterface([MediaRenderer impl]) =>
+      new MediaRendererStub.unbound(impl);
 
-  factory AudioTrackInterface.fromEndpoint(
+  factory MediaRendererInterface.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint,
-      [AudioTrack impl]) =>
-      new AudioTrackStub.fromEndpoint(endpoint, impl);
+      [MediaRenderer impl]) =>
+      new MediaRendererStub.fromEndpoint(endpoint, impl);
 
-  factory AudioTrackInterface.fromMock(
-      AudioTrack mock) =>
-      new AudioTrackProxy.fromMock(mock);
+  factory MediaRendererInterface.fromMock(
+      MediaRenderer mock) =>
+      new MediaRendererProxy.fromMock(mock);
 }
 
-abstract class AudioTrackInterfaceRequest
-    implements bindings.MojoInterface<AudioTrack>,
-               AudioTrack {
-  factory AudioTrackInterfaceRequest() =>
-      new AudioTrackProxy.unbound();
+abstract class MediaRendererInterfaceRequest
+    implements bindings.MojoInterface<MediaRenderer>,
+               MediaRenderer {
+  factory MediaRendererInterfaceRequest() =>
+      new MediaRendererProxy.unbound();
 }
 
-class _AudioTrackProxyControl
+class _MediaRendererProxyControl
     extends bindings.ProxyMessageHandler
-    implements bindings.ProxyControl<AudioTrack> {
-  AudioTrack impl;
+    implements bindings.ProxyControl<MediaRenderer> {
+  MediaRenderer impl;
 
-  _AudioTrackProxyControl.fromEndpoint(
+  _MediaRendererProxyControl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
-  _AudioTrackProxyControl.fromHandle(
+  _MediaRendererProxyControl.fromHandle(
       core.MojoHandle handle) : super.fromHandle(handle);
 
-  _AudioTrackProxyControl.unbound() : super.unbound();
+  _MediaRendererProxyControl.unbound() : super.unbound();
 
-  String get serviceName => AudioTrack.serviceName;
+  String get serviceName => MediaRenderer.serviceName;
 
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
-      case _audioTrackMethodDescribeName:
-        var r = AudioTrackDescribeResponseParams.deserialize(
+      case _mediaRendererMethodGetSupportedMediaTypesName:
+        var r = MediaRendererGetSupportedMediaTypesResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
@@ -692,7 +492,7 @@ class _AudioTrackProxyControl
           return;
         }
         callbackMap.remove(message.header.requestId);
-        callback(r.descriptor );
+        callback(r.supportedMediaTypes );
         break;
       default:
         proxyError("Unexpected message type: ${message.header.type}");
@@ -704,138 +504,137 @@ class _AudioTrackProxyControl
   @override
   String toString() {
     var superString = super.toString();
-    return "_AudioTrackProxyControl($superString)";
+    return "_MediaRendererProxyControl($superString)";
   }
 }
 
-class AudioTrackProxy
-    extends bindings.Proxy<AudioTrack>
-    implements AudioTrack,
-               AudioTrackInterface,
-               AudioTrackInterfaceRequest {
-  AudioTrackProxy.fromEndpoint(
+class MediaRendererProxy
+    extends bindings.Proxy<MediaRenderer>
+    implements MediaRenderer,
+               MediaRendererInterface,
+               MediaRendererInterfaceRequest {
+  MediaRendererProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint)
-      : super(new _AudioTrackProxyControl.fromEndpoint(endpoint));
+      : super(new _MediaRendererProxyControl.fromEndpoint(endpoint));
 
-  AudioTrackProxy.fromHandle(core.MojoHandle handle)
-      : super(new _AudioTrackProxyControl.fromHandle(handle));
+  MediaRendererProxy.fromHandle(core.MojoHandle handle)
+      : super(new _MediaRendererProxyControl.fromHandle(handle));
 
-  AudioTrackProxy.unbound()
-      : super(new _AudioTrackProxyControl.unbound());
+  MediaRendererProxy.unbound()
+      : super(new _MediaRendererProxyControl.unbound());
 
-  factory AudioTrackProxy.fromMock(AudioTrack mock) {
-    AudioTrackProxy newMockedProxy =
-        new AudioTrackProxy.unbound();
+  factory MediaRendererProxy.fromMock(MediaRenderer mock) {
+    MediaRendererProxy newMockedProxy =
+        new MediaRendererProxy.unbound();
     newMockedProxy.impl = mock;
     return newMockedProxy;
   }
 
-  static AudioTrackProxy newFromEndpoint(
+  static MediaRendererProxy newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For AudioTrackProxy"));
-    return new AudioTrackProxy.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For MediaRendererProxy"));
+    return new MediaRendererProxy.fromEndpoint(endpoint);
   }
 
 
-  void describe(void callback(AudioTrackDescriptor descriptor)) {
+  void getSupportedMediaTypes(void callback(List<media_types_mojom.MediaTypeSet> supportedMediaTypes)) {
     if (impl != null) {
-      impl.describe(callback);
+      impl.getSupportedMediaTypes(callback);
       return;
     }
-    var params = new _AudioTrackDescribeParams();
+    var params = new _MediaRendererGetSupportedMediaTypesParams();
     Function zonedCallback;
     if (identical(Zone.current, Zone.ROOT)) {
       zonedCallback = callback;
     } else {
       Zone z = Zone.current;
-      zonedCallback = ((AudioTrackDescriptor descriptor) {
+      zonedCallback = ((List<media_types_mojom.MediaTypeSet> supportedMediaTypes) {
         z.bindCallback(() {
-          callback(descriptor);
+          callback(supportedMediaTypes);
         })();
       });
     }
     ctrl.sendMessageWithRequestId(
         params,
-        _audioTrackMethodDescribeName,
+        _mediaRendererMethodGetSupportedMediaTypesName,
         -1,
         bindings.MessageHeader.kMessageExpectsResponse,
         zonedCallback);
   }
-  void configure(AudioTrackConfiguration configuration, media_transport_mojom.MediaConsumerInterfaceRequest pipe) {
+  void setMediaType(media_types_mojom.MediaType mediaType) {
     if (impl != null) {
-      impl.configure(configuration, pipe);
+      impl.setMediaType(mediaType);
       return;
     }
     if (!ctrl.isBound) {
       ctrl.proxyError("The Proxy is closed.");
       return;
     }
-    var params = new _AudioTrackConfigureParams();
-    params.configuration = configuration;
-    params.pipe = pipe;
+    var params = new _MediaRendererSetMediaTypeParams();
+    params.mediaType = mediaType;
     ctrl.sendMessage(params,
-        _audioTrackMethodConfigureName);
+        _mediaRendererMethodSetMediaTypeName);
   }
-  void getTimelineControlSite(timeline_controller_mojom.MediaTimelineControlSiteInterfaceRequest timelineControlSite) {
+  void getConsumer(media_transport_mojom.MediaConsumerInterfaceRequest consumer) {
     if (impl != null) {
-      impl.getTimelineControlSite(timelineControlSite);
+      impl.getConsumer(consumer);
       return;
     }
     if (!ctrl.isBound) {
       ctrl.proxyError("The Proxy is closed.");
       return;
     }
-    var params = new _AudioTrackGetTimelineControlSiteParams();
-    params.timelineControlSite = timelineControlSite;
+    var params = new _MediaRendererGetConsumerParams();
+    params.consumer = consumer;
     ctrl.sendMessage(params,
-        _audioTrackMethodGetTimelineControlSiteName);
+        _mediaRendererMethodGetConsumerName);
   }
-  void setGain(double dbGain) {
+  void getTimelineControlSite(timeline_controller_mojom.MediaTimelineControlSiteInterfaceRequest timelineControlSite) {
     if (impl != null) {
-      impl.setGain(dbGain);
+      impl.getTimelineControlSite(timelineControlSite);
       return;
     }
     if (!ctrl.isBound) {
       ctrl.proxyError("The Proxy is closed.");
       return;
     }
-    var params = new _AudioTrackSetGainParams();
-    params.dbGain = dbGain;
+    var params = new _MediaRendererGetTimelineControlSiteParams();
+    params.timelineControlSite = timelineControlSite;
     ctrl.sendMessage(params,
-        _audioTrackMethodSetGainName);
+        _mediaRendererMethodGetTimelineControlSiteName);
   }
 }
 
-class _AudioTrackStubControl
+class _MediaRendererStubControl
     extends bindings.StubMessageHandler
-    implements bindings.StubControl<AudioTrack> {
-  AudioTrack _impl;
+    implements bindings.StubControl<MediaRenderer> {
+  MediaRenderer _impl;
 
-  _AudioTrackStubControl.fromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint, [AudioTrack impl])
+  _MediaRendererStubControl.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint, [MediaRenderer impl])
       : super.fromEndpoint(endpoint, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  _AudioTrackStubControl.fromHandle(
-      core.MojoHandle handle, [AudioTrack impl])
+  _MediaRendererStubControl.fromHandle(
+      core.MojoHandle handle, [MediaRenderer impl])
       : super.fromHandle(handle, autoBegin: impl != null) {
     _impl = impl;
   }
 
-  _AudioTrackStubControl.unbound([this._impl]) : super.unbound();
+  _MediaRendererStubControl.unbound([this._impl]) : super.unbound();
 
-  String get serviceName => AudioTrack.serviceName;
+  String get serviceName => MediaRenderer.serviceName;
 
 
-  Function _audioTrackDescribeResponseParamsResponder(
+  Function _mediaRendererGetSupportedMediaTypesResponseParamsResponder(
       int requestId) {
-  return (AudioTrackDescriptor descriptor) {
-      var result = new AudioTrackDescribeResponseParams();
-      result.descriptor = descriptor;
+  return (List<media_types_mojom.MediaTypeSet> supportedMediaTypes) {
+      var result = new MediaRendererGetSupportedMediaTypesResponseParams();
+      result.supportedMediaTypes = supportedMediaTypes;
       sendResponse(buildResponseWithId(
           result,
-          _audioTrackMethodDescribeName,
+          _mediaRendererMethodGetSupportedMediaTypesName,
           requestId,
           bindings.MessageHeader.kMessageIsResponse));
     };
@@ -851,23 +650,23 @@ class _AudioTrackStubControl
       throw new core.MojoApiError("$this has no implementation set");
     }
     switch (message.header.type) {
-      case _audioTrackMethodDescribeName:
-        _impl.describe(_audioTrackDescribeResponseParamsResponder(message.header.requestId));
+      case _mediaRendererMethodGetSupportedMediaTypesName:
+        _impl.getSupportedMediaTypes(_mediaRendererGetSupportedMediaTypesResponseParamsResponder(message.header.requestId));
         break;
-      case _audioTrackMethodConfigureName:
-        var params = _AudioTrackConfigureParams.deserialize(
+      case _mediaRendererMethodSetMediaTypeName:
+        var params = _MediaRendererSetMediaTypeParams.deserialize(
             message.payload);
-        _impl.configure(params.configuration, params.pipe);
+        _impl.setMediaType(params.mediaType);
         break;
-      case _audioTrackMethodGetTimelineControlSiteName:
-        var params = _AudioTrackGetTimelineControlSiteParams.deserialize(
+      case _mediaRendererMethodGetConsumerName:
+        var params = _MediaRendererGetConsumerParams.deserialize(
             message.payload);
-        _impl.getTimelineControlSite(params.timelineControlSite);
+        _impl.getConsumer(params.consumer);
         break;
-      case _audioTrackMethodSetGainName:
-        var params = _AudioTrackSetGainParams.deserialize(
+      case _mediaRendererMethodGetTimelineControlSiteName:
+        var params = _MediaRendererGetTimelineControlSiteParams.deserialize(
             message.payload);
-        _impl.setGain(params.dbGain);
+        _impl.getTimelineControlSite(params.timelineControlSite);
         break;
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
@@ -875,8 +674,8 @@ class _AudioTrackStubControl
     }
   }
 
-  AudioTrack get impl => _impl;
-  set impl(AudioTrack d) {
+  MediaRenderer get impl => _impl;
+  set impl(MediaRenderer d) {
     if (d == null) {
       throw new core.MojoApiError("$this: Cannot set a null implementation");
     }
@@ -897,47 +696,47 @@ class _AudioTrackStubControl
   @override
   String toString() {
     var superString = super.toString();
-    return "_AudioTrackStubControl($superString)";
+    return "_MediaRendererStubControl($superString)";
   }
 
   int get version => 0;
 }
 
-class AudioTrackStub
-    extends bindings.Stub<AudioTrack>
-    implements AudioTrack,
-               AudioTrackInterface,
-               AudioTrackInterfaceRequest {
-  AudioTrackStub.unbound([AudioTrack impl])
-      : super(new _AudioTrackStubControl.unbound(impl));
+class MediaRendererStub
+    extends bindings.Stub<MediaRenderer>
+    implements MediaRenderer,
+               MediaRendererInterface,
+               MediaRendererInterfaceRequest {
+  MediaRendererStub.unbound([MediaRenderer impl])
+      : super(new _MediaRendererStubControl.unbound(impl));
 
-  AudioTrackStub.fromEndpoint(
-      core.MojoMessagePipeEndpoint endpoint, [AudioTrack impl])
-      : super(new _AudioTrackStubControl.fromEndpoint(endpoint, impl));
+  MediaRendererStub.fromEndpoint(
+      core.MojoMessagePipeEndpoint endpoint, [MediaRenderer impl])
+      : super(new _MediaRendererStubControl.fromEndpoint(endpoint, impl));
 
-  AudioTrackStub.fromHandle(
-      core.MojoHandle handle, [AudioTrack impl])
-      : super(new _AudioTrackStubControl.fromHandle(handle, impl));
+  MediaRendererStub.fromHandle(
+      core.MojoHandle handle, [MediaRenderer impl])
+      : super(new _MediaRendererStubControl.fromHandle(handle, impl));
 
-  static AudioTrackStub newFromEndpoint(
+  static MediaRendererStub newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For AudioTrackStub"));
-    return new AudioTrackStub.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For MediaRendererStub"));
+    return new MediaRendererStub.fromEndpoint(endpoint);
   }
 
 
-  void describe(void callback(AudioTrackDescriptor descriptor)) {
-    return impl.describe(callback);
+  void getSupportedMediaTypes(void callback(List<media_types_mojom.MediaTypeSet> supportedMediaTypes)) {
+    return impl.getSupportedMediaTypes(callback);
+  }
+  void setMediaType(media_types_mojom.MediaType mediaType) {
+    return impl.setMediaType(mediaType);
   }
-  void configure(AudioTrackConfiguration configuration, media_transport_mojom.MediaConsumerInterfaceRequest pipe) {
-    return impl.configure(configuration, pipe);
+  void getConsumer(media_transport_mojom.MediaConsumerInterfaceRequest consumer) {
+    return impl.getConsumer(consumer);
   }
   void getTimelineControlSite(timeline_controller_mojom.MediaTimelineControlSiteInterfaceRequest timelineControlSite) {
     return impl.getTimelineControlSite(timelineControlSite);
   }
-  void setGain(double dbGain) {
-    return impl.setGain(dbGain);
-  }
 }