Mojom updates for Motown.

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

Index: mojo/dart/packages/mojo_services/lib/mojo/media/media_player.mojom.dart
diff --git a/mojo/dart/packages/_mojo_for_test_only/lib/test/echo_service.mojom.dart b/mojo/dart/packages/mojo_services/lib/mojo/media/media_player.mojom.dart
similarity index 50%
copy from mojo/dart/packages/_mojo_for_test_only/lib/test/echo_service.mojom.dart
copy to mojo/dart/packages/mojo_services/lib/mojo/media/media_player.mojom.dart
index 256e7ea680b176318ce0f2d1bbbe03ba7a056ed2..aec5e3136b2f92f8ca4644c1ba19b43e1cc50af7 100644
--- a/mojo/dart/packages/_mojo_for_test_only/lib/test/echo_service.mojom.dart
+++ b/mojo/dart/packages/mojo_services/lib/mojo/media/media_player.mojom.dart
@@ -2,24 +2,29 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-library echo_service_mojom;
+library media_player_mojom;
 
 import 'dart:async';
 
 import 'package:mojo/bindings.dart' as bindings;
 import 'package:mojo/core.dart' as core;
+import 'package:mojo_services/mojo/media/media_metadata.mojom.dart' as media_metadata_mojom;
+import 'package:mojo_services/mojo/media/media_state.mojom.dart' as media_state_mojom;
+import 'package:mojo_services/mojo/media/rate_control.mojom.dart' as rate_control_mojom;
 
 
 
-class EchoServiceEchoStringParams extends bindings.Struct {
+class MediaPlayerStatus extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(16, 0)
+    const bindings.StructDataHeader(32, 0)
   ];
-  String value = null;
+  media_state_mojom.MediaState state = null;
+  rate_control_mojom.TimelineTransform timelineTransform = null;
+  media_metadata_mojom.MediaMetadata metadata = null;
 
-  EchoServiceEchoStringParams() : super(kVersions.last.size);
+  MediaPlayerStatus() : super(kVersions.last.size);
 
-  static EchoServiceEchoStringParams deserialize(bindings.Message message) {
+  static MediaPlayerStatus deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -28,11 +33,11 @@ class EchoServiceEchoStringParams extends bindings.Struct {
     return result;
   }
 
-  static EchoServiceEchoStringParams decode(bindings.Decoder decoder0) {
+  static MediaPlayerStatus decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    EchoServiceEchoStringParams result = new EchoServiceEchoStringParams();
+    MediaPlayerStatus result = new MediaPlayerStatus();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -54,7 +59,21 @@ class EchoServiceEchoStringParams extends bindings.Struct {
     }
     if (mainDataHeader.version >= 0) {
       
-      result.value = decoder0.decodeString(8, true);
+        result.state = media_state_mojom.MediaState.decode(decoder0, 8);
+        if (result.state == null) {
+          throw new bindings.MojoCodecError(
+            'Trying to decode null union for non-nullable media_state_mojom.MediaState.');
+        }
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      var decoder1 = decoder0.decodePointer(16, true);
+      result.timelineTransform = rate_control_mojom.TimelineTransform.decode(decoder1);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      var decoder1 = decoder0.decodePointer(24, true);
+      result.metadata = media_metadata_mojom.MediaMetadata.decode(decoder1);
     }
     return result;
   }
@@ -62,31 +81,38 @@ class EchoServiceEchoStringParams extends bindings.Struct {
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     
-    encoder0.encodeString(value, 8, true);
+    encoder0.encodeEnum(state, 8);
+    
+    encoder0.encodeStruct(timelineTransform, 16, true);
+    
+    encoder0.encodeStruct(metadata, 24, true);
   }
 
   String toString() {
-    return "EchoServiceEchoStringParams("
-           "value: $value" ")";
+    return "MediaPlayerStatus("
+           "state: $state" ", "
+           "timelineTransform: $timelineTransform" ", "
+           "metadata: $metadata" ")";
   }
 
   Map toJson() {
     Map map = new Map();
-    map["value"] = value;
+    map["state"] = state;
+    map["timelineTransform"] = timelineTransform;
+    map["metadata"] = metadata;
     return map;
   }
 }
 
 
-class EchoServiceEchoStringResponseParams extends bindings.Struct {
+class MediaPlayerPlayParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(16, 0)
+    const bindings.StructDataHeader(8, 0)
   ];
-  String value = null;
 
-  EchoServiceEchoStringResponseParams() : super(kVersions.last.size);
+  MediaPlayerPlayParams() : super(kVersions.last.size);
 
-  static EchoServiceEchoStringResponseParams deserialize(bindings.Message message) {
+  static MediaPlayerPlayParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -95,11 +121,11 @@ class EchoServiceEchoStringResponseParams extends bindings.Struct {
     return result;
   }
 
-  static EchoServiceEchoStringResponseParams decode(bindings.Decoder decoder0) {
+  static MediaPlayerPlayParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    EchoServiceEchoStringResponseParams result = new EchoServiceEchoStringResponseParams();
+    MediaPlayerPlayParams result = new MediaPlayerPlayParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -119,42 +145,32 @@ class EchoServiceEchoStringResponseParams 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.value = decoder0.decodeString(8, true);
-    }
     return result;
   }
 
   void encode(bindings.Encoder encoder) {
-    var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
-    
-    encoder0.encodeString(value, 8, true);
+    encoder.getStructEncoderAtOffset(kVersions.last);
   }
 
   String toString() {
-    return "EchoServiceEchoStringResponseParams("
-           "value: $value" ")";
+    return "MediaPlayerPlayParams("")";
   }
 
   Map toJson() {
     Map map = new Map();
-    map["value"] = value;
     return map;
   }
 }
 
 
-class EchoServiceDelayedEchoStringParams extends bindings.Struct {
+class MediaPlayerPauseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(24, 0)
+    const bindings.StructDataHeader(8, 0)
   ];
-  String value = null;
-  int millis = 0;
 
-  EchoServiceDelayedEchoStringParams() : super(kVersions.last.size);
+  MediaPlayerPauseParams() : super(kVersions.last.size);
 
-  static EchoServiceDelayedEchoStringParams deserialize(bindings.Message message) {
+  static MediaPlayerPauseParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -163,11 +179,11 @@ class EchoServiceDelayedEchoStringParams extends bindings.Struct {
     return result;
   }
 
-  static EchoServiceDelayedEchoStringParams decode(bindings.Decoder decoder0) {
+  static MediaPlayerPauseParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    EchoServiceDelayedEchoStringParams result = new EchoServiceDelayedEchoStringParams();
+    MediaPlayerPauseParams result = new MediaPlayerPauseParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -187,13 +203,68 @@ class EchoServiceDelayedEchoStringParams 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.value = decoder0.decodeString(8, true);
+    return result;
+  }
+
+  void encode(bindings.Encoder encoder) {
+    encoder.getStructEncoderAtOffset(kVersions.last);
+  }
+
+  String toString() {
+    return "MediaPlayerPauseParams("")";
+  }
+
+  Map toJson() {
+    Map map = new Map();
+    return map;
+  }
+}
+
+
+class MediaPlayerGetStatusParams extends bindings.Struct {
+  static const List<bindings.StructDataHeader> kVersions = const [
+    const bindings.StructDataHeader(16, 0)
+  ];
+  int versionLastSeen = 0;
+
+  MediaPlayerGetStatusParams() : super(kVersions.last.size);
+
+  static MediaPlayerGetStatusParams 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 MediaPlayerGetStatusParams decode(bindings.Decoder decoder0) {
+    if (decoder0 == null) {
+      return null;
+    }
+    MediaPlayerGetStatusParams result = new MediaPlayerGetStatusParams();
+
+    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.millis = decoder0.decodeInt32(16);
+      result.versionLastSeen = decoder0.decodeUint64(8);
     }
     return result;
   }
@@ -201,35 +272,32 @@ class EchoServiceDelayedEchoStringParams extends bindings.Struct {
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     
-    encoder0.encodeString(value, 8, true);
-    
-    encoder0.encodeInt32(millis, 16);
+    encoder0.encodeUint64(versionLastSeen, 8);
   }
 
   String toString() {
-    return "EchoServiceDelayedEchoStringParams("
-           "value: $value" ", "
-           "millis: $millis" ")";
+    return "MediaPlayerGetStatusParams("
+           "versionLastSeen: $versionLastSeen" ")";
   }
 
   Map toJson() {
     Map map = new Map();
-    map["value"] = value;
-    map["millis"] = millis;
+    map["versionLastSeen"] = versionLastSeen;
     return map;
   }
 }
 
 
-class EchoServiceDelayedEchoStringResponseParams extends bindings.Struct {
+class MediaPlayerGetStatusResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(16, 0)
+    const bindings.StructDataHeader(24, 0)
   ];
-  String value = null;
+  int version = 0;
+  MediaPlayerStatus status = null;
 
-  EchoServiceDelayedEchoStringResponseParams() : super(kVersions.last.size);
+  MediaPlayerGetStatusResponseParams() : super(kVersions.last.size);
 
-  static EchoServiceDelayedEchoStringResponseParams deserialize(bindings.Message message) {
+  static MediaPlayerGetStatusResponseParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -238,11 +306,11 @@ class EchoServiceDelayedEchoStringResponseParams extends bindings.Struct {
     return result;
   }
 
-  static EchoServiceDelayedEchoStringResponseParams decode(bindings.Decoder decoder0) {
+  static MediaPlayerGetStatusResponseParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    EchoServiceDelayedEchoStringResponseParams result = new EchoServiceDelayedEchoStringResponseParams();
+    MediaPlayerGetStatusResponseParams result = new MediaPlayerGetStatusResponseParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -264,7 +332,12 @@ class EchoServiceDelayedEchoStringResponseParams extends bindings.Struct {
     }
     if (mainDataHeader.version >= 0) {
       
-      result.value = decoder0.decodeString(8, true);
+      result.version = decoder0.decodeUint64(8);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      var decoder1 = decoder0.decodePointer(16, false);
+      result.status = MediaPlayerStatus.decode(decoder1);
     }
     return result;
   }
@@ -272,73 +345,59 @@ class EchoServiceDelayedEchoStringResponseParams extends bindings.Struct {
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     
-    encoder0.encodeString(value, 8, true);
+    encoder0.encodeUint64(version, 8);
+    
+    encoder0.encodeStruct(status, 16, false);
   }
 
   String toString() {
-    return "EchoServiceDelayedEchoStringResponseParams("
-           "value: $value" ")";
+    return "MediaPlayerGetStatusResponseParams("
+           "version: $version" ", "
+           "status: $status" ")";
   }
 
   Map toJson() {
     Map map = new Map();
-    map["value"] = value;
+    map["version"] = version;
+    map["status"] = status;
     return map;
   }
 }
 
-const int kEchoService_echoString_name = 0;
-const int kEchoService_delayedEchoString_name = 1;
-const String EchoServiceName = "test::EchoService";
+const int kMediaPlayer_play_name = 0;
+const int kMediaPlayer_pause_name = 1;
+const int kMediaPlayer_getStatus_name = 2;
+const String MediaPlayerName = null;
 
-abstract class EchoService {
-  dynamic echoString(String value,[Function responseFactory = null]);
-  dynamic delayedEchoString(String value,int millis,[Function responseFactory = null]);
+abstract class MediaPlayer {
+  void play();
+  void pause();
+  dynamic getStatus(int versionLastSeen,[Function responseFactory = null]);
 
 }
 
 
-class EchoServiceProxyImpl extends bindings.Proxy {
-  EchoServiceProxyImpl.fromEndpoint(
+class MediaPlayerProxyImpl extends bindings.Proxy {
+  MediaPlayerProxyImpl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
-  EchoServiceProxyImpl.fromHandle(core.MojoHandle handle) :
+  MediaPlayerProxyImpl.fromHandle(core.MojoHandle handle) :
       super.fromHandle(handle);
 
-  EchoServiceProxyImpl.unbound() : super.unbound();
+  MediaPlayerProxyImpl.unbound() : super.unbound();
 
-  static EchoServiceProxyImpl newFromEndpoint(
+  static MediaPlayerProxyImpl newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For EchoServiceProxyImpl"));
-    return new EchoServiceProxyImpl.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For MediaPlayerProxyImpl"));
+    return new MediaPlayerProxyImpl.fromEndpoint(endpoint);
   }
 
-  String get name => EchoServiceName;
+  String get name => MediaPlayerName;
 
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
-      case kEchoService_echoString_name:
-        var r = EchoServiceEchoStringResponseParams.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 kEchoService_delayedEchoString_name:
-        var r = EchoServiceDelayedEchoStringResponseParams.deserialize(
+      case kMediaPlayer_getStatus_name:
+        var r = MediaPlayerGetStatusResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
@@ -366,73 +425,81 @@ class EchoServiceProxyImpl extends bindings.Proxy {
 
   String toString() {
     var superString = super.toString();
-    return "EchoServiceProxyImpl($superString)";
+    return "MediaPlayerProxyImpl($superString)";
   }
 }
 
 
-class _EchoServiceProxyCalls implements EchoService {
-  EchoServiceProxyImpl _proxyImpl;
+class _MediaPlayerProxyCalls implements MediaPlayer {
+  MediaPlayerProxyImpl _proxyImpl;
 
-  _EchoServiceProxyCalls(this._proxyImpl);
-    dynamic echoString(String value,[Function responseFactory = null]) {
-      var params = new EchoServiceEchoStringParams();
-      params.value = value;
-      return _proxyImpl.sendMessageWithRequestId(
-          params,
-          kEchoService_echoString_name,
-          -1,
-          bindings.MessageHeader.kMessageExpectsResponse);
+  _MediaPlayerProxyCalls(this._proxyImpl);
+    void play() {
+      if (!_proxyImpl.isBound) {
+        _proxyImpl.proxyError("The Proxy is closed.");
+        return;
+      }
+      var params = new MediaPlayerPlayParams();
+      _proxyImpl.sendMessage(params, kMediaPlayer_play_name);
+    }
+  
+    void pause() {
+      if (!_proxyImpl.isBound) {
+        _proxyImpl.proxyError("The Proxy is closed.");
+        return;
+      }
+      var params = new MediaPlayerPauseParams();
+      _proxyImpl.sendMessage(params, kMediaPlayer_pause_name);
     }
-    dynamic delayedEchoString(String value,int millis,[Function responseFactory = null]) {
-      var params = new EchoServiceDelayedEchoStringParams();
-      params.value = value;
-      params.millis = millis;
+  
+    dynamic getStatus(int versionLastSeen,[Function responseFactory = null]) {
+      var params = new MediaPlayerGetStatusParams();
+      params.versionLastSeen = versionLastSeen;
       return _proxyImpl.sendMessageWithRequestId(
           params,
-          kEchoService_delayedEchoString_name,
+          kMediaPlayer_getStatus_name,
           -1,
           bindings.MessageHeader.kMessageExpectsResponse);
     }
 }
 
 
-class EchoServiceProxy implements bindings.ProxyBase {
+class MediaPlayerProxy implements bindings.ProxyBase {
   final bindings.Proxy impl;
-  EchoService ptr;
-  final String name = EchoServiceName;
+  MediaPlayer ptr;
+  final String name = MediaPlayerName;
 
-  EchoServiceProxy(EchoServiceProxyImpl proxyImpl) :
+  MediaPlayerProxy(MediaPlayerProxyImpl proxyImpl) :
       impl = proxyImpl,
-      ptr = new _EchoServiceProxyCalls(proxyImpl);
+      ptr = new _MediaPlayerProxyCalls(proxyImpl);
 
-  EchoServiceProxy.fromEndpoint(
+  MediaPlayerProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) :
-      impl = new EchoServiceProxyImpl.fromEndpoint(endpoint) {
-    ptr = new _EchoServiceProxyCalls(impl);
+      impl = new MediaPlayerProxyImpl.fromEndpoint(endpoint) {
+    ptr = new _MediaPlayerProxyCalls(impl);
   }
 
-  EchoServiceProxy.fromHandle(core.MojoHandle handle) :
-      impl = new EchoServiceProxyImpl.fromHandle(handle) {
-    ptr = new _EchoServiceProxyCalls(impl);
+  MediaPlayerProxy.fromHandle(core.MojoHandle handle) :
+      impl = new MediaPlayerProxyImpl.fromHandle(handle) {
+    ptr = new _MediaPlayerProxyCalls(impl);
   }
 
-  EchoServiceProxy.unbound() :
-      impl = new EchoServiceProxyImpl.unbound() {
-    ptr = new _EchoServiceProxyCalls(impl);
+  MediaPlayerProxy.unbound() :
+      impl = new MediaPlayerProxyImpl.unbound() {
+    ptr = new _MediaPlayerProxyCalls(impl);
   }
 
-  factory EchoServiceProxy.connectToService(
+  factory MediaPlayerProxy.connectToService(
       bindings.ServiceConnector s, String url) {
-    EchoServiceProxy p = new EchoServiceProxy.unbound();
+    MediaPlayerProxy p = new MediaPlayerProxy.unbound();
     s.connectToService(url, p);
     return p;
   }
 
-  static EchoServiceProxy newFromEndpoint(
+  static MediaPlayerProxy newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For EchoServiceProxy"));
-    return new EchoServiceProxy.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For MediaPlayerProxy"));
+    return new MediaPlayerProxy.fromEndpoint(endpoint);
   }
 
   Future close({bool immediate: false}) => impl.close(immediate: immediate);
@@ -450,40 +517,36 @@ class EchoServiceProxy implements bindings.ProxyBase {
   }
 
   String toString() {
-    return "EchoServiceProxy($impl)";
+    return "MediaPlayerProxy($impl)";
   }
 }
 
 
-class EchoServiceStub extends bindings.Stub {
-  EchoService _impl = null;
+class MediaPlayerStub extends bindings.Stub {
+  MediaPlayer _impl = null;
 
-  EchoServiceStub.fromEndpoint(
+  MediaPlayerStub.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [this._impl])
       : super.fromEndpoint(endpoint);
 
-  EchoServiceStub.fromHandle(core.MojoHandle handle, [this._impl])
+  MediaPlayerStub.fromHandle(core.MojoHandle handle, [this._impl])
       : super.fromHandle(handle);
 
-  EchoServiceStub.unbound() : super.unbound();
+  MediaPlayerStub.unbound() : super.unbound();
 
-  static EchoServiceStub newFromEndpoint(
+  static MediaPlayerStub newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For EchoServiceStub"));
-    return new EchoServiceStub.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For MediaPlayerStub"));
+    return new MediaPlayerStub.fromEndpoint(endpoint);
   }
 
-  static const String name = EchoServiceName;
+  static const String name = MediaPlayerName;
 
 
-  EchoServiceEchoStringResponseParams _EchoServiceEchoStringResponseParamsFactory(String value) {
-    var mojo_factory_result = new EchoServiceEchoStringResponseParams();
-    mojo_factory_result.value = value;
-    return mojo_factory_result;
-  }
-  EchoServiceDelayedEchoStringResponseParams _EchoServiceDelayedEchoStringResponseParamsFactory(String value) {
-    var mojo_factory_result = new EchoServiceDelayedEchoStringResponseParams();
-    mojo_factory_result.value = value;
+  MediaPlayerGetStatusResponseParams _MediaPlayerGetStatusResponseParamsFactory(int version, MediaPlayerStatus status) {
+    var mojo_factory_result = new MediaPlayerGetStatusResponseParams();
+    mojo_factory_result.version = version;
+    mojo_factory_result.status = status;
     return mojo_factory_result;
   }
 
@@ -495,38 +558,26 @@ class EchoServiceStub extends bindings.Stub {
     }
     assert(_impl != null);
     switch (message.header.type) {
-      case kEchoService_echoString_name:
-        var params = EchoServiceEchoStringParams.deserialize(
+      case kMediaPlayer_play_name:
+        var params = MediaPlayerPlayParams.deserialize(
             message.payload);
-        var response = _impl.echoString(params.value,_EchoServiceEchoStringResponseParamsFactory);
-        if (response is Future) {
-          return response.then((response) {
-            if (response != null) {
-              return buildResponseWithId(
-                  response,
-                  kEchoService_echoString_name,
-                  message.header.requestId,
-                  bindings.MessageHeader.kMessageIsResponse);
-            }
-          });
-        } else if (response != null) {
-          return buildResponseWithId(
-              response,
-              kEchoService_echoString_name,
-              message.header.requestId,
-              bindings.MessageHeader.kMessageIsResponse);
-        }
+        _impl.play();
+        break;
+      case kMediaPlayer_pause_name:
+        var params = MediaPlayerPauseParams.deserialize(
+            message.payload);
+        _impl.pause();
         break;
-      case kEchoService_delayedEchoString_name:
-        var params = EchoServiceDelayedEchoStringParams.deserialize(
+      case kMediaPlayer_getStatus_name:
+        var params = MediaPlayerGetStatusParams.deserialize(
             message.payload);
-        var response = _impl.delayedEchoString(params.value,params.millis,_EchoServiceDelayedEchoStringResponseParamsFactory);
+        var response = _impl.getStatus(params.versionLastSeen,_MediaPlayerGetStatusResponseParamsFactory);
         if (response is Future) {
           return response.then((response) {
             if (response != null) {
               return buildResponseWithId(
                   response,
-                  kEchoService_delayedEchoString_name,
+                  kMediaPlayer_getStatus_name,
                   message.header.requestId,
                   bindings.MessageHeader.kMessageIsResponse);
             }
@@ -534,7 +585,7 @@ class EchoServiceStub extends bindings.Stub {
         } else if (response != null) {
           return buildResponseWithId(
               response,
-              kEchoService_delayedEchoString_name,
+              kMediaPlayer_getStatus_name,
               message.header.requestId,
               bindings.MessageHeader.kMessageIsResponse);
         }
@@ -546,15 +597,15 @@ class EchoServiceStub extends bindings.Stub {
     return null;
   }
 
-  EchoService get impl => _impl;
-  set impl(EchoService d) {
+  MediaPlayer get impl => _impl;
+  set impl(MediaPlayer d) {
     assert(_impl == null);
     _impl = d;
   }
 
   String toString() {
     var superString = super.toString();
-    return "EchoServiceStub($superString)";
+    return "MediaPlayerStub($superString)";
   }
 
   int get version => 0;