Motown: Rename Ratio and LinearFunction classes

mojo/dart/packages/mojo_services/lib/mojo/timelines.mojom.dart

Index: mojo/dart/packages/mojo_services/lib/mojo/timelines.mojom.dart
diff --git a/mojo/dart/packages/mojo_services/lib/mojo/gfx/composition/compositor.mojom.dart b/mojo/dart/packages/mojo_services/lib/mojo/timelines.mojom.dart
similarity index 50%
copy from mojo/dart/packages/mojo_services/lib/mojo/gfx/composition/compositor.mojom.dart
copy to mojo/dart/packages/mojo_services/lib/mojo/timelines.mojom.dart
index 3615eb6664c96d27dfcbb185d910f4b6884d512b..1c97d38bdaccee175a892e79f1cbd0a7e48a634f 100644
--- a/mojo/dart/packages/mojo_services/lib/mojo/gfx/composition/compositor.mojom.dart
+++ b/mojo/dart/packages/mojo_services/lib/mojo/timelines.mojom.dart
@@ -2,29 +2,26 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-library compositor_mojom;
+library timelines_mojom;
 import 'dart:async';
 import 'package:mojo/bindings.dart' as bindings;
 import 'package:mojo/core.dart' as core;
 import 'package:mojo/mojo/bindings/types/service_describer.mojom.dart' as service_describer;
-import 'package:mojo_services/mojo/gfx/composition/renderers.mojom.dart' as renderers_mojom;
-import 'package:mojo_services/mojo/gfx/composition/scene_token.mojom.dart' as scene_token_mojom;
-import 'package:mojo_services/mojo/gfx/composition/scenes.mojom.dart' as scenes_mojom;
-import 'package:mojom/mojo/context_provider.mojom.dart' as context_provider_mojom;
-const int kLabelMaxLength = 32;
 
 
 
-class _CompositorCreateSceneParams extends bindings.Struct {
+class TimelineTransform extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(24, 0)
+    const bindings.StructDataHeader(32, 0)
   ];
-  Object scene = null;
-  String label = null;
+  int referenceTime = 0;
+  int subjectTime = 0;
+  int referenceDelta = 1;
+  int subjectDelta = 0;
 
-  _CompositorCreateSceneParams() : super(kVersions.last.size);
+  TimelineTransform() : super(kVersions.last.size);
 
-  static _CompositorCreateSceneParams deserialize(bindings.Message message) {
+  static TimelineTransform deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -33,11 +30,11 @@ class _CompositorCreateSceneParams extends bindings.Struct {
     return result;
   }
 
-  static _CompositorCreateSceneParams decode(bindings.Decoder decoder0) {
+  static TimelineTransform decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    _CompositorCreateSceneParams result = new _CompositorCreateSceneParams();
+    TimelineTransform result = new TimelineTransform();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -59,11 +56,19 @@ class _CompositorCreateSceneParams extends bindings.Struct {
     }
     if (mainDataHeader.version >= 0) {
       
-      result.scene = decoder0.decodeInterfaceRequest(8, false, scenes_mojom.SceneStub.newFromEndpoint);
+      result.referenceTime = decoder0.decodeInt64(8);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.subjectTime = decoder0.decodeInt64(16);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.referenceDelta = decoder0.decodeUint32(24);
     }
     if (mainDataHeader.version >= 0) {
       
-      result.label = decoder0.decodeString(16, true);
+      result.subjectDelta = decoder0.decodeUint32(28);
     }
     return result;
   }
@@ -71,43 +76,67 @@ class _CompositorCreateSceneParams extends bindings.Struct {
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     try {
-      encoder0.encodeInterfaceRequest(scene, 8, false);
+      encoder0.encodeInt64(referenceTime, 8);
     } on bindings.MojoCodecError catch(e) {
       e.message = "Error encountered while encoding field "
-          "scene of struct _CompositorCreateSceneParams: $e";
+          "referenceTime of struct TimelineTransform: $e";
       rethrow;
     }
     try {
-      encoder0.encodeString(label, 16, true);
+      encoder0.encodeInt64(subjectTime, 16);
     } on bindings.MojoCodecError catch(e) {
       e.message = "Error encountered while encoding field "
-          "label of struct _CompositorCreateSceneParams: $e";
+          "subjectTime of struct TimelineTransform: $e";
+      rethrow;
+    }
+    try {
+      encoder0.encodeUint32(referenceDelta, 24);
+    } on bindings.MojoCodecError catch(e) {
+      e.message = "Error encountered while encoding field "
+          "referenceDelta of struct TimelineTransform: $e";
+      rethrow;
+    }
+    try {
+      encoder0.encodeUint32(subjectDelta, 28);
+    } on bindings.MojoCodecError catch(e) {
+      e.message = "Error encountered while encoding field "
+          "subjectDelta of struct TimelineTransform: $e";
       rethrow;
     }
   }
 
   String toString() {
-    return "_CompositorCreateSceneParams("
-           "scene: $scene" ", "
-           "label: $label" ")";
+    return "TimelineTransform("
+           "referenceTime: $referenceTime" ", "
+           "subjectTime: $subjectTime" ", "
+           "referenceDelta: $referenceDelta" ", "
+           "subjectDelta: $subjectDelta" ")";
   }
 
   Map toJson() {
-    throw new bindings.MojoCodecError(
-        'Object containing handles cannot be encoded to JSON.');
+    Map map = new Map();
+    map["referenceTime"] = referenceTime;
+    map["subjectTime"] = subjectTime;
+    map["referenceDelta"] = referenceDelta;
+    map["subjectDelta"] = subjectDelta;
+    return map;
   }
 }
 
 
-class CompositorCreateSceneResponseParams extends bindings.Struct {
+class _TimelineConsumerSetTimelineTransformParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(16, 0)
+    const bindings.StructDataHeader(40, 0)
   ];
-  scene_token_mojom.SceneToken sceneToken = null;
+  int subjectTime = 0;
+  int referenceDelta = 0;
+  int subjectDelta = 0;
+  int effectiveReferenceTime = 0;
+  int effectiveSubjectTime = 0;
 
-  CompositorCreateSceneResponseParams() : super(kVersions.last.size);
+  _TimelineConsumerSetTimelineTransformParams() : super(kVersions.last.size);
 
-  static CompositorCreateSceneResponseParams deserialize(bindings.Message message) {
+  static _TimelineConsumerSetTimelineTransformParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -116,11 +145,11 @@ class CompositorCreateSceneResponseParams extends bindings.Struct {
     return result;
   }
 
-  static CompositorCreateSceneResponseParams decode(bindings.Decoder decoder0) {
+  static _TimelineConsumerSetTimelineTransformParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    CompositorCreateSceneResponseParams result = new CompositorCreateSceneResponseParams();
+    _TimelineConsumerSetTimelineTransformParams result = new _TimelineConsumerSetTimelineTransformParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -142,8 +171,23 @@ class CompositorCreateSceneResponseParams extends bindings.Struct {
     }
     if (mainDataHeader.version >= 0) {
       
-      var decoder1 = decoder0.decodePointer(8, false);
-      result.sceneToken = scene_token_mojom.SceneToken.decode(decoder1);
+      result.subjectTime = decoder0.decodeInt64(8);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.referenceDelta = decoder0.decodeUint32(16);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.subjectDelta = decoder0.decodeUint32(20);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.effectiveReferenceTime = decoder0.decodeInt64(24);
+    }
+    if (mainDataHeader.version >= 0) {
+      
+      result.effectiveSubjectTime = decoder0.decodeInt64(32);
     }
     return result;
   }
@@ -151,38 +195,72 @@ class CompositorCreateSceneResponseParams extends bindings.Struct {
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     try {
-      encoder0.encodeStruct(sceneToken, 8, false);
+      encoder0.encodeInt64(subjectTime, 8);
+    } on bindings.MojoCodecError catch(e) {
+      e.message = "Error encountered while encoding field "
+          "subjectTime of struct _TimelineConsumerSetTimelineTransformParams: $e";
+      rethrow;
+    }
+    try {
+      encoder0.encodeUint32(referenceDelta, 16);
+    } on bindings.MojoCodecError catch(e) {
+      e.message = "Error encountered while encoding field "
+          "referenceDelta of struct _TimelineConsumerSetTimelineTransformParams: $e";
+      rethrow;
+    }
+    try {
+      encoder0.encodeUint32(subjectDelta, 20);
+    } on bindings.MojoCodecError catch(e) {
+      e.message = "Error encountered while encoding field "
+          "subjectDelta of struct _TimelineConsumerSetTimelineTransformParams: $e";
+      rethrow;
+    }
+    try {
+      encoder0.encodeInt64(effectiveReferenceTime, 24);
     } on bindings.MojoCodecError catch(e) {
       e.message = "Error encountered while encoding field "
-          "sceneToken of struct CompositorCreateSceneResponseParams: $e";
+          "effectiveReferenceTime of struct _TimelineConsumerSetTimelineTransformParams: $e";
+      rethrow;
+    }
+    try {
+      encoder0.encodeInt64(effectiveSubjectTime, 32);
+    } on bindings.MojoCodecError catch(e) {
+      e.message = "Error encountered while encoding field "
+          "effectiveSubjectTime of struct _TimelineConsumerSetTimelineTransformParams: $e";
       rethrow;
     }
   }
 
   String toString() {
-    return "CompositorCreateSceneResponseParams("
-           "sceneToken: $sceneToken" ")";
+    return "_TimelineConsumerSetTimelineTransformParams("
+           "subjectTime: $subjectTime" ", "
+           "referenceDelta: $referenceDelta" ", "
+           "subjectDelta: $subjectDelta" ", "
+           "effectiveReferenceTime: $effectiveReferenceTime" ", "
+           "effectiveSubjectTime: $effectiveSubjectTime" ")";
   }
 
   Map toJson() {
     Map map = new Map();
-    map["sceneToken"] = sceneToken;
+    map["subjectTime"] = subjectTime;
+    map["referenceDelta"] = referenceDelta;
+    map["subjectDelta"] = subjectDelta;
+    map["effectiveReferenceTime"] = effectiveReferenceTime;
+    map["effectiveSubjectTime"] = effectiveSubjectTime;
     return map;
   }
 }
 
 
-class _CompositorCreateRendererParams extends bindings.Struct {
+class TimelineConsumerSetTimelineTransformResponseParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
-    const bindings.StructDataHeader(32, 0)
+    const bindings.StructDataHeader(16, 0)
   ];
-  Object contextProvider = null;
-  Object renderer = null;
-  String label = null;
+  bool completed = false;
 
-  _CompositorCreateRendererParams() : super(kVersions.last.size);
+  TimelineConsumerSetTimelineTransformResponseParams() : super(kVersions.last.size);
 
-  static _CompositorCreateRendererParams deserialize(bindings.Message message) {
+  static TimelineConsumerSetTimelineTransformResponseParams deserialize(bindings.Message message) {
     var decoder = new bindings.Decoder(message);
     var result = decode(decoder);
     if (decoder.excessHandles != null) {
@@ -191,11 +269,11 @@ class _CompositorCreateRendererParams extends bindings.Struct {
     return result;
   }
 
-  static _CompositorCreateRendererParams decode(bindings.Decoder decoder0) {
+  static TimelineConsumerSetTimelineTransformResponseParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    _CompositorCreateRendererParams result = new _CompositorCreateRendererParams();
+    TimelineConsumerSetTimelineTransformResponseParams result = new TimelineConsumerSetTimelineTransformResponseParams();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
     if (mainDataHeader.version <= kVersions.last.version) {
@@ -217,15 +295,7 @@ class _CompositorCreateRendererParams extends bindings.Struct {
     }
     if (mainDataHeader.version >= 0) {
       
-      result.contextProvider = decoder0.decodeServiceInterface(8, false, context_provider_mojom.ContextProviderProxy.newFromEndpoint);
-    }
-    if (mainDataHeader.version >= 0) {
-      
-      result.renderer = decoder0.decodeInterfaceRequest(16, false, renderers_mojom.RendererStub.newFromEndpoint);
-    }
-    if (mainDataHeader.version >= 0) {
-      
-      result.label = decoder0.decodeString(24, true);
+      result.completed = decoder0.decodeBool(8, 0);
     }
     return result;
   }
@@ -233,45 +303,29 @@ class _CompositorCreateRendererParams extends bindings.Struct {
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     try {
-      encoder0.encodeInterface(contextProvider, 8, false);
-    } on bindings.MojoCodecError catch(e) {
-      e.message = "Error encountered while encoding field "
-          "contextProvider of struct _CompositorCreateRendererParams: $e";
-      rethrow;
-    }
-    try {
-      encoder0.encodeInterfaceRequest(renderer, 16, false);
+      encoder0.encodeBool(completed, 8, 0);
     } on bindings.MojoCodecError catch(e) {
       e.message = "Error encountered while encoding field "
-          "renderer of struct _CompositorCreateRendererParams: $e";
-      rethrow;
-    }
-    try {
-      encoder0.encodeString(label, 24, true);
-    } on bindings.MojoCodecError catch(e) {
-      e.message = "Error encountered while encoding field "
-          "label of struct _CompositorCreateRendererParams: $e";
+          "completed of struct TimelineConsumerSetTimelineTransformResponseParams: $e";
       rethrow;
     }
   }
 
   String toString() {
-    return "_CompositorCreateRendererParams("
-           "contextProvider: $contextProvider" ", "
-           "renderer: $renderer" ", "
-           "label: $label" ")";
+    return "TimelineConsumerSetTimelineTransformResponseParams("
+           "completed: $completed" ")";
   }
 
   Map toJson() {
-    throw new bindings.MojoCodecError(
-        'Object containing handles cannot be encoded to JSON.');
+    Map map = new Map();
+    map["completed"] = completed;
+    return map;
   }
 }
 
-const int _compositorMethodCreateSceneName = 0;
-const int _compositorMethodCreateRendererName = 1;
+const int _timelineConsumerMethodSetTimelineTransformName = 0;
 
-class _CompositorServiceDescription implements service_describer.ServiceDescription {
+class _TimelineConsumerServiceDescription implements service_describer.ServiceDescription {
   dynamic getTopLevelInterface([Function responseFactory]) =>
       responseFactory(null);
 
@@ -282,35 +336,35 @@ class _CompositorServiceDescription implements service_describer.ServiceDescript
       responseFactory(null);
 }
 
-abstract class Compositor {
-  static const String serviceName = "mojo::gfx::composition::Compositor";
-  dynamic createScene(Object scene,String label,[Function responseFactory = null]);
-  void createRenderer(Object contextProvider, Object renderer, String label);
+abstract class TimelineConsumer {
+  static const String serviceName = null;
+  dynamic setTimelineTransform(int subjectTime,int referenceDelta,int subjectDelta,int effectiveReferenceTime,int effectiveSubjectTime,[Function responseFactory = null]);
+  static const int kUnspecifiedTime = 9223372036854775807;
 }
 
 
-class _CompositorProxyImpl extends bindings.Proxy {
-  _CompositorProxyImpl.fromEndpoint(
+class _TimelineConsumerProxyImpl extends bindings.Proxy {
+  _TimelineConsumerProxyImpl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
-  _CompositorProxyImpl.fromHandle(core.MojoHandle handle) :
+  _TimelineConsumerProxyImpl.fromHandle(core.MojoHandle handle) :
       super.fromHandle(handle);
 
-  _CompositorProxyImpl.unbound() : super.unbound();
+  _TimelineConsumerProxyImpl.unbound() : super.unbound();
 
-  static _CompositorProxyImpl newFromEndpoint(
+  static _TimelineConsumerProxyImpl newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For _CompositorProxyImpl"));
-    return new _CompositorProxyImpl.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For _TimelineConsumerProxyImpl"));
+    return new _TimelineConsumerProxyImpl.fromEndpoint(endpoint);
   }
 
   service_describer.ServiceDescription get serviceDescription =>
-    new _CompositorServiceDescription();
+    new _TimelineConsumerServiceDescription();
 
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
-      case _compositorMethodCreateSceneName:
-        var r = CompositorCreateSceneResponseParams.deserialize(
+      case _timelineConsumerMethodSetTimelineTransformName:
+        var r = TimelineConsumerSetTimelineTransformResponseParams.deserialize(
             message.payload);
         if (!message.header.hasRequestId) {
           proxyError("Expected a message with a valid request Id.");
@@ -338,77 +392,69 @@ class _CompositorProxyImpl extends bindings.Proxy {
 
   String toString() {
     var superString = super.toString();
-    return "_CompositorProxyImpl($superString)";
+    return "_TimelineConsumerProxyImpl($superString)";
   }
 }
 
 
-class _CompositorProxyCalls implements Compositor {
-  _CompositorProxyImpl _proxyImpl;
+class _TimelineConsumerProxyCalls implements TimelineConsumer {
+  _TimelineConsumerProxyImpl _proxyImpl;
 
-  _CompositorProxyCalls(this._proxyImpl);
-    dynamic createScene(Object scene,String label,[Function responseFactory = null]) {
-      var params = new _CompositorCreateSceneParams();
-      params.scene = scene;
-      params.label = label;
+  _TimelineConsumerProxyCalls(this._proxyImpl);
+    dynamic setTimelineTransform(int subjectTime,int referenceDelta,int subjectDelta,int effectiveReferenceTime,int effectiveSubjectTime,[Function responseFactory = null]) {
+      var params = new _TimelineConsumerSetTimelineTransformParams();
+      params.subjectTime = subjectTime;
+      params.referenceDelta = referenceDelta;
+      params.subjectDelta = subjectDelta;
+      params.effectiveReferenceTime = effectiveReferenceTime;
+      params.effectiveSubjectTime = effectiveSubjectTime;
       return _proxyImpl.sendMessageWithRequestId(
           params,
-          _compositorMethodCreateSceneName,
+          _timelineConsumerMethodSetTimelineTransformName,
           -1,
           bindings.MessageHeader.kMessageExpectsResponse);
     }
-    void createRenderer(Object contextProvider, Object renderer, String label) {
-      if (!_proxyImpl.isBound) {
-        _proxyImpl.proxyError("The Proxy is closed.");
-        return;
-      }
-      var params = new _CompositorCreateRendererParams();
-      params.contextProvider = contextProvider;
-      params.renderer = renderer;
-      params.label = label;
-      _proxyImpl.sendMessage(params, _compositorMethodCreateRendererName);
-    }
 }
 
 
-class CompositorProxy implements bindings.ProxyBase {
+class TimelineConsumerProxy implements bindings.ProxyBase {
   final bindings.Proxy impl;
-  Compositor ptr;
+  TimelineConsumer ptr;
 
-  CompositorProxy(_CompositorProxyImpl proxyImpl) :
+  TimelineConsumerProxy(_TimelineConsumerProxyImpl proxyImpl) :
       impl = proxyImpl,
-      ptr = new _CompositorProxyCalls(proxyImpl);
+      ptr = new _TimelineConsumerProxyCalls(proxyImpl);
 
-  CompositorProxy.fromEndpoint(
+  TimelineConsumerProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) :
-      impl = new _CompositorProxyImpl.fromEndpoint(endpoint) {
-    ptr = new _CompositorProxyCalls(impl);
+      impl = new _TimelineConsumerProxyImpl.fromEndpoint(endpoint) {
+    ptr = new _TimelineConsumerProxyCalls(impl);
   }
 
-  CompositorProxy.fromHandle(core.MojoHandle handle) :
-      impl = new _CompositorProxyImpl.fromHandle(handle) {
-    ptr = new _CompositorProxyCalls(impl);
+  TimelineConsumerProxy.fromHandle(core.MojoHandle handle) :
+      impl = new _TimelineConsumerProxyImpl.fromHandle(handle) {
+    ptr = new _TimelineConsumerProxyCalls(impl);
   }
 
-  CompositorProxy.unbound() :
-      impl = new _CompositorProxyImpl.unbound() {
-    ptr = new _CompositorProxyCalls(impl);
+  TimelineConsumerProxy.unbound() :
+      impl = new _TimelineConsumerProxyImpl.unbound() {
+    ptr = new _TimelineConsumerProxyCalls(impl);
   }
 
-  factory CompositorProxy.connectToService(
+  factory TimelineConsumerProxy.connectToService(
       bindings.ServiceConnector s, String url, [String serviceName]) {
-    CompositorProxy p = new CompositorProxy.unbound();
+    TimelineConsumerProxy p = new TimelineConsumerProxy.unbound();
     s.connectToService(url, p, serviceName);
     return p;
   }
 
-  static CompositorProxy newFromEndpoint(
+  static TimelineConsumerProxy newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For CompositorProxy"));
-    return new CompositorProxy.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For TimelineConsumerProxy"));
+    return new TimelineConsumerProxy.fromEndpoint(endpoint);
   }
 
-  String get serviceName => Compositor.serviceName;
+  String get serviceName => TimelineConsumer.serviceName;
 
   Future close({bool immediate: false}) => impl.close(immediate: immediate);
 
@@ -425,33 +471,33 @@ class CompositorProxy implements bindings.ProxyBase {
   }
 
   String toString() {
-    return "CompositorProxy($impl)";
+    return "TimelineConsumerProxy($impl)";
   }
 }
 
 
-class CompositorStub extends bindings.Stub {
-  Compositor _impl = null;
+class TimelineConsumerStub extends bindings.Stub {
+  TimelineConsumer _impl = null;
 
-  CompositorStub.fromEndpoint(
+  TimelineConsumerStub.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [this._impl])
       : super.fromEndpoint(endpoint);
 
-  CompositorStub.fromHandle(core.MojoHandle handle, [this._impl])
+  TimelineConsumerStub.fromHandle(core.MojoHandle handle, [this._impl])
       : super.fromHandle(handle);
 
-  CompositorStub.unbound() : super.unbound();
+  TimelineConsumerStub.unbound() : super.unbound();
 
-  static CompositorStub newFromEndpoint(
+  static TimelineConsumerStub newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For CompositorStub"));
-    return new CompositorStub.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For TimelineConsumerStub"));
+    return new TimelineConsumerStub.fromEndpoint(endpoint);
   }
 
 
-  CompositorCreateSceneResponseParams _compositorCreateSceneResponseParamsFactory(scene_token_mojom.SceneToken sceneToken) {
-    var result = new CompositorCreateSceneResponseParams();
-    result.sceneToken = sceneToken;
+  TimelineConsumerSetTimelineTransformResponseParams _timelineConsumerSetTimelineTransformResponseParamsFactory(bool completed) {
+    var result = new TimelineConsumerSetTimelineTransformResponseParams();
+    result.completed = completed;
     return result;
   }
 
@@ -463,16 +509,16 @@ class CompositorStub extends bindings.Stub {
     }
     assert(_impl != null);
     switch (message.header.type) {
-      case _compositorMethodCreateSceneName:
-        var params = _CompositorCreateSceneParams.deserialize(
+      case _timelineConsumerMethodSetTimelineTransformName:
+        var params = _TimelineConsumerSetTimelineTransformParams.deserialize(
             message.payload);
-        var response = _impl.createScene(params.scene,params.label,_compositorCreateSceneResponseParamsFactory);
+        var response = _impl.setTimelineTransform(params.subjectTime,params.referenceDelta,params.subjectDelta,params.effectiveReferenceTime,params.effectiveSubjectTime,_timelineConsumerSetTimelineTransformResponseParamsFactory);
         if (response is Future) {
           return response.then((response) {
             if (response != null) {
               return buildResponseWithId(
                   response,
-                  _compositorMethodCreateSceneName,
+                  _timelineConsumerMethodSetTimelineTransformName,
                   message.header.requestId,
                   bindings.MessageHeader.kMessageIsResponse);
             }
@@ -480,16 +526,11 @@ class CompositorStub extends bindings.Stub {
         } else if (response != null) {
           return buildResponseWithId(
               response,
-              _compositorMethodCreateSceneName,
+              _timelineConsumerMethodSetTimelineTransformName,
               message.header.requestId,
               bindings.MessageHeader.kMessageIsResponse);
         }
         break;
-      case _compositorMethodCreateRendererName:
-        var params = _CompositorCreateRendererParams.deserialize(
-            message.payload);
-        _impl.createRenderer(params.contextProvider, params.renderer, params.label);
-        break;
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
         break;
@@ -497,15 +538,15 @@ class CompositorStub extends bindings.Stub {
     return null;
   }
 
-  Compositor get impl => _impl;
-  set impl(Compositor d) {
+  TimelineConsumer get impl => _impl;
+  set impl(TimelineConsumer d) {
     assert(_impl == null);
     _impl = d;
   }
 
   String toString() {
     var superString = super.toString();
-    return "CompositorStub($superString)";
+    return "TimelineConsumerStub($superString)";
   }
 
   int get version => 0;
@@ -513,7 +554,7 @@ class CompositorStub extends bindings.Stub {
   static service_describer.ServiceDescription _cachedServiceDescription;
   static service_describer.ServiceDescription get serviceDescription {
     if (_cachedServiceDescription == null) {
-      _cachedServiceDescription = new _CompositorServiceDescription();
+      _cachedServiceDescription = new _TimelineConsumerServiceDescription();
     }
     return _cachedServiceDescription;
   }