Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(699)

Side by Side Diff: mojo/dart/packages/mojo_services/lib/mojo/media/audio_track.mojom.dart

Issue 1509323002: Mojom updates for Motown. (Closed) Base URL: https://github.com/domokit/mojo.git@master
Patch Set: sync with master Created 5 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 library terminal_mojom; 5 library audio_track_mojom;
6 6
7 import 'dart:async'; 7 import 'dart:async';
8 8
9 import 'package:mojo/bindings.dart' as bindings; 9 import 'package:mojo/bindings.dart' as bindings;
10 import 'package:mojo/core.dart' as core; 10 import 'package:mojo/core.dart' as core;
11 import 'package:mojo_services/mojo/files/file.mojom.dart' as file_mojom; 11 import 'package:mojo_services/mojo/media/media_common.mojom.dart' as media_commo n_mojom;
12 import 'package:mojo_services/mojo/files/types.mojom.dart' as types_mojom; 12 import 'package:mojo_services/mojo/media/media_pipe.mojom.dart' as media_pipe_mo jom;
13 import 'package:mojo_services/mojo/terminal/terminal_client.mojom.dart' as termi nal_client_mojom; 13 import 'package:mojo_services/mojo/media/media_types.mojom.dart' as media_types_ mojom;
14 import 'package:mojo_services/mojo/media/rate_control.mojom.dart' as rate_contro l_mojom;
14 15
15 16
16 17
17 class TerminalConnectParams extends bindings.Struct { 18 class AudioTrackDescriptor extends bindings.Struct {
18 static const List<bindings.StructDataHeader> kVersions = const [ 19 static const List<bindings.StructDataHeader> kVersions = const [
19 const bindings.StructDataHeader(16, 0) 20 const bindings.StructDataHeader(16, 0)
20 ]; 21 ];
21 Object terminalFile = null; 22 List<media_types_mojom.MediaTypeSet> supportedMediaTypes = null;
22 bool force = false;
23 23
24 TerminalConnectParams() : super(kVersions.last.size); 24 AudioTrackDescriptor() : super(kVersions.last.size);
25 25
26 static TerminalConnectParams deserialize(bindings.Message message) { 26 static AudioTrackDescriptor deserialize(bindings.Message message) {
27 var decoder = new bindings.Decoder(message); 27 var decoder = new bindings.Decoder(message);
28 var result = decode(decoder); 28 var result = decode(decoder);
29 if (decoder.excessHandles != null) { 29 if (decoder.excessHandles != null) {
30 decoder.excessHandles.forEach((h) => h.close()); 30 decoder.excessHandles.forEach((h) => h.close());
31 } 31 }
32 return result; 32 return result;
33 } 33 }
34 34
35 static TerminalConnectParams decode(bindings.Decoder decoder0) { 35 static AudioTrackDescriptor decode(bindings.Decoder decoder0) {
36 if (decoder0 == null) { 36 if (decoder0 == null) {
37 return null; 37 return null;
38 } 38 }
39 TerminalConnectParams result = new TerminalConnectParams(); 39 AudioTrackDescriptor result = new AudioTrackDescriptor();
40 40
41 var mainDataHeader = decoder0.decodeStructDataHeader(); 41 var mainDataHeader = decoder0.decodeStructDataHeader();
42 if (mainDataHeader.version <= kVersions.last.version) { 42 if (mainDataHeader.version <= kVersions.last.version) {
43 // Scan in reverse order to optimize for more recent versions. 43 // Scan in reverse order to optimize for more recent versions.
44 for (int i = kVersions.length - 1; i >= 0; --i) { 44 for (int i = kVersions.length - 1; i >= 0; --i) {
45 if (mainDataHeader.version >= kVersions[i].version) { 45 if (mainDataHeader.version >= kVersions[i].version) {
46 if (mainDataHeader.size == kVersions[i].size) { 46 if (mainDataHeader.size == kVersions[i].size) {
47 // Found a match. 47 // Found a match.
48 break; 48 break;
49 } 49 }
50 throw new bindings.MojoCodecError( 50 throw new bindings.MojoCodecError(
51 'Header size doesn\'t correspond to known version size.'); 51 'Header size doesn\'t correspond to known version size.');
52 } 52 }
53 } 53 }
54 } else if (mainDataHeader.size < kVersions.last.size) { 54 } else if (mainDataHeader.size < kVersions.last.size) {
55 throw new bindings.MojoCodecError( 55 throw new bindings.MojoCodecError(
56 'Message newer than the last known version cannot be shorter than ' 56 'Message newer than the last known version cannot be shorter than '
57 'required by the last known version.'); 57 'required by the last known version.');
58 } 58 }
59 if (mainDataHeader.version >= 0) { 59 if (mainDataHeader.version >= 0) {
60 60
61 result.terminalFile = decoder0.decodeInterfaceRequest(8, false, file_mojom .FileStub.newFromEndpoint); 61 var decoder1 = decoder0.decodePointer(8, false);
62 } 62 {
63 if (mainDataHeader.version >= 0) { 63 var si1 = decoder1.decodeDataHeaderForPointerArray(bindings.kUnspecified ArrayLength);
64 64 result.supportedMediaTypes = new List<media_types_mojom.MediaTypeSet>(si 1.numElements);
65 result.force = decoder0.decodeBool(12, 0); 65 for (int i1 = 0; i1 < si1.numElements; ++i1) {
66
67 var decoder2 = decoder1.decodePointer(bindings.ArrayDataHeader.kHeader Size + bindings.kPointerSize * i1, false);
68 result.supportedMediaTypes[i1] = media_types_mojom.MediaTypeSet.decode (decoder2);
69 }
70 }
66 } 71 }
67 return result; 72 return result;
68 } 73 }
69 74
70 void encode(bindings.Encoder encoder) { 75 void encode(bindings.Encoder encoder) {
71 var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last); 76 var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
72 77
73 encoder0.encodeInterfaceRequest(terminalFile, 8, false); 78 if (supportedMediaTypes == null) {
74 79 encoder0.encodeNullPointer(8, false);
75 encoder0.encodeBool(force, 12, 0); 80 } else {
81 var encoder1 = encoder0.encodePointerArray(supportedMediaTypes.length, 8, bindings.kUnspecifiedArrayLength);
82 for (int i0 = 0; i0 < supportedMediaTypes.length; ++i0) {
83
84 encoder1.encodeStruct(supportedMediaTypes[i0], bindings.ArrayDataHeader. kHeaderSize + bindings.kPointerSize * i0, false);
85 }
86 }
76 } 87 }
77 88
78 String toString() { 89 String toString() {
79 return "TerminalConnectParams(" 90 return "AudioTrackDescriptor("
80 "terminalFile: $terminalFile" ", " 91 "supportedMediaTypes: $supportedMediaTypes" ")";
81 "force: $force" ")";
82 } 92 }
83 93
84 Map toJson() { 94 Map toJson() {
85 throw new bindings.MojoCodecError( 95 Map map = new Map();
86 'Object containing handles cannot be encoded to JSON.'); 96 map["supportedMediaTypes"] = supportedMediaTypes;
97 return map;
87 } 98 }
88 } 99 }
89 100
90 101
91 class TerminalConnectResponseParams extends bindings.Struct { 102 class AudioTrackConfiguration extends bindings.Struct {
92 static const List<bindings.StructDataHeader> kVersions = const [ 103 static const List<bindings.StructDataHeader> kVersions = const [
93 const bindings.StructDataHeader(16, 0) 104 const bindings.StructDataHeader(32, 0)
94 ]; 105 ];
95 types_mojom.Error error = null; 106 media_types_mojom.MediaType mediaType = null;
107 int maxFrames = 0;
108 int audioFrameRatio = 1;
109 int mediaTimeRatio = 1;
96 110
97 TerminalConnectResponseParams() : super(kVersions.last.size); 111 AudioTrackConfiguration() : super(kVersions.last.size);
98 112
99 static TerminalConnectResponseParams deserialize(bindings.Message message) { 113 static AudioTrackConfiguration deserialize(bindings.Message message) {
100 var decoder = new bindings.Decoder(message); 114 var decoder = new bindings.Decoder(message);
101 var result = decode(decoder); 115 var result = decode(decoder);
102 if (decoder.excessHandles != null) { 116 if (decoder.excessHandles != null) {
103 decoder.excessHandles.forEach((h) => h.close()); 117 decoder.excessHandles.forEach((h) => h.close());
104 } 118 }
105 return result; 119 return result;
106 } 120 }
107 121
108 static TerminalConnectResponseParams decode(bindings.Decoder decoder0) { 122 static AudioTrackConfiguration decode(bindings.Decoder decoder0) {
109 if (decoder0 == null) { 123 if (decoder0 == null) {
110 return null; 124 return null;
111 } 125 }
112 TerminalConnectResponseParams result = new TerminalConnectResponseParams(); 126 AudioTrackConfiguration result = new AudioTrackConfiguration();
113 127
114 var mainDataHeader = decoder0.decodeStructDataHeader(); 128 var mainDataHeader = decoder0.decodeStructDataHeader();
115 if (mainDataHeader.version <= kVersions.last.version) { 129 if (mainDataHeader.version <= kVersions.last.version) {
116 // Scan in reverse order to optimize for more recent versions. 130 // Scan in reverse order to optimize for more recent versions.
117 for (int i = kVersions.length - 1; i >= 0; --i) { 131 for (int i = kVersions.length - 1; i >= 0; --i) {
118 if (mainDataHeader.version >= kVersions[i].version) { 132 if (mainDataHeader.version >= kVersions[i].version) {
119 if (mainDataHeader.size == kVersions[i].size) { 133 if (mainDataHeader.size == kVersions[i].size) {
120 // Found a match. 134 // Found a match.
121 break; 135 break;
122 } 136 }
123 throw new bindings.MojoCodecError( 137 throw new bindings.MojoCodecError(
124 'Header size doesn\'t correspond to known version size.'); 138 'Header size doesn\'t correspond to known version size.');
125 } 139 }
126 } 140 }
127 } else if (mainDataHeader.size < kVersions.last.size) { 141 } else if (mainDataHeader.size < kVersions.last.size) {
128 throw new bindings.MojoCodecError( 142 throw new bindings.MojoCodecError(
129 'Message newer than the last known version cannot be shorter than ' 143 'Message newer than the last known version cannot be shorter than '
130 'required by the last known version.'); 144 'required by the last known version.');
131 } 145 }
132 if (mainDataHeader.version >= 0) { 146 if (mainDataHeader.version >= 0) {
133 147
134 result.error = types_mojom.Error.decode(decoder0, 8); 148 var decoder1 = decoder0.decodePointer(8, false);
135 if (result.error == null) { 149 result.mediaType = media_types_mojom.MediaType.decode(decoder1);
136 throw new bindings.MojoCodecError( 150 }
137 'Trying to decode null union for non-nullable types_mojom.Error.'); 151 if (mainDataHeader.version >= 0) {
138 } 152
153 result.maxFrames = decoder0.decodeUint64(16);
154 }
155 if (mainDataHeader.version >= 0) {
156
157 result.audioFrameRatio = decoder0.decodeUint32(24);
158 }
159 if (mainDataHeader.version >= 0) {
160
161 result.mediaTimeRatio = decoder0.decodeUint32(28);
139 } 162 }
140 return result; 163 return result;
141 } 164 }
142 165
143 void encode(bindings.Encoder encoder) { 166 void encode(bindings.Encoder encoder) {
144 var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last); 167 var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
145 168
146 encoder0.encodeEnum(error, 8); 169 encoder0.encodeStruct(mediaType, 8, false);
170
171 encoder0.encodeUint64(maxFrames, 16);
172
173 encoder0.encodeUint32(audioFrameRatio, 24);
174
175 encoder0.encodeUint32(mediaTimeRatio, 28);
147 } 176 }
148 177
149 String toString() { 178 String toString() {
150 return "TerminalConnectResponseParams(" 179 return "AudioTrackConfiguration("
151 "error: $error" ")"; 180 "mediaType: $mediaType" ", "
181 "maxFrames: $maxFrames" ", "
182 "audioFrameRatio: $audioFrameRatio" ", "
183 "mediaTimeRatio: $mediaTimeRatio" ")";
152 } 184 }
153 185
154 Map toJson() { 186 Map toJson() {
155 Map map = new Map(); 187 Map map = new Map();
156 map["error"] = error; 188 map["mediaType"] = mediaType;
189 map["maxFrames"] = maxFrames;
190 map["audioFrameRatio"] = audioFrameRatio;
191 map["mediaTimeRatio"] = mediaTimeRatio;
157 return map; 192 return map;
158 } 193 }
159 } 194 }
160 195
161 196
162 class TerminalConnectToClientParams extends bindings.Struct { 197 class AudioTrackDescribeParams extends bindings.Struct {
163 static const List<bindings.StructDataHeader> kVersions = const [ 198 static const List<bindings.StructDataHeader> kVersions = const [
164 const bindings.StructDataHeader(24, 0) 199 const bindings.StructDataHeader(8, 0)
165 ]; 200 ];
166 Object terminalClient = null;
167 bool force = false;
168 201
169 TerminalConnectToClientParams() : super(kVersions.last.size); 202 AudioTrackDescribeParams() : super(kVersions.last.size);
170 203
171 static TerminalConnectToClientParams deserialize(bindings.Message message) { 204 static AudioTrackDescribeParams deserialize(bindings.Message message) {
172 var decoder = new bindings.Decoder(message); 205 var decoder = new bindings.Decoder(message);
173 var result = decode(decoder); 206 var result = decode(decoder);
174 if (decoder.excessHandles != null) { 207 if (decoder.excessHandles != null) {
175 decoder.excessHandles.forEach((h) => h.close()); 208 decoder.excessHandles.forEach((h) => h.close());
176 } 209 }
177 return result; 210 return result;
178 } 211 }
179 212
180 static TerminalConnectToClientParams decode(bindings.Decoder decoder0) { 213 static AudioTrackDescribeParams decode(bindings.Decoder decoder0) {
181 if (decoder0 == null) { 214 if (decoder0 == null) {
182 return null; 215 return null;
183 } 216 }
184 TerminalConnectToClientParams result = new TerminalConnectToClientParams(); 217 AudioTrackDescribeParams result = new AudioTrackDescribeParams();
185 218
186 var mainDataHeader = decoder0.decodeStructDataHeader(); 219 var mainDataHeader = decoder0.decodeStructDataHeader();
187 if (mainDataHeader.version <= kVersions.last.version) { 220 if (mainDataHeader.version <= kVersions.last.version) {
188 // Scan in reverse order to optimize for more recent versions. 221 // Scan in reverse order to optimize for more recent versions.
189 for (int i = kVersions.length - 1; i >= 0; --i) { 222 for (int i = kVersions.length - 1; i >= 0; --i) {
190 if (mainDataHeader.version >= kVersions[i].version) { 223 if (mainDataHeader.version >= kVersions[i].version) {
191 if (mainDataHeader.size == kVersions[i].size) { 224 if (mainDataHeader.size == kVersions[i].size) {
192 // Found a match. 225 // Found a match.
193 break; 226 break;
194 } 227 }
195 throw new bindings.MojoCodecError( 228 throw new bindings.MojoCodecError(
196 'Header size doesn\'t correspond to known version size.'); 229 'Header size doesn\'t correspond to known version size.');
197 } 230 }
198 } 231 }
199 } else if (mainDataHeader.size < kVersions.last.size) { 232 } else if (mainDataHeader.size < kVersions.last.size) {
200 throw new bindings.MojoCodecError( 233 throw new bindings.MojoCodecError(
201 'Message newer than the last known version cannot be shorter than ' 234 'Message newer than the last known version cannot be shorter than '
202 'required by the last known version.'); 235 'required by the last known version.');
203 } 236 }
204 if (mainDataHeader.version >= 0) {
205
206 result.terminalClient = decoder0.decodeServiceInterface(8, false, terminal _client_mojom.TerminalClientProxy.newFromEndpoint);
207 }
208 if (mainDataHeader.version >= 0) {
209
210 result.force = decoder0.decodeBool(16, 0);
211 }
212 return result; 237 return result;
213 } 238 }
214 239
215 void encode(bindings.Encoder encoder) { 240 void encode(bindings.Encoder encoder) {
216 var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last); 241 encoder.getStructEncoderAtOffset(kVersions.last);
217
218 encoder0.encodeInterface(terminalClient, 8, false);
219
220 encoder0.encodeBool(force, 16, 0);
221 } 242 }
222 243
223 String toString() { 244 String toString() {
224 return "TerminalConnectToClientParams(" 245 return "AudioTrackDescribeParams("")";
225 "terminalClient: $terminalClient" ", "
226 "force: $force" ")";
227 } 246 }
228 247
229 Map toJson() { 248 Map toJson() {
230 throw new bindings.MojoCodecError( 249 Map map = new Map();
231 'Object containing handles cannot be encoded to JSON.'); 250 return map;
232 } 251 }
233 } 252 }
234 253
235 254
236 class TerminalConnectToClientResponseParams extends bindings.Struct { 255 class AudioTrackDescribeResponseParams extends bindings.Struct {
237 static const List<bindings.StructDataHeader> kVersions = const [ 256 static const List<bindings.StructDataHeader> kVersions = const [
238 const bindings.StructDataHeader(16, 0) 257 const bindings.StructDataHeader(16, 0)
239 ]; 258 ];
240 types_mojom.Error error = null; 259 AudioTrackDescriptor descriptor = null;
241 260
242 TerminalConnectToClientResponseParams() : super(kVersions.last.size); 261 AudioTrackDescribeResponseParams() : super(kVersions.last.size);
243 262
244 static TerminalConnectToClientResponseParams deserialize(bindings.Message mess age) { 263 static AudioTrackDescribeResponseParams deserialize(bindings.Message message) {
245 var decoder = new bindings.Decoder(message); 264 var decoder = new bindings.Decoder(message);
246 var result = decode(decoder); 265 var result = decode(decoder);
247 if (decoder.excessHandles != null) { 266 if (decoder.excessHandles != null) {
248 decoder.excessHandles.forEach((h) => h.close()); 267 decoder.excessHandles.forEach((h) => h.close());
249 } 268 }
250 return result; 269 return result;
251 } 270 }
252 271
253 static TerminalConnectToClientResponseParams decode(bindings.Decoder decoder0) { 272 static AudioTrackDescribeResponseParams decode(bindings.Decoder decoder0) {
254 if (decoder0 == null) { 273 if (decoder0 == null) {
255 return null; 274 return null;
256 } 275 }
257 TerminalConnectToClientResponseParams result = new TerminalConnectToClientRe sponseParams(); 276 AudioTrackDescribeResponseParams result = new AudioTrackDescribeResponsePara ms();
258 277
259 var mainDataHeader = decoder0.decodeStructDataHeader(); 278 var mainDataHeader = decoder0.decodeStructDataHeader();
260 if (mainDataHeader.version <= kVersions.last.version) { 279 if (mainDataHeader.version <= kVersions.last.version) {
261 // Scan in reverse order to optimize for more recent versions. 280 // Scan in reverse order to optimize for more recent versions.
262 for (int i = kVersions.length - 1; i >= 0; --i) { 281 for (int i = kVersions.length - 1; i >= 0; --i) {
263 if (mainDataHeader.version >= kVersions[i].version) { 282 if (mainDataHeader.version >= kVersions[i].version) {
264 if (mainDataHeader.size == kVersions[i].size) { 283 if (mainDataHeader.size == kVersions[i].size) {
265 // Found a match. 284 // Found a match.
266 break; 285 break;
267 } 286 }
268 throw new bindings.MojoCodecError( 287 throw new bindings.MojoCodecError(
269 'Header size doesn\'t correspond to known version size.'); 288 'Header size doesn\'t correspond to known version size.');
270 } 289 }
271 } 290 }
272 } else if (mainDataHeader.size < kVersions.last.size) { 291 } else if (mainDataHeader.size < kVersions.last.size) {
273 throw new bindings.MojoCodecError( 292 throw new bindings.MojoCodecError(
274 'Message newer than the last known version cannot be shorter than ' 293 'Message newer than the last known version cannot be shorter than '
275 'required by the last known version.'); 294 'required by the last known version.');
276 } 295 }
277 if (mainDataHeader.version >= 0) { 296 if (mainDataHeader.version >= 0) {
278 297
279 result.error = types_mojom.Error.decode(decoder0, 8); 298 var decoder1 = decoder0.decodePointer(8, false);
280 if (result.error == null) { 299 result.descriptor = AudioTrackDescriptor.decode(decoder1);
281 throw new bindings.MojoCodecError(
282 'Trying to decode null union for non-nullable types_mojom.Error.');
283 }
284 } 300 }
285 return result; 301 return result;
286 } 302 }
287 303
288 void encode(bindings.Encoder encoder) { 304 void encode(bindings.Encoder encoder) {
289 var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last); 305 var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
290 306
291 encoder0.encodeEnum(error, 8); 307 encoder0.encodeStruct(descriptor, 8, false);
292 } 308 }
293 309
294 String toString() { 310 String toString() {
295 return "TerminalConnectToClientResponseParams(" 311 return "AudioTrackDescribeResponseParams("
296 "error: $error" ")"; 312 "descriptor: $descriptor" ")";
297 } 313 }
298 314
299 Map toJson() { 315 Map toJson() {
300 Map map = new Map(); 316 Map map = new Map();
301 map["error"] = error; 317 map["descriptor"] = descriptor;
302 return map; 318 return map;
303 } 319 }
304 } 320 }
305 321
306 322
307 class TerminalGetSizeParams extends bindings.Struct { 323 class AudioTrackConfigureParams extends bindings.Struct {
308 static const List<bindings.StructDataHeader> kVersions = const [ 324 static const List<bindings.StructDataHeader> kVersions = const [
309 const bindings.StructDataHeader(8, 0) 325 const bindings.StructDataHeader(24, 0)
310 ]; 326 ];
327 AudioTrackConfiguration configuration = null;
328 Object pipe = null;
311 329
312 TerminalGetSizeParams() : super(kVersions.last.size); 330 AudioTrackConfigureParams() : super(kVersions.last.size);
313 331
314 static TerminalGetSizeParams deserialize(bindings.Message message) { 332 static AudioTrackConfigureParams deserialize(bindings.Message message) {
315 var decoder = new bindings.Decoder(message); 333 var decoder = new bindings.Decoder(message);
316 var result = decode(decoder); 334 var result = decode(decoder);
317 if (decoder.excessHandles != null) { 335 if (decoder.excessHandles != null) {
318 decoder.excessHandles.forEach((h) => h.close()); 336 decoder.excessHandles.forEach((h) => h.close());
319 } 337 }
320 return result; 338 return result;
321 } 339 }
322 340
323 static TerminalGetSizeParams decode(bindings.Decoder decoder0) { 341 static AudioTrackConfigureParams decode(bindings.Decoder decoder0) {
324 if (decoder0 == null) { 342 if (decoder0 == null) {
325 return null; 343 return null;
326 } 344 }
327 TerminalGetSizeParams result = new TerminalGetSizeParams(); 345 AudioTrackConfigureParams result = new AudioTrackConfigureParams();
328 346
329 var mainDataHeader = decoder0.decodeStructDataHeader(); 347 var mainDataHeader = decoder0.decodeStructDataHeader();
330 if (mainDataHeader.version <= kVersions.last.version) { 348 if (mainDataHeader.version <= kVersions.last.version) {
331 // Scan in reverse order to optimize for more recent versions. 349 // Scan in reverse order to optimize for more recent versions.
332 for (int i = kVersions.length - 1; i >= 0; --i) { 350 for (int i = kVersions.length - 1; i >= 0; --i) {
333 if (mainDataHeader.version >= kVersions[i].version) { 351 if (mainDataHeader.version >= kVersions[i].version) {
334 if (mainDataHeader.size == kVersions[i].size) { 352 if (mainDataHeader.size == kVersions[i].size) {
335 // Found a match. 353 // Found a match.
336 break; 354 break;
337 } 355 }
338 throw new bindings.MojoCodecError( 356 throw new bindings.MojoCodecError(
339 'Header size doesn\'t correspond to known version size.'); 357 'Header size doesn\'t correspond to known version size.');
340 } 358 }
341 } 359 }
342 } else if (mainDataHeader.size < kVersions.last.size) { 360 } else if (mainDataHeader.size < kVersions.last.size) {
343 throw new bindings.MojoCodecError( 361 throw new bindings.MojoCodecError(
344 'Message newer than the last known version cannot be shorter than ' 362 'Message newer than the last known version cannot be shorter than '
345 'required by the last known version.'); 363 'required by the last known version.');
346 } 364 }
365 if (mainDataHeader.version >= 0) {
366
367 var decoder1 = decoder0.decodePointer(8, false);
368 result.configuration = AudioTrackConfiguration.decode(decoder1);
369 }
370 if (mainDataHeader.version >= 0) {
371
372 result.pipe = decoder0.decodeInterfaceRequest(16, false, media_pipe_mojom. MediaPipeStub.newFromEndpoint);
373 }
347 return result; 374 return result;
348 } 375 }
349 376
350 void encode(bindings.Encoder encoder) { 377 void encode(bindings.Encoder encoder) {
351 encoder.getStructEncoderAtOffset(kVersions.last); 378 var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
379
380 encoder0.encodeStruct(configuration, 8, false);
381
382 encoder0.encodeInterfaceRequest(pipe, 16, false);
352 } 383 }
353 384
354 String toString() { 385 String toString() {
355 return "TerminalGetSizeParams("")"; 386 return "AudioTrackConfigureParams("
387 "configuration: $configuration" ", "
388 "pipe: $pipe" ")";
356 } 389 }
357 390
358 Map toJson() { 391 Map toJson() {
359 Map map = new Map(); 392 throw new bindings.MojoCodecError(
360 return map; 393 'Object containing handles cannot be encoded to JSON.');
361 } 394 }
362 } 395 }
363 396
364 397
365 class TerminalGetSizeResponseParams extends bindings.Struct { 398 class AudioTrackConfigureResponseParams extends bindings.Struct {
366 static const List<bindings.StructDataHeader> kVersions = const [ 399 static const List<bindings.StructDataHeader> kVersions = const [
367 const bindings.StructDataHeader(24, 0) 400 const bindings.StructDataHeader(16, 0)
368 ]; 401 ];
369 types_mojom.Error error = null; 402 media_common_mojom.MediaResult result = null;
370 int rows = 0;
371 int columns = 0;
372 403
373 TerminalGetSizeResponseParams() : super(kVersions.last.size); 404 AudioTrackConfigureResponseParams() : super(kVersions.last.size);
374 405
375 static TerminalGetSizeResponseParams deserialize(bindings.Message message) { 406 static AudioTrackConfigureResponseParams deserialize(bindings.Message message) {
376 var decoder = new bindings.Decoder(message); 407 var decoder = new bindings.Decoder(message);
377 var result = decode(decoder); 408 var result = decode(decoder);
378 if (decoder.excessHandles != null) { 409 if (decoder.excessHandles != null) {
379 decoder.excessHandles.forEach((h) => h.close()); 410 decoder.excessHandles.forEach((h) => h.close());
380 } 411 }
381 return result; 412 return result;
382 } 413 }
383 414
384 static TerminalGetSizeResponseParams decode(bindings.Decoder decoder0) { 415 static AudioTrackConfigureResponseParams decode(bindings.Decoder decoder0) {
385 if (decoder0 == null) { 416 if (decoder0 == null) {
386 return null; 417 return null;
387 } 418 }
388 TerminalGetSizeResponseParams result = new TerminalGetSizeResponseParams(); 419 AudioTrackConfigureResponseParams result = new AudioTrackConfigureResponsePa rams();
389 420
390 var mainDataHeader = decoder0.decodeStructDataHeader(); 421 var mainDataHeader = decoder0.decodeStructDataHeader();
391 if (mainDataHeader.version <= kVersions.last.version) { 422 if (mainDataHeader.version <= kVersions.last.version) {
392 // Scan in reverse order to optimize for more recent versions. 423 // Scan in reverse order to optimize for more recent versions.
393 for (int i = kVersions.length - 1; i >= 0; --i) { 424 for (int i = kVersions.length - 1; i >= 0; --i) {
394 if (mainDataHeader.version >= kVersions[i].version) { 425 if (mainDataHeader.version >= kVersions[i].version) {
395 if (mainDataHeader.size == kVersions[i].size) { 426 if (mainDataHeader.size == kVersions[i].size) {
396 // Found a match. 427 // Found a match.
397 break; 428 break;
398 } 429 }
399 throw new bindings.MojoCodecError( 430 throw new bindings.MojoCodecError(
400 'Header size doesn\'t correspond to known version size.'); 431 'Header size doesn\'t correspond to known version size.');
401 } 432 }
402 } 433 }
403 } else if (mainDataHeader.size < kVersions.last.size) { 434 } else if (mainDataHeader.size < kVersions.last.size) {
404 throw new bindings.MojoCodecError( 435 throw new bindings.MojoCodecError(
405 'Message newer than the last known version cannot be shorter than ' 436 'Message newer than the last known version cannot be shorter than '
406 'required by the last known version.'); 437 'required by the last known version.');
407 } 438 }
408 if (mainDataHeader.version >= 0) { 439 if (mainDataHeader.version >= 0) {
409 440
410 result.error = types_mojom.Error.decode(decoder0, 8); 441 result.result = media_common_mojom.MediaResult.decode(decoder0, 8);
411 if (result.error == null) { 442 if (result.result == null) {
412 throw new bindings.MojoCodecError( 443 throw new bindings.MojoCodecError(
413 'Trying to decode null union for non-nullable types_mojom.Error.'); 444 'Trying to decode null union for non-nullable media_common_mojom.Med iaResult.');
414 } 445 }
415 } 446 }
416 if (mainDataHeader.version >= 0) {
417
418 result.rows = decoder0.decodeUint32(12);
419 }
420 if (mainDataHeader.version >= 0) {
421
422 result.columns = decoder0.decodeUint32(16);
423 }
424 return result; 447 return result;
425 } 448 }
426 449
427 void encode(bindings.Encoder encoder) { 450 void encode(bindings.Encoder encoder) {
428 var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last); 451 var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
429 452
430 encoder0.encodeEnum(error, 8); 453 encoder0.encodeEnum(result, 8);
431
432 encoder0.encodeUint32(rows, 12);
433
434 encoder0.encodeUint32(columns, 16);
435 } 454 }
436 455
437 String toString() { 456 String toString() {
438 return "TerminalGetSizeResponseParams(" 457 return "AudioTrackConfigureResponseParams("
439 "error: $error" ", " 458 "result: $result" ")";
440 "rows: $rows" ", "
441 "columns: $columns" ")";
442 } 459 }
443 460
444 Map toJson() { 461 Map toJson() {
445 Map map = new Map(); 462 Map map = new Map();
446 map["error"] = error; 463 map["result"] = result;
447 map["rows"] = rows;
448 map["columns"] = columns;
449 return map; 464 return map;
450 } 465 }
451 } 466 }
452 467
453 468
454 class TerminalSetSizeParams extends bindings.Struct { 469 class AudioTrackGetRateControlParams extends bindings.Struct {
455 static const List<bindings.StructDataHeader> kVersions = const [ 470 static const List<bindings.StructDataHeader> kVersions = const [
456 const bindings.StructDataHeader(24, 0) 471 const bindings.StructDataHeader(16, 0)
457 ]; 472 ];
458 int rows = 0; 473 Object rateControl = null;
459 int columns = 0;
460 bool reset = false;
461 474
462 TerminalSetSizeParams() : super(kVersions.last.size); 475 AudioTrackGetRateControlParams() : super(kVersions.last.size);
463 476
464 static TerminalSetSizeParams deserialize(bindings.Message message) { 477 static AudioTrackGetRateControlParams deserialize(bindings.Message message) {
465 var decoder = new bindings.Decoder(message); 478 var decoder = new bindings.Decoder(message);
466 var result = decode(decoder); 479 var result = decode(decoder);
467 if (decoder.excessHandles != null) { 480 if (decoder.excessHandles != null) {
468 decoder.excessHandles.forEach((h) => h.close()); 481 decoder.excessHandles.forEach((h) => h.close());
469 } 482 }
470 return result; 483 return result;
471 } 484 }
472 485
473 static TerminalSetSizeParams decode(bindings.Decoder decoder0) { 486 static AudioTrackGetRateControlParams decode(bindings.Decoder decoder0) {
474 if (decoder0 == null) { 487 if (decoder0 == null) {
475 return null; 488 return null;
476 } 489 }
477 TerminalSetSizeParams result = new TerminalSetSizeParams(); 490 AudioTrackGetRateControlParams result = new AudioTrackGetRateControlParams() ;
478 491
479 var mainDataHeader = decoder0.decodeStructDataHeader(); 492 var mainDataHeader = decoder0.decodeStructDataHeader();
480 if (mainDataHeader.version <= kVersions.last.version) { 493 if (mainDataHeader.version <= kVersions.last.version) {
481 // Scan in reverse order to optimize for more recent versions. 494 // Scan in reverse order to optimize for more recent versions.
482 for (int i = kVersions.length - 1; i >= 0; --i) { 495 for (int i = kVersions.length - 1; i >= 0; --i) {
483 if (mainDataHeader.version >= kVersions[i].version) { 496 if (mainDataHeader.version >= kVersions[i].version) {
484 if (mainDataHeader.size == kVersions[i].size) { 497 if (mainDataHeader.size == kVersions[i].size) {
485 // Found a match. 498 // Found a match.
486 break; 499 break;
487 } 500 }
488 throw new bindings.MojoCodecError( 501 throw new bindings.MojoCodecError(
489 'Header size doesn\'t correspond to known version size.'); 502 'Header size doesn\'t correspond to known version size.');
490 } 503 }
491 } 504 }
492 } else if (mainDataHeader.size < kVersions.last.size) { 505 } else if (mainDataHeader.size < kVersions.last.size) {
493 throw new bindings.MojoCodecError( 506 throw new bindings.MojoCodecError(
494 'Message newer than the last known version cannot be shorter than ' 507 'Message newer than the last known version cannot be shorter than '
495 'required by the last known version.'); 508 'required by the last known version.');
496 } 509 }
497 if (mainDataHeader.version >= 0) { 510 if (mainDataHeader.version >= 0) {
498 511
499 result.rows = decoder0.decodeUint32(8); 512 result.rateControl = decoder0.decodeInterfaceRequest(8, false, rate_contro l_mojom.RateControlStub.newFromEndpoint);
500 }
501 if (mainDataHeader.version >= 0) {
502
503 result.columns = decoder0.decodeUint32(12);
504 }
505 if (mainDataHeader.version >= 0) {
506
507 result.reset = decoder0.decodeBool(16, 0);
508 } 513 }
509 return result; 514 return result;
510 } 515 }
511 516
512 void encode(bindings.Encoder encoder) { 517 void encode(bindings.Encoder encoder) {
513 var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last); 518 var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
514 519
515 encoder0.encodeUint32(rows, 8); 520 encoder0.encodeInterfaceRequest(rateControl, 8, false);
516
517 encoder0.encodeUint32(columns, 12);
518
519 encoder0.encodeBool(reset, 16, 0);
520 } 521 }
521 522
522 String toString() { 523 String toString() {
523 return "TerminalSetSizeParams(" 524 return "AudioTrackGetRateControlParams("
524 "rows: $rows" ", " 525 "rateControl: $rateControl" ")";
525 "columns: $columns" ", "
526 "reset: $reset" ")";
527 } 526 }
528 527
529 Map toJson() { 528 Map toJson() {
530 Map map = new Map(); 529 throw new bindings.MojoCodecError(
531 map["rows"] = rows; 530 'Object containing handles cannot be encoded to JSON.');
532 map["columns"] = columns;
533 map["reset"] = reset;
534 return map;
535 } 531 }
536 } 532 }
537 533
538 534
539 class TerminalSetSizeResponseParams extends bindings.Struct { 535 class AudioTrackGetRateControlResponseParams extends bindings.Struct {
540 static const List<bindings.StructDataHeader> kVersions = const [ 536 static const List<bindings.StructDataHeader> kVersions = const [
541 const bindings.StructDataHeader(24, 0) 537 const bindings.StructDataHeader(16, 0)
542 ]; 538 ];
543 types_mojom.Error error = null; 539 media_common_mojom.MediaResult result = null;
544 int rows = 0;
545 int columns = 0;
546 540
547 TerminalSetSizeResponseParams() : super(kVersions.last.size); 541 AudioTrackGetRateControlResponseParams() : super(kVersions.last.size);
548 542
549 static TerminalSetSizeResponseParams deserialize(bindings.Message message) { 543 static AudioTrackGetRateControlResponseParams deserialize(bindings.Message mes sage) {
550 var decoder = new bindings.Decoder(message); 544 var decoder = new bindings.Decoder(message);
551 var result = decode(decoder); 545 var result = decode(decoder);
552 if (decoder.excessHandles != null) { 546 if (decoder.excessHandles != null) {
553 decoder.excessHandles.forEach((h) => h.close()); 547 decoder.excessHandles.forEach((h) => h.close());
554 } 548 }
555 return result; 549 return result;
556 } 550 }
557 551
558 static TerminalSetSizeResponseParams decode(bindings.Decoder decoder0) { 552 static AudioTrackGetRateControlResponseParams decode(bindings.Decoder decoder0 ) {
559 if (decoder0 == null) { 553 if (decoder0 == null) {
560 return null; 554 return null;
561 } 555 }
562 TerminalSetSizeResponseParams result = new TerminalSetSizeResponseParams(); 556 AudioTrackGetRateControlResponseParams result = new AudioTrackGetRateControl ResponseParams();
563 557
564 var mainDataHeader = decoder0.decodeStructDataHeader(); 558 var mainDataHeader = decoder0.decodeStructDataHeader();
565 if (mainDataHeader.version <= kVersions.last.version) { 559 if (mainDataHeader.version <= kVersions.last.version) {
566 // Scan in reverse order to optimize for more recent versions. 560 // Scan in reverse order to optimize for more recent versions.
567 for (int i = kVersions.length - 1; i >= 0; --i) { 561 for (int i = kVersions.length - 1; i >= 0; --i) {
568 if (mainDataHeader.version >= kVersions[i].version) { 562 if (mainDataHeader.version >= kVersions[i].version) {
569 if (mainDataHeader.size == kVersions[i].size) { 563 if (mainDataHeader.size == kVersions[i].size) {
570 // Found a match. 564 // Found a match.
571 break; 565 break;
572 } 566 }
573 throw new bindings.MojoCodecError( 567 throw new bindings.MojoCodecError(
574 'Header size doesn\'t correspond to known version size.'); 568 'Header size doesn\'t correspond to known version size.');
575 } 569 }
576 } 570 }
577 } else if (mainDataHeader.size < kVersions.last.size) { 571 } else if (mainDataHeader.size < kVersions.last.size) {
578 throw new bindings.MojoCodecError( 572 throw new bindings.MojoCodecError(
579 'Message newer than the last known version cannot be shorter than ' 573 'Message newer than the last known version cannot be shorter than '
580 'required by the last known version.'); 574 'required by the last known version.');
581 } 575 }
582 if (mainDataHeader.version >= 0) { 576 if (mainDataHeader.version >= 0) {
583 577
584 result.error = types_mojom.Error.decode(decoder0, 8); 578 result.result = media_common_mojom.MediaResult.decode(decoder0, 8);
585 if (result.error == null) { 579 if (result.result == null) {
586 throw new bindings.MojoCodecError( 580 throw new bindings.MojoCodecError(
587 'Trying to decode null union for non-nullable types_mojom.Error.'); 581 'Trying to decode null union for non-nullable media_common_mojom.Med iaResult.');
588 } 582 }
589 } 583 }
590 if (mainDataHeader.version >= 0) {
591
592 result.rows = decoder0.decodeUint32(12);
593 }
594 if (mainDataHeader.version >= 0) {
595
596 result.columns = decoder0.decodeUint32(16);
597 }
598 return result; 584 return result;
599 } 585 }
600 586
601 void encode(bindings.Encoder encoder) { 587 void encode(bindings.Encoder encoder) {
602 var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last); 588 var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
603 589
604 encoder0.encodeEnum(error, 8); 590 encoder0.encodeEnum(result, 8);
605
606 encoder0.encodeUint32(rows, 12);
607
608 encoder0.encodeUint32(columns, 16);
609 } 591 }
610 592
611 String toString() { 593 String toString() {
612 return "TerminalSetSizeResponseParams(" 594 return "AudioTrackGetRateControlResponseParams("
613 "error: $error" ", " 595 "result: $result" ")";
614 "rows: $rows" ", "
615 "columns: $columns" ")";
616 } 596 }
617 597
618 Map toJson() { 598 Map toJson() {
619 Map map = new Map(); 599 Map map = new Map();
620 map["error"] = error; 600 map["result"] = result;
621 map["rows"] = rows;
622 map["columns"] = columns;
623 return map; 601 return map;
624 } 602 }
625 } 603 }
626 604
627 const int kTerminal_connect_name = 0; 605 const int kAudioTrack_describe_name = 0;
628 const int kTerminal_connectToClient_name = 1; 606 const int kAudioTrack_configure_name = 1;
629 const int kTerminal_getSize_name = 2; 607 const int kAudioTrack_getRateControl_name = 2;
630 const int kTerminal_setSize_name = 3; 608 const String AudioTrackName = null;
631 const String TerminalName = "mojo::terminal::Terminal";
632 609
633 abstract class Terminal { 610 abstract class AudioTrack {
634 dynamic connect(Object terminalFile,bool force,[Function responseFactory = nul l]); 611 dynamic describe([Function responseFactory = null]);
635 dynamic connectToClient(Object terminalClient,bool force,[Function responseFac tory = null]); 612 dynamic configure(AudioTrackConfiguration configuration,Object pipe,[Function responseFactory = null]);
636 dynamic getSize([Function responseFactory = null]); 613 dynamic getRateControl(Object rateControl,[Function responseFactory = null]);
637 dynamic setSize(int rows,int columns,bool reset,[Function responseFactory = nu ll]);
638 614
639 } 615 }
640 616
641 617
642 class TerminalProxyImpl extends bindings.Proxy { 618 class AudioTrackProxyImpl extends bindings.Proxy {
643 TerminalProxyImpl.fromEndpoint( 619 AudioTrackProxyImpl.fromEndpoint(
644 core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint); 620 core.MojoMessagePipeEndpoint endpoint) : super.fromEndpoint(endpoint);
645 621
646 TerminalProxyImpl.fromHandle(core.MojoHandle handle) : 622 AudioTrackProxyImpl.fromHandle(core.MojoHandle handle) :
647 super.fromHandle(handle); 623 super.fromHandle(handle);
648 624
649 TerminalProxyImpl.unbound() : super.unbound(); 625 AudioTrackProxyImpl.unbound() : super.unbound();
650 626
651 static TerminalProxyImpl newFromEndpoint( 627 static AudioTrackProxyImpl newFromEndpoint(
652 core.MojoMessagePipeEndpoint endpoint) { 628 core.MojoMessagePipeEndpoint endpoint) {
653 assert(endpoint.setDescription("For TerminalProxyImpl")); 629 assert(endpoint.setDescription("For AudioTrackProxyImpl"));
654 return new TerminalProxyImpl.fromEndpoint(endpoint); 630 return new AudioTrackProxyImpl.fromEndpoint(endpoint);
655 } 631 }
656 632
657 String get name => TerminalName; 633 String get name => AudioTrackName;
658 634
659 void handleResponse(bindings.ServiceMessage message) { 635 void handleResponse(bindings.ServiceMessage message) {
660 switch (message.header.type) { 636 switch (message.header.type) {
661 case kTerminal_connect_name: 637 case kAudioTrack_describe_name:
662 var r = TerminalConnectResponseParams.deserialize( 638 var r = AudioTrackDescribeResponseParams.deserialize(
663 message.payload); 639 message.payload);
664 if (!message.header.hasRequestId) { 640 if (!message.header.hasRequestId) {
665 proxyError("Expected a message with a valid request Id."); 641 proxyError("Expected a message with a valid request Id.");
666 return;
667 }
668 Completer c = completerMap[message.header.requestId];
669 if (c == null) {
670 proxyError(
671 "Message had unknown request Id: ${message.header.requestId}");
672 return;
673 }
674 completerMap.remove(message.header.requestId);
675 if (c.isCompleted) {
676 proxyError("Response completer already completed");
677 return;
678 }
679 c.complete(r);
680 break;
681 case kTerminal_connectToClient_name:
682 var r = TerminalConnectToClientResponseParams.deserialize(
683 message.payload);
684 if (!message.header.hasRequestId) {
685 proxyError("Expected a message with a valid request Id.");
686 return; 642 return;
687 } 643 }
688 Completer c = completerMap[message.header.requestId]; 644 Completer c = completerMap[message.header.requestId];
689 if (c == null) { 645 if (c == null) {
690 proxyError( 646 proxyError(
691 "Message had unknown request Id: ${message.header.requestId}"); 647 "Message had unknown request Id: ${message.header.requestId}");
692 return; 648 return;
693 } 649 }
694 completerMap.remove(message.header.requestId); 650 completerMap.remove(message.header.requestId);
695 if (c.isCompleted) { 651 if (c.isCompleted) {
696 proxyError("Response completer already completed"); 652 proxyError("Response completer already completed");
697 return; 653 return;
698 } 654 }
699 c.complete(r); 655 c.complete(r);
700 break; 656 break;
701 case kTerminal_getSize_name: 657 case kAudioTrack_configure_name:
702 var r = TerminalGetSizeResponseParams.deserialize( 658 var r = AudioTrackConfigureResponseParams.deserialize(
703 message.payload); 659 message.payload);
704 if (!message.header.hasRequestId) { 660 if (!message.header.hasRequestId) {
705 proxyError("Expected a message with a valid request Id."); 661 proxyError("Expected a message with a valid request Id.");
706 return; 662 return;
707 } 663 }
708 Completer c = completerMap[message.header.requestId]; 664 Completer c = completerMap[message.header.requestId];
709 if (c == null) { 665 if (c == null) {
710 proxyError( 666 proxyError(
711 "Message had unknown request Id: ${message.header.requestId}"); 667 "Message had unknown request Id: ${message.header.requestId}");
712 return; 668 return;
713 } 669 }
714 completerMap.remove(message.header.requestId); 670 completerMap.remove(message.header.requestId);
715 if (c.isCompleted) { 671 if (c.isCompleted) {
716 proxyError("Response completer already completed"); 672 proxyError("Response completer already completed");
717 return; 673 return;
718 } 674 }
719 c.complete(r); 675 c.complete(r);
720 break; 676 break;
721 case kTerminal_setSize_name: 677 case kAudioTrack_getRateControl_name:
722 var r = TerminalSetSizeResponseParams.deserialize( 678 var r = AudioTrackGetRateControlResponseParams.deserialize(
723 message.payload); 679 message.payload);
724 if (!message.header.hasRequestId) { 680 if (!message.header.hasRequestId) {
725 proxyError("Expected a message with a valid request Id."); 681 proxyError("Expected a message with a valid request Id.");
726 return; 682 return;
727 } 683 }
728 Completer c = completerMap[message.header.requestId]; 684 Completer c = completerMap[message.header.requestId];
729 if (c == null) { 685 if (c == null) {
730 proxyError( 686 proxyError(
731 "Message had unknown request Id: ${message.header.requestId}"); 687 "Message had unknown request Id: ${message.header.requestId}");
732 return; 688 return;
733 } 689 }
734 completerMap.remove(message.header.requestId); 690 completerMap.remove(message.header.requestId);
735 if (c.isCompleted) { 691 if (c.isCompleted) {
736 proxyError("Response completer already completed"); 692 proxyError("Response completer already completed");
737 return; 693 return;
738 } 694 }
739 c.complete(r); 695 c.complete(r);
740 break; 696 break;
741 default: 697 default:
742 proxyError("Unexpected message type: ${message.header.type}"); 698 proxyError("Unexpected message type: ${message.header.type}");
743 close(immediate: true); 699 close(immediate: true);
744 break; 700 break;
745 } 701 }
746 } 702 }
747 703
748 String toString() { 704 String toString() {
749 var superString = super.toString(); 705 var superString = super.toString();
750 return "TerminalProxyImpl($superString)"; 706 return "AudioTrackProxyImpl($superString)";
751 } 707 }
752 } 708 }
753 709
754 710
755 class _TerminalProxyCalls implements Terminal { 711 class _AudioTrackProxyCalls implements AudioTrack {
756 TerminalProxyImpl _proxyImpl; 712 AudioTrackProxyImpl _proxyImpl;
757 713
758 _TerminalProxyCalls(this._proxyImpl); 714 _AudioTrackProxyCalls(this._proxyImpl);
759 dynamic connect(Object terminalFile,bool force,[Function responseFactory = n ull]) { 715 dynamic describe([Function responseFactory = null]) {
760 var params = new TerminalConnectParams(); 716 var params = new AudioTrackDescribeParams();
761 params.terminalFile = terminalFile;
762 params.force = force;
763 return _proxyImpl.sendMessageWithRequestId( 717 return _proxyImpl.sendMessageWithRequestId(
764 params, 718 params,
765 kTerminal_connect_name, 719 kAudioTrack_describe_name,
766 -1, 720 -1,
767 bindings.MessageHeader.kMessageExpectsResponse); 721 bindings.MessageHeader.kMessageExpectsResponse);
768 } 722 }
769 dynamic connectToClient(Object terminalClient,bool force,[Function responseF actory = null]) { 723 dynamic configure(AudioTrackConfiguration configuration,Object pipe,[Functio n responseFactory = null]) {
770 var params = new TerminalConnectToClientParams(); 724 var params = new AudioTrackConfigureParams();
771 params.terminalClient = terminalClient; 725 params.configuration = configuration;
772 params.force = force; 726 params.pipe = pipe;
773 return _proxyImpl.sendMessageWithRequestId( 727 return _proxyImpl.sendMessageWithRequestId(
774 params, 728 params,
775 kTerminal_connectToClient_name, 729 kAudioTrack_configure_name,
776 -1, 730 -1,
777 bindings.MessageHeader.kMessageExpectsResponse); 731 bindings.MessageHeader.kMessageExpectsResponse);
778 } 732 }
779 dynamic getSize([Function responseFactory = null]) { 733 dynamic getRateControl(Object rateControl,[Function responseFactory = null]) {
780 var params = new TerminalGetSizeParams(); 734 var params = new AudioTrackGetRateControlParams();
735 params.rateControl = rateControl;
781 return _proxyImpl.sendMessageWithRequestId( 736 return _proxyImpl.sendMessageWithRequestId(
782 params, 737 params,
783 kTerminal_getSize_name, 738 kAudioTrack_getRateControl_name,
784 -1,
785 bindings.MessageHeader.kMessageExpectsResponse);
786 }
787 dynamic setSize(int rows,int columns,bool reset,[Function responseFactory = null]) {
788 var params = new TerminalSetSizeParams();
789 params.rows = rows;
790 params.columns = columns;
791 params.reset = reset;
792 return _proxyImpl.sendMessageWithRequestId(
793 params,
794 kTerminal_setSize_name,
795 -1, 739 -1,
796 bindings.MessageHeader.kMessageExpectsResponse); 740 bindings.MessageHeader.kMessageExpectsResponse);
797 } 741 }
798 } 742 }
799 743
800 744
801 class TerminalProxy implements bindings.ProxyBase { 745 class AudioTrackProxy implements bindings.ProxyBase {
802 final bindings.Proxy impl; 746 final bindings.Proxy impl;
803 Terminal ptr; 747 AudioTrack ptr;
804 final String name = TerminalName; 748 final String name = AudioTrackName;
805 749
806 TerminalProxy(TerminalProxyImpl proxyImpl) : 750 AudioTrackProxy(AudioTrackProxyImpl proxyImpl) :
807 impl = proxyImpl, 751 impl = proxyImpl,
808 ptr = new _TerminalProxyCalls(proxyImpl); 752 ptr = new _AudioTrackProxyCalls(proxyImpl);
809 753
810 TerminalProxy.fromEndpoint( 754 AudioTrackProxy.fromEndpoint(
811 core.MojoMessagePipeEndpoint endpoint) : 755 core.MojoMessagePipeEndpoint endpoint) :
812 impl = new TerminalProxyImpl.fromEndpoint(endpoint) { 756 impl = new AudioTrackProxyImpl.fromEndpoint(endpoint) {
813 ptr = new _TerminalProxyCalls(impl); 757 ptr = new _AudioTrackProxyCalls(impl);
814 } 758 }
815 759
816 TerminalProxy.fromHandle(core.MojoHandle handle) : 760 AudioTrackProxy.fromHandle(core.MojoHandle handle) :
817 impl = new TerminalProxyImpl.fromHandle(handle) { 761 impl = new AudioTrackProxyImpl.fromHandle(handle) {
818 ptr = new _TerminalProxyCalls(impl); 762 ptr = new _AudioTrackProxyCalls(impl);
819 } 763 }
820 764
821 TerminalProxy.unbound() : 765 AudioTrackProxy.unbound() :
822 impl = new TerminalProxyImpl.unbound() { 766 impl = new AudioTrackProxyImpl.unbound() {
823 ptr = new _TerminalProxyCalls(impl); 767 ptr = new _AudioTrackProxyCalls(impl);
824 } 768 }
825 769
826 factory TerminalProxy.connectToService( 770 factory AudioTrackProxy.connectToService(
827 bindings.ServiceConnector s, String url, [String serviceName]) { 771 bindings.ServiceConnector s, String url) {
828 TerminalProxy p = new TerminalProxy.unbound(); 772 AudioTrackProxy p = new AudioTrackProxy.unbound();
829 s.connectToService(url, p, serviceName); 773 s.connectToService(url, p);
830 return p; 774 return p;
831 } 775 }
832 776
833 static TerminalProxy newFromEndpoint( 777 static AudioTrackProxy newFromEndpoint(
834 core.MojoMessagePipeEndpoint endpoint) { 778 core.MojoMessagePipeEndpoint endpoint) {
835 assert(endpoint.setDescription("For TerminalProxy")); 779 assert(endpoint.setDescription("For AudioTrackProxy"));
836 return new TerminalProxy.fromEndpoint(endpoint); 780 return new AudioTrackProxy.fromEndpoint(endpoint);
837 } 781 }
838 782
839 Future close({bool immediate: false}) => impl.close(immediate: immediate); 783 Future close({bool immediate: false}) => impl.close(immediate: immediate);
840 784
841 Future responseOrError(Future f) => impl.responseOrError(f); 785 Future responseOrError(Future f) => impl.responseOrError(f);
842 786
843 Future get errorFuture => impl.errorFuture; 787 Future get errorFuture => impl.errorFuture;
844 788
845 int get version => impl.version; 789 int get version => impl.version;
846 790
847 Future<int> queryVersion() => impl.queryVersion(); 791 Future<int> queryVersion() => impl.queryVersion();
848 792
849 void requireVersion(int requiredVersion) { 793 void requireVersion(int requiredVersion) {
850 impl.requireVersion(requiredVersion); 794 impl.requireVersion(requiredVersion);
851 } 795 }
852 796
853 String toString() { 797 String toString() {
854 return "TerminalProxy($impl)"; 798 return "AudioTrackProxy($impl)";
855 } 799 }
856 } 800 }
857 801
858 802
859 class TerminalStub extends bindings.Stub { 803 class AudioTrackStub extends bindings.Stub {
860 Terminal _impl = null; 804 AudioTrack _impl = null;
861 805
862 TerminalStub.fromEndpoint( 806 AudioTrackStub.fromEndpoint(
863 core.MojoMessagePipeEndpoint endpoint, [this._impl]) 807 core.MojoMessagePipeEndpoint endpoint, [this._impl])
864 : super.fromEndpoint(endpoint); 808 : super.fromEndpoint(endpoint);
865 809
866 TerminalStub.fromHandle(core.MojoHandle handle, [this._impl]) 810 AudioTrackStub.fromHandle(core.MojoHandle handle, [this._impl])
867 : super.fromHandle(handle); 811 : super.fromHandle(handle);
868 812
869 TerminalStub.unbound() : super.unbound(); 813 AudioTrackStub.unbound() : super.unbound();
870 814
871 static TerminalStub newFromEndpoint( 815 static AudioTrackStub newFromEndpoint(
872 core.MojoMessagePipeEndpoint endpoint) { 816 core.MojoMessagePipeEndpoint endpoint) {
873 assert(endpoint.setDescription("For TerminalStub")); 817 assert(endpoint.setDescription("For AudioTrackStub"));
874 return new TerminalStub.fromEndpoint(endpoint); 818 return new AudioTrackStub.fromEndpoint(endpoint);
875 } 819 }
876 820
877 static const String name = TerminalName; 821 static const String name = AudioTrackName;
878 822
879 823
880 TerminalConnectResponseParams _TerminalConnectResponseParamsFactory(types_mojo m.Error error) { 824 AudioTrackDescribeResponseParams _AudioTrackDescribeResponseParamsFactory(Audi oTrackDescriptor descriptor) {
881 var mojo_factory_result = new TerminalConnectResponseParams(); 825 var mojo_factory_result = new AudioTrackDescribeResponseParams();
882 mojo_factory_result.error = error; 826 mojo_factory_result.descriptor = descriptor;
883 return mojo_factory_result; 827 return mojo_factory_result;
884 } 828 }
885 TerminalConnectToClientResponseParams _TerminalConnectToClientResponseParamsFa ctory(types_mojom.Error error) { 829 AudioTrackConfigureResponseParams _AudioTrackConfigureResponseParamsFactory(me dia_common_mojom.MediaResult result) {
886 var mojo_factory_result = new TerminalConnectToClientResponseParams(); 830 var mojo_factory_result = new AudioTrackConfigureResponseParams();
887 mojo_factory_result.error = error; 831 mojo_factory_result.result = result;
888 return mojo_factory_result; 832 return mojo_factory_result;
889 } 833 }
890 TerminalGetSizeResponseParams _TerminalGetSizeResponseParamsFactory(types_mojo m.Error error, int rows, int columns) { 834 AudioTrackGetRateControlResponseParams _AudioTrackGetRateControlResponseParams Factory(media_common_mojom.MediaResult result) {
891 var mojo_factory_result = new TerminalGetSizeResponseParams(); 835 var mojo_factory_result = new AudioTrackGetRateControlResponseParams();
892 mojo_factory_result.error = error; 836 mojo_factory_result.result = result;
893 mojo_factory_result.rows = rows;
894 mojo_factory_result.columns = columns;
895 return mojo_factory_result;
896 }
897 TerminalSetSizeResponseParams _TerminalSetSizeResponseParamsFactory(types_mojo m.Error error, int rows, int columns) {
898 var mojo_factory_result = new TerminalSetSizeResponseParams();
899 mojo_factory_result.error = error;
900 mojo_factory_result.rows = rows;
901 mojo_factory_result.columns = columns;
902 return mojo_factory_result; 837 return mojo_factory_result;
903 } 838 }
904 839
905 dynamic handleMessage(bindings.ServiceMessage message) { 840 dynamic handleMessage(bindings.ServiceMessage message) {
906 if (bindings.ControlMessageHandler.isControlMessage(message)) { 841 if (bindings.ControlMessageHandler.isControlMessage(message)) {
907 return bindings.ControlMessageHandler.handleMessage(this, 842 return bindings.ControlMessageHandler.handleMessage(this,
908 0, 843 0,
909 message); 844 message);
910 } 845 }
911 assert(_impl != null); 846 assert(_impl != null);
912 switch (message.header.type) { 847 switch (message.header.type) {
913 case kTerminal_connect_name: 848 case kAudioTrack_describe_name:
914 var params = TerminalConnectParams.deserialize( 849 var params = AudioTrackDescribeParams.deserialize(
915 message.payload); 850 message.payload);
916 var response = _impl.connect(params.terminalFile,params.force,_TerminalC onnectResponseParamsFactory); 851 var response = _impl.describe(_AudioTrackDescribeResponseParamsFactory);
917 if (response is Future) { 852 if (response is Future) {
918 return response.then((response) { 853 return response.then((response) {
919 if (response != null) { 854 if (response != null) {
920 return buildResponseWithId( 855 return buildResponseWithId(
921 response, 856 response,
922 kTerminal_connect_name, 857 kAudioTrack_describe_name,
923 message.header.requestId, 858 message.header.requestId,
924 bindings.MessageHeader.kMessageIsResponse); 859 bindings.MessageHeader.kMessageIsResponse);
925 } 860 }
926 });
927 } else if (response != null) {
928 return buildResponseWithId(
929 response,
930 kTerminal_connect_name,
931 message.header.requestId,
932 bindings.MessageHeader.kMessageIsResponse);
933 }
934 break;
935 case kTerminal_connectToClient_name:
936 var params = TerminalConnectToClientParams.deserialize(
937 message.payload);
938 var response = _impl.connectToClient(params.terminalClient,params.force, _TerminalConnectToClientResponseParamsFactory);
939 if (response is Future) {
940 return response.then((response) {
941 if (response != null) {
942 return buildResponseWithId(
943 response,
944 kTerminal_connectToClient_name,
945 message.header.requestId,
946 bindings.MessageHeader.kMessageIsResponse);
947 }
948 }); 861 });
949 } else if (response != null) { 862 } else if (response != null) {
950 return buildResponseWithId( 863 return buildResponseWithId(
951 response, 864 response,
952 kTerminal_connectToClient_name, 865 kAudioTrack_describe_name,
953 message.header.requestId, 866 message.header.requestId,
954 bindings.MessageHeader.kMessageIsResponse); 867 bindings.MessageHeader.kMessageIsResponse);
955 } 868 }
956 break; 869 break;
957 case kTerminal_getSize_name: 870 case kAudioTrack_configure_name:
958 var params = TerminalGetSizeParams.deserialize( 871 var params = AudioTrackConfigureParams.deserialize(
959 message.payload); 872 message.payload);
960 var response = _impl.getSize(_TerminalGetSizeResponseParamsFactory); 873 var response = _impl.configure(params.configuration,params.pipe,_AudioTr ackConfigureResponseParamsFactory);
961 if (response is Future) { 874 if (response is Future) {
962 return response.then((response) { 875 return response.then((response) {
963 if (response != null) { 876 if (response != null) {
964 return buildResponseWithId( 877 return buildResponseWithId(
965 response, 878 response,
966 kTerminal_getSize_name, 879 kAudioTrack_configure_name,
967 message.header.requestId, 880 message.header.requestId,
968 bindings.MessageHeader.kMessageIsResponse); 881 bindings.MessageHeader.kMessageIsResponse);
969 } 882 }
970 }); 883 });
971 } else if (response != null) { 884 } else if (response != null) {
972 return buildResponseWithId( 885 return buildResponseWithId(
973 response, 886 response,
974 kTerminal_getSize_name, 887 kAudioTrack_configure_name,
975 message.header.requestId, 888 message.header.requestId,
976 bindings.MessageHeader.kMessageIsResponse); 889 bindings.MessageHeader.kMessageIsResponse);
977 } 890 }
978 break; 891 break;
979 case kTerminal_setSize_name: 892 case kAudioTrack_getRateControl_name:
980 var params = TerminalSetSizeParams.deserialize( 893 var params = AudioTrackGetRateControlParams.deserialize(
981 message.payload); 894 message.payload);
982 var response = _impl.setSize(params.rows,params.columns,params.reset,_Te rminalSetSizeResponseParamsFactory); 895 var response = _impl.getRateControl(params.rateControl,_AudioTrackGetRat eControlResponseParamsFactory);
983 if (response is Future) { 896 if (response is Future) {
984 return response.then((response) { 897 return response.then((response) {
985 if (response != null) { 898 if (response != null) {
986 return buildResponseWithId( 899 return buildResponseWithId(
987 response, 900 response,
988 kTerminal_setSize_name, 901 kAudioTrack_getRateControl_name,
989 message.header.requestId, 902 message.header.requestId,
990 bindings.MessageHeader.kMessageIsResponse); 903 bindings.MessageHeader.kMessageIsResponse);
991 } 904 }
992 }); 905 });
993 } else if (response != null) { 906 } else if (response != null) {
994 return buildResponseWithId( 907 return buildResponseWithId(
995 response, 908 response,
996 kTerminal_setSize_name, 909 kAudioTrack_getRateControl_name,
997 message.header.requestId, 910 message.header.requestId,
998 bindings.MessageHeader.kMessageIsResponse); 911 bindings.MessageHeader.kMessageIsResponse);
999 } 912 }
1000 break; 913 break;
1001 default: 914 default:
1002 throw new bindings.MojoCodecError("Unexpected message name"); 915 throw new bindings.MojoCodecError("Unexpected message name");
1003 break; 916 break;
1004 } 917 }
1005 return null; 918 return null;
1006 } 919 }
1007 920
1008 Terminal get impl => _impl; 921 AudioTrack get impl => _impl;
1009 set impl(Terminal d) { 922 set impl(AudioTrack d) {
1010 assert(_impl == null); 923 assert(_impl == null);
1011 _impl = d; 924 _impl = d;
1012 } 925 }
1013 926
1014 String toString() { 927 String toString() {
1015 var superString = super.toString(); 928 var superString = super.toString();
1016 return "TerminalStub($superString)"; 929 return "AudioTrackStub($superString)";
1017 } 930 }
1018 931
1019 int get version => 0; 932 int get version => 0;
1020 } 933 }
1021 934
1022 935
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698