OLD | NEW |
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 |
OLD | NEW |