Mojom updates for Motown.

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

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-library gpu_mojom;
+library audio_server_mojom;
 
 import 'dart:async';
 
 import 'package:mojo/bindings.dart' as bindings;
 import 'package:mojo/core.dart' as core;
-import 'package:mojo_services/mojo/command_buffer.mojom.dart' as command_buffer_mojom;
+import 'package:mojo_services/mojo/media/audio_track.mojom.dart' as audio_track_mojom;
 
 
 
-class GpuCreateOffscreenGleS2ContextParams extends bindings.Struct {
+class AudioServerCreateTrackParams extends bindings.Struct {
   static const List<bindings.StructDataHeader> kVersions = const [
     const bindings.StructDataHeader(16, 0)
   ];
-  Object gles2Client = null;
+  Object track = null;
 
-  GpuCreateOffscreenGleS2ContextParams() : super(kVersions.last.size);
+  AudioServerCreateTrackParams() : super(kVersions.last.size);
 
-  static GpuCreateOffscreenGleS2ContextParams deserialize(bindings.Message message) {
+  static AudioServerCreateTrackParams 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 GpuCreateOffscreenGleS2ContextParams decode(bindings.Decoder decoder0) {
+  static AudioServerCreateTrackParams decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
-    GpuCreateOffscreenGleS2ContextParams result = new GpuCreateOffscreenGleS2ContextParams();
+    AudioServerCreateTrackParams result = new AudioServerCreateTrackParams();
 
     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.gles2Client = decoder0.decodeInterfaceRequest(8, false, command_buffer_mojom.CommandBufferStub.newFromEndpoint);
+      result.track = decoder0.decodeInterfaceRequest(8, false, audio_track_mojom.AudioTrackStub.newFromEndpoint);
     }
     return result;
   }
 
   void encode(bindings.Encoder encoder) {
     var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
     
-    encoder0.encodeInterfaceRequest(gles2Client, 8, false);
+    encoder0.encodeInterfaceRequest(track, 8, false);
   }
 
   String toString() {
-    return "GpuCreateOffscreenGleS2ContextParams("
-           "gles2Client: $gles2Client" ")";
+    return "AudioServerCreateTrackParams("
+           "track: $track" ")";
   }
 
   Map toJson() {
     throw new bindings.MojoCodecError(
         'Object containing handles cannot be encoded to JSON.');
   }
 }
 
-const int kGpu_createOffscreenGleS2Context_name = 0;
-const String GpuName = "mojo::Gpu";
+const int kAudioServer_createTrack_name = 0;
+const String AudioServerName = "mojo::media::AudioServer";
 
-abstract class Gpu {
-  void createOffscreenGleS2Context(Object gles2Client);
+abstract class AudioServer {
+  void createTrack(Object track);
 
 }
 
 
-class GpuProxyImpl extends bindings.Proxy {
-  GpuProxyImpl.fromEndpoint(
+class AudioServerProxyImpl extends bindings.Proxy {
+  AudioServerProxyImpl.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
 
-  GpuProxyImpl.fromHandle(core.MojoHandle handle) :
+  AudioServerProxyImpl.fromHandle(core.MojoHandle handle) :
       super.fromHandle(handle);
 
-  GpuProxyImpl.unbound() : super.unbound();
+  AudioServerProxyImpl.unbound() : super.unbound();
 
-  static GpuProxyImpl newFromEndpoint(
+  static AudioServerProxyImpl newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For GpuProxyImpl"));
-    return new GpuProxyImpl.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For AudioServerProxyImpl"));
+    return new AudioServerProxyImpl.fromEndpoint(endpoint);
   }
 
-  String get name => GpuName;
+  String get name => AudioServerName;
 
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       default:
         proxyError("Unexpected message type: ${message.header.type}");
         close(immediate: true);
         break;
     }
   }
 
   String toString() {
     var superString = super.toString();
-    return "GpuProxyImpl($superString)";
+    return "AudioServerProxyImpl($superString)";
   }
 }
 
 
-class _GpuProxyCalls implements Gpu {
-  GpuProxyImpl _proxyImpl;
+class _AudioServerProxyCalls implements AudioServer {
+  AudioServerProxyImpl _proxyImpl;
 
-  _GpuProxyCalls(this._proxyImpl);
-    void createOffscreenGleS2Context(Object gles2Client) {
+  _AudioServerProxyCalls(this._proxyImpl);
+    void createTrack(Object track) {
       if (!_proxyImpl.isBound) {
         _proxyImpl.proxyError("The Proxy is closed.");
         return;
       }
-      var params = new GpuCreateOffscreenGleS2ContextParams();
-      params.gles2Client = gles2Client;
-      _proxyImpl.sendMessage(params, kGpu_createOffscreenGleS2Context_name);
+      var params = new AudioServerCreateTrackParams();
+      params.track = track;
+      _proxyImpl.sendMessage(params, kAudioServer_createTrack_name);
     }
   
 }
 
 
-class GpuProxy implements bindings.ProxyBase {
+class AudioServerProxy implements bindings.ProxyBase {
   final bindings.Proxy impl;
-  Gpu ptr;
-  final String name = GpuName;
+  AudioServer ptr;
+  final String name = AudioServerName;
 
-  GpuProxy(GpuProxyImpl proxyImpl) :
+  AudioServerProxy(AudioServerProxyImpl proxyImpl) :
       impl = proxyImpl,
-      ptr = new _GpuProxyCalls(proxyImpl);
+      ptr = new _AudioServerProxyCalls(proxyImpl);
 
-  GpuProxy.fromEndpoint(
+  AudioServerProxy.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) :
-      impl = new GpuProxyImpl.fromEndpoint(endpoint) {
-    ptr = new _GpuProxyCalls(impl);
+      impl = new AudioServerProxyImpl.fromEndpoint(endpoint) {
+    ptr = new _AudioServerProxyCalls(impl);
   }
 
-  GpuProxy.fromHandle(core.MojoHandle handle) :
-      impl = new GpuProxyImpl.fromHandle(handle) {
-    ptr = new _GpuProxyCalls(impl);
+  AudioServerProxy.fromHandle(core.MojoHandle handle) :
+      impl = new AudioServerProxyImpl.fromHandle(handle) {
+    ptr = new _AudioServerProxyCalls(impl);
   }
 
-  GpuProxy.unbound() :
-      impl = new GpuProxyImpl.unbound() {
-    ptr = new _GpuProxyCalls(impl);
+  AudioServerProxy.unbound() :
+      impl = new AudioServerProxyImpl.unbound() {
+    ptr = new _AudioServerProxyCalls(impl);
   }
 
-  factory GpuProxy.connectToService(
-      bindings.ServiceConnector s, String url, [String serviceName]) {
-    GpuProxy p = new GpuProxy.unbound();
-    s.connectToService(url, p, serviceName);
+  factory AudioServerProxy.connectToService(
+      bindings.ServiceConnector s, String url) {
+    AudioServerProxy p = new AudioServerProxy.unbound();
+    s.connectToService(url, p);
     return p;
   }
 
-  static GpuProxy newFromEndpoint(
+  static AudioServerProxy newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For GpuProxy"));
-    return new GpuProxy.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For AudioServerProxy"));
+    return new AudioServerProxy.fromEndpoint(endpoint);
   }
 
   Future close({bool immediate: false}) => impl.close(immediate: immediate);
 
   Future responseOrError(Future f) => impl.responseOrError(f);
 
   Future get errorFuture => impl.errorFuture;
 
   int get version => impl.version;
 
   Future<int> queryVersion() => impl.queryVersion();
 
   void requireVersion(int requiredVersion) {
     impl.requireVersion(requiredVersion);
   }
 
   String toString() {
-    return "GpuProxy($impl)";
+    return "AudioServerProxy($impl)";
   }
 }
 
 
-class GpuStub extends bindings.Stub {
-  Gpu _impl = null;
+class AudioServerStub extends bindings.Stub {
+  AudioServer _impl = null;
 
-  GpuStub.fromEndpoint(
+  AudioServerStub.fromEndpoint(
       core.MojoMessagePipeEndpoint endpoint, [this._impl])
       : super.fromEndpoint(endpoint);
 
-  GpuStub.fromHandle(core.MojoHandle handle, [this._impl])
+  AudioServerStub.fromHandle(core.MojoHandle handle, [this._impl])
       : super.fromHandle(handle);
 
-  GpuStub.unbound() : super.unbound();
+  AudioServerStub.unbound() : super.unbound();
 
-  static GpuStub newFromEndpoint(
+  static AudioServerStub newFromEndpoint(
       core.MojoMessagePipeEndpoint endpoint) {
-    assert(endpoint.setDescription("For GpuStub"));
-    return new GpuStub.fromEndpoint(endpoint);
+    assert(endpoint.setDescription("For AudioServerStub"));
+    return new AudioServerStub.fromEndpoint(endpoint);
   }
 
-  static const String name = GpuName;
+  static const String name = AudioServerName;
 
 
 
   dynamic handleMessage(bindings.ServiceMessage message) {
     if (bindings.ControlMessageHandler.isControlMessage(message)) {
       return bindings.ControlMessageHandler.handleMessage(this,
                                                           0,
                                                           message);
     }
     assert(_impl != null);
     switch (message.header.type) {
-      case kGpu_createOffscreenGleS2Context_name:
-        var params = GpuCreateOffscreenGleS2ContextParams.deserialize(
+      case kAudioServer_createTrack_name:
+        var params = AudioServerCreateTrackParams.deserialize(
             message.payload);
-        _impl.createOffscreenGleS2Context(params.gles2Client);
+        _impl.createTrack(params.track);
         break;
       default:
         throw new bindings.MojoCodecError("Unexpected message name");
         break;
     }
     return null;
   }
 
-  Gpu get impl => _impl;
-  set impl(Gpu d) {
+  AudioServer get impl => _impl;
+  set impl(AudioServer d) {
     assert(_impl == null);
     _impl = d;
   }
 
   String toString() {
     var superString = super.toString();
-    return "GpuStub($superString)";
+    return "AudioServerStub($superString)";
   }
 
   int get version => 0;
 }