OLD | NEW |
(Empty) | |
| 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 |
| 3 // found in the LICENSE file. |
| 4 |
| 5 'use strict'; |
| 6 |
| 7 (function() { |
| 8 var mojomId = 'device/usb/public/interfaces/device_manager.mojom'; |
| 9 if (mojo.internal.isMojomLoaded(mojomId)) { |
| 10 console.warn('The following mojom is loaded multiple times: ' + mojomId); |
| 11 return; |
| 12 } |
| 13 mojo.internal.markMojomLoaded(mojomId); |
| 14 |
| 15 // TODO(yzshen): Define these aliases to minimize the differences between the |
| 16 // old/new modes. Remove them when the old mode goes away. |
| 17 var bindings = mojo; |
| 18 var associatedBindings = mojo; |
| 19 var codec = mojo.internal; |
| 20 var validator = mojo.internal; |
| 21 var device$ = |
| 22 mojo.internal.exposeNamespace('device.mojom'); |
| 23 if (mojo.config.autoLoadMojomDeps) { |
| 24 mojo.internal.loadMojomIfNecessary( |
| 25 'device/usb/public/interfaces/device.mojom', |
| 26 new URL('device.mojom.js', |
| 27 document.currentScript.src).href); |
| 28 } |
| 29 |
| 30 |
| 31 |
| 32 function UsbDeviceFilter(values) { |
| 33 this.initDefaults_(); |
| 34 this.initFields_(values); |
| 35 } |
| 36 |
| 37 |
| 38 UsbDeviceFilter.prototype.initDefaults_ = function() { |
| 39 this.hasVendorId = false; |
| 40 this.hasProductId = false; |
| 41 this.hasClassCode = false; |
| 42 this.hasSubclassCode = false; |
| 43 this.hasProtocolCode = false; |
| 44 this.classCode = 0; |
| 45 this.vendorId = 0; |
| 46 this.productId = 0; |
| 47 this.subclassCode = 0; |
| 48 this.protocolCode = 0; |
| 49 this.serialNumber = null; |
| 50 }; |
| 51 UsbDeviceFilter.prototype.initFields_ = function(fields) { |
| 52 for(var field in fields) { |
| 53 if (this.hasOwnProperty(field)) |
| 54 this[field] = fields[field]; |
| 55 } |
| 56 }; |
| 57 |
| 58 UsbDeviceFilter.validate = function(messageValidator, offset) { |
| 59 var err; |
| 60 err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize)
; |
| 61 if (err !== validator.validationError.NONE) |
| 62 return err; |
| 63 |
| 64 var kVersionSizes = [ |
| 65 {version: 0, numBytes: 24} |
| 66 ]; |
| 67 err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| 68 if (err !== validator.validationError.NONE) |
| 69 return err; |
| 70 |
| 71 |
| 72 |
| 73 |
| 74 |
| 75 |
| 76 |
| 77 |
| 78 |
| 79 |
| 80 |
| 81 |
| 82 |
| 83 // validate UsbDeviceFilter.serialNumber |
| 84 err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSiz
e + 8, true) |
| 85 if (err !== validator.validationError.NONE) |
| 86 return err; |
| 87 |
| 88 return validator.validationError.NONE; |
| 89 }; |
| 90 |
| 91 UsbDeviceFilter.encodedSize = codec.kStructHeaderSize + 16; |
| 92 |
| 93 UsbDeviceFilter.decode = function(decoder) { |
| 94 var packed; |
| 95 var val = new UsbDeviceFilter(); |
| 96 var numberOfBytes = decoder.readUint32(); |
| 97 var version = decoder.readUint32(); |
| 98 packed = decoder.readUint8(); |
| 99 val.hasVendorId = (packed >> 0) & 1 ? true : false; |
| 100 val.hasProductId = (packed >> 1) & 1 ? true : false; |
| 101 val.hasClassCode = (packed >> 2) & 1 ? true : false; |
| 102 val.hasSubclassCode = (packed >> 3) & 1 ? true : false; |
| 103 val.hasProtocolCode = (packed >> 4) & 1 ? true : false; |
| 104 val.classCode = decoder.decodeStruct(codec.Uint8); |
| 105 val.vendorId = decoder.decodeStruct(codec.Uint16); |
| 106 val.productId = decoder.decodeStruct(codec.Uint16); |
| 107 val.subclassCode = decoder.decodeStruct(codec.Uint8); |
| 108 val.protocolCode = decoder.decodeStruct(codec.Uint8); |
| 109 val.serialNumber = decoder.decodeStruct(codec.NullableString); |
| 110 return val; |
| 111 }; |
| 112 |
| 113 UsbDeviceFilter.encode = function(encoder, val) { |
| 114 var packed; |
| 115 encoder.writeUint32(UsbDeviceFilter.encodedSize); |
| 116 encoder.writeUint32(0); |
| 117 packed = 0; |
| 118 packed |= (val.hasVendorId & 1) << 0 |
| 119 packed |= (val.hasProductId & 1) << 1 |
| 120 packed |= (val.hasClassCode & 1) << 2 |
| 121 packed |= (val.hasSubclassCode & 1) << 3 |
| 122 packed |= (val.hasProtocolCode & 1) << 4 |
| 123 encoder.writeUint8(packed); |
| 124 encoder.encodeStruct(codec.Uint8, val.classCode); |
| 125 encoder.encodeStruct(codec.Uint16, val.vendorId); |
| 126 encoder.encodeStruct(codec.Uint16, val.productId); |
| 127 encoder.encodeStruct(codec.Uint8, val.subclassCode); |
| 128 encoder.encodeStruct(codec.Uint8, val.protocolCode); |
| 129 encoder.encodeStruct(codec.NullableString, val.serialNumber); |
| 130 }; |
| 131 function UsbEnumerationOptions(values) { |
| 132 this.initDefaults_(); |
| 133 this.initFields_(values); |
| 134 } |
| 135 |
| 136 |
| 137 UsbEnumerationOptions.prototype.initDefaults_ = function() { |
| 138 this.filters = null; |
| 139 }; |
| 140 UsbEnumerationOptions.prototype.initFields_ = function(fields) { |
| 141 for(var field in fields) { |
| 142 if (this.hasOwnProperty(field)) |
| 143 this[field] = fields[field]; |
| 144 } |
| 145 }; |
| 146 |
| 147 UsbEnumerationOptions.validate = function(messageValidator, offset) { |
| 148 var err; |
| 149 err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize)
; |
| 150 if (err !== validator.validationError.NONE) |
| 151 return err; |
| 152 |
| 153 var kVersionSizes = [ |
| 154 {version: 0, numBytes: 16} |
| 155 ]; |
| 156 err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| 157 if (err !== validator.validationError.NONE) |
| 158 return err; |
| 159 |
| 160 |
| 161 |
| 162 // validate UsbEnumerationOptions.filters |
| 163 err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize
+ 0, 8, new codec.PointerTo(UsbDeviceFilter), false, [0], 0); |
| 164 if (err !== validator.validationError.NONE) |
| 165 return err; |
| 166 |
| 167 return validator.validationError.NONE; |
| 168 }; |
| 169 |
| 170 UsbEnumerationOptions.encodedSize = codec.kStructHeaderSize + 8; |
| 171 |
| 172 UsbEnumerationOptions.decode = function(decoder) { |
| 173 var packed; |
| 174 var val = new UsbEnumerationOptions(); |
| 175 var numberOfBytes = decoder.readUint32(); |
| 176 var version = decoder.readUint32(); |
| 177 val.filters = decoder.decodeArrayPointer(new codec.PointerTo(UsbDeviceFilter
)); |
| 178 return val; |
| 179 }; |
| 180 |
| 181 UsbEnumerationOptions.encode = function(encoder, val) { |
| 182 var packed; |
| 183 encoder.writeUint32(UsbEnumerationOptions.encodedSize); |
| 184 encoder.writeUint32(0); |
| 185 encoder.encodeArrayPointer(new codec.PointerTo(UsbDeviceFilter), val.filters
); |
| 186 }; |
| 187 function UsbDeviceManager_GetDevices_Params(values) { |
| 188 this.initDefaults_(); |
| 189 this.initFields_(values); |
| 190 } |
| 191 |
| 192 |
| 193 UsbDeviceManager_GetDevices_Params.prototype.initDefaults_ = function() { |
| 194 this.options = null; |
| 195 }; |
| 196 UsbDeviceManager_GetDevices_Params.prototype.initFields_ = function(fields) { |
| 197 for(var field in fields) { |
| 198 if (this.hasOwnProperty(field)) |
| 199 this[field] = fields[field]; |
| 200 } |
| 201 }; |
| 202 |
| 203 UsbDeviceManager_GetDevices_Params.validate = function(messageValidator, offse
t) { |
| 204 var err; |
| 205 err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize)
; |
| 206 if (err !== validator.validationError.NONE) |
| 207 return err; |
| 208 |
| 209 var kVersionSizes = [ |
| 210 {version: 0, numBytes: 16} |
| 211 ]; |
| 212 err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| 213 if (err !== validator.validationError.NONE) |
| 214 return err; |
| 215 |
| 216 |
| 217 |
| 218 // validate UsbDeviceManager_GetDevices_Params.options |
| 219 err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSiz
e + 0, UsbEnumerationOptions, true); |
| 220 if (err !== validator.validationError.NONE) |
| 221 return err; |
| 222 |
| 223 return validator.validationError.NONE; |
| 224 }; |
| 225 |
| 226 UsbDeviceManager_GetDevices_Params.encodedSize = codec.kStructHeaderSize + 8; |
| 227 |
| 228 UsbDeviceManager_GetDevices_Params.decode = function(decoder) { |
| 229 var packed; |
| 230 var val = new UsbDeviceManager_GetDevices_Params(); |
| 231 var numberOfBytes = decoder.readUint32(); |
| 232 var version = decoder.readUint32(); |
| 233 val.options = decoder.decodeStructPointer(UsbEnumerationOptions); |
| 234 return val; |
| 235 }; |
| 236 |
| 237 UsbDeviceManager_GetDevices_Params.encode = function(encoder, val) { |
| 238 var packed; |
| 239 encoder.writeUint32(UsbDeviceManager_GetDevices_Params.encodedSize); |
| 240 encoder.writeUint32(0); |
| 241 encoder.encodeStructPointer(UsbEnumerationOptions, val.options); |
| 242 }; |
| 243 function UsbDeviceManager_GetDevices_ResponseParams(values) { |
| 244 this.initDefaults_(); |
| 245 this.initFields_(values); |
| 246 } |
| 247 |
| 248 |
| 249 UsbDeviceManager_GetDevices_ResponseParams.prototype.initDefaults_ = function(
) { |
| 250 this.results = null; |
| 251 }; |
| 252 UsbDeviceManager_GetDevices_ResponseParams.prototype.initFields_ = function(fi
elds) { |
| 253 for(var field in fields) { |
| 254 if (this.hasOwnProperty(field)) |
| 255 this[field] = fields[field]; |
| 256 } |
| 257 }; |
| 258 |
| 259 UsbDeviceManager_GetDevices_ResponseParams.validate = function(messageValidato
r, offset) { |
| 260 var err; |
| 261 err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize)
; |
| 262 if (err !== validator.validationError.NONE) |
| 263 return err; |
| 264 |
| 265 var kVersionSizes = [ |
| 266 {version: 0, numBytes: 16} |
| 267 ]; |
| 268 err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| 269 if (err !== validator.validationError.NONE) |
| 270 return err; |
| 271 |
| 272 |
| 273 |
| 274 // validate UsbDeviceManager_GetDevices_ResponseParams.results |
| 275 err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize
+ 0, 8, new codec.PointerTo(device$.UsbDeviceInfo), false, [0], 0); |
| 276 if (err !== validator.validationError.NONE) |
| 277 return err; |
| 278 |
| 279 return validator.validationError.NONE; |
| 280 }; |
| 281 |
| 282 UsbDeviceManager_GetDevices_ResponseParams.encodedSize = codec.kStructHeaderSi
ze + 8; |
| 283 |
| 284 UsbDeviceManager_GetDevices_ResponseParams.decode = function(decoder) { |
| 285 var packed; |
| 286 var val = new UsbDeviceManager_GetDevices_ResponseParams(); |
| 287 var numberOfBytes = decoder.readUint32(); |
| 288 var version = decoder.readUint32(); |
| 289 val.results = decoder.decodeArrayPointer(new codec.PointerTo(device$.UsbDevi
ceInfo)); |
| 290 return val; |
| 291 }; |
| 292 |
| 293 UsbDeviceManager_GetDevices_ResponseParams.encode = function(encoder, val) { |
| 294 var packed; |
| 295 encoder.writeUint32(UsbDeviceManager_GetDevices_ResponseParams.encodedSize); |
| 296 encoder.writeUint32(0); |
| 297 encoder.encodeArrayPointer(new codec.PointerTo(device$.UsbDeviceInfo), val.r
esults); |
| 298 }; |
| 299 function UsbDeviceManager_GetDevice_Params(values) { |
| 300 this.initDefaults_(); |
| 301 this.initFields_(values); |
| 302 } |
| 303 |
| 304 |
| 305 UsbDeviceManager_GetDevice_Params.prototype.initDefaults_ = function() { |
| 306 this.guid = null; |
| 307 this.deviceRequest = new bindings.InterfaceRequest(); |
| 308 }; |
| 309 UsbDeviceManager_GetDevice_Params.prototype.initFields_ = function(fields) { |
| 310 for(var field in fields) { |
| 311 if (this.hasOwnProperty(field)) |
| 312 this[field] = fields[field]; |
| 313 } |
| 314 }; |
| 315 |
| 316 UsbDeviceManager_GetDevice_Params.validate = function(messageValidator, offset
) { |
| 317 var err; |
| 318 err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize)
; |
| 319 if (err !== validator.validationError.NONE) |
| 320 return err; |
| 321 |
| 322 var kVersionSizes = [ |
| 323 {version: 0, numBytes: 24} |
| 324 ]; |
| 325 err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| 326 if (err !== validator.validationError.NONE) |
| 327 return err; |
| 328 |
| 329 |
| 330 |
| 331 // validate UsbDeviceManager_GetDevice_Params.guid |
| 332 err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSiz
e + 0, false) |
| 333 if (err !== validator.validationError.NONE) |
| 334 return err; |
| 335 |
| 336 |
| 337 |
| 338 // validate UsbDeviceManager_GetDevice_Params.deviceRequest |
| 339 err = messageValidator.validateInterfaceRequest(offset + codec.kStructHeader
Size + 8, false) |
| 340 if (err !== validator.validationError.NONE) |
| 341 return err; |
| 342 |
| 343 return validator.validationError.NONE; |
| 344 }; |
| 345 |
| 346 UsbDeviceManager_GetDevice_Params.encodedSize = codec.kStructHeaderSize + 16; |
| 347 |
| 348 UsbDeviceManager_GetDevice_Params.decode = function(decoder) { |
| 349 var packed; |
| 350 var val = new UsbDeviceManager_GetDevice_Params(); |
| 351 var numberOfBytes = decoder.readUint32(); |
| 352 var version = decoder.readUint32(); |
| 353 val.guid = decoder.decodeStruct(codec.String); |
| 354 val.deviceRequest = decoder.decodeStruct(codec.InterfaceRequest); |
| 355 decoder.skip(1); |
| 356 decoder.skip(1); |
| 357 decoder.skip(1); |
| 358 decoder.skip(1); |
| 359 return val; |
| 360 }; |
| 361 |
| 362 UsbDeviceManager_GetDevice_Params.encode = function(encoder, val) { |
| 363 var packed; |
| 364 encoder.writeUint32(UsbDeviceManager_GetDevice_Params.encodedSize); |
| 365 encoder.writeUint32(0); |
| 366 encoder.encodeStruct(codec.String, val.guid); |
| 367 encoder.encodeStruct(codec.InterfaceRequest, val.deviceRequest); |
| 368 encoder.skip(1); |
| 369 encoder.skip(1); |
| 370 encoder.skip(1); |
| 371 encoder.skip(1); |
| 372 }; |
| 373 function UsbDeviceManager_SetClient_Params(values) { |
| 374 this.initDefaults_(); |
| 375 this.initFields_(values); |
| 376 } |
| 377 |
| 378 |
| 379 UsbDeviceManager_SetClient_Params.prototype.initDefaults_ = function() { |
| 380 this.client = new UsbDeviceManagerClientPtr(); |
| 381 }; |
| 382 UsbDeviceManager_SetClient_Params.prototype.initFields_ = function(fields) { |
| 383 for(var field in fields) { |
| 384 if (this.hasOwnProperty(field)) |
| 385 this[field] = fields[field]; |
| 386 } |
| 387 }; |
| 388 |
| 389 UsbDeviceManager_SetClient_Params.validate = function(messageValidator, offset
) { |
| 390 var err; |
| 391 err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize)
; |
| 392 if (err !== validator.validationError.NONE) |
| 393 return err; |
| 394 |
| 395 var kVersionSizes = [ |
| 396 {version: 0, numBytes: 16} |
| 397 ]; |
| 398 err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| 399 if (err !== validator.validationError.NONE) |
| 400 return err; |
| 401 |
| 402 |
| 403 |
| 404 // validate UsbDeviceManager_SetClient_Params.client |
| 405 err = messageValidator.validateInterface(offset + codec.kStructHeaderSize +
0, false); |
| 406 if (err !== validator.validationError.NONE) |
| 407 return err; |
| 408 |
| 409 return validator.validationError.NONE; |
| 410 }; |
| 411 |
| 412 UsbDeviceManager_SetClient_Params.encodedSize = codec.kStructHeaderSize + 8; |
| 413 |
| 414 UsbDeviceManager_SetClient_Params.decode = function(decoder) { |
| 415 var packed; |
| 416 var val = new UsbDeviceManager_SetClient_Params(); |
| 417 var numberOfBytes = decoder.readUint32(); |
| 418 var version = decoder.readUint32(); |
| 419 val.client = decoder.decodeStruct(new codec.Interface(UsbDeviceManagerClient
Ptr)); |
| 420 return val; |
| 421 }; |
| 422 |
| 423 UsbDeviceManager_SetClient_Params.encode = function(encoder, val) { |
| 424 var packed; |
| 425 encoder.writeUint32(UsbDeviceManager_SetClient_Params.encodedSize); |
| 426 encoder.writeUint32(0); |
| 427 encoder.encodeStruct(new codec.Interface(UsbDeviceManagerClientPtr), val.cli
ent); |
| 428 }; |
| 429 function UsbDeviceManagerClient_OnDeviceAdded_Params(values) { |
| 430 this.initDefaults_(); |
| 431 this.initFields_(values); |
| 432 } |
| 433 |
| 434 |
| 435 UsbDeviceManagerClient_OnDeviceAdded_Params.prototype.initDefaults_ = function
() { |
| 436 this.deviceInfo = null; |
| 437 }; |
| 438 UsbDeviceManagerClient_OnDeviceAdded_Params.prototype.initFields_ = function(f
ields) { |
| 439 for(var field in fields) { |
| 440 if (this.hasOwnProperty(field)) |
| 441 this[field] = fields[field]; |
| 442 } |
| 443 }; |
| 444 |
| 445 UsbDeviceManagerClient_OnDeviceAdded_Params.validate = function(messageValidat
or, offset) { |
| 446 var err; |
| 447 err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize)
; |
| 448 if (err !== validator.validationError.NONE) |
| 449 return err; |
| 450 |
| 451 var kVersionSizes = [ |
| 452 {version: 0, numBytes: 16} |
| 453 ]; |
| 454 err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| 455 if (err !== validator.validationError.NONE) |
| 456 return err; |
| 457 |
| 458 |
| 459 |
| 460 // validate UsbDeviceManagerClient_OnDeviceAdded_Params.deviceInfo |
| 461 err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSiz
e + 0, device$.UsbDeviceInfo, false); |
| 462 if (err !== validator.validationError.NONE) |
| 463 return err; |
| 464 |
| 465 return validator.validationError.NONE; |
| 466 }; |
| 467 |
| 468 UsbDeviceManagerClient_OnDeviceAdded_Params.encodedSize = codec.kStructHeaderS
ize + 8; |
| 469 |
| 470 UsbDeviceManagerClient_OnDeviceAdded_Params.decode = function(decoder) { |
| 471 var packed; |
| 472 var val = new UsbDeviceManagerClient_OnDeviceAdded_Params(); |
| 473 var numberOfBytes = decoder.readUint32(); |
| 474 var version = decoder.readUint32(); |
| 475 val.deviceInfo = decoder.decodeStructPointer(device$.UsbDeviceInfo); |
| 476 return val; |
| 477 }; |
| 478 |
| 479 UsbDeviceManagerClient_OnDeviceAdded_Params.encode = function(encoder, val) { |
| 480 var packed; |
| 481 encoder.writeUint32(UsbDeviceManagerClient_OnDeviceAdded_Params.encodedSize)
; |
| 482 encoder.writeUint32(0); |
| 483 encoder.encodeStructPointer(device$.UsbDeviceInfo, val.deviceInfo); |
| 484 }; |
| 485 function UsbDeviceManagerClient_OnDeviceRemoved_Params(values) { |
| 486 this.initDefaults_(); |
| 487 this.initFields_(values); |
| 488 } |
| 489 |
| 490 |
| 491 UsbDeviceManagerClient_OnDeviceRemoved_Params.prototype.initDefaults_ = functi
on() { |
| 492 this.deviceInfo = null; |
| 493 }; |
| 494 UsbDeviceManagerClient_OnDeviceRemoved_Params.prototype.initFields_ = function
(fields) { |
| 495 for(var field in fields) { |
| 496 if (this.hasOwnProperty(field)) |
| 497 this[field] = fields[field]; |
| 498 } |
| 499 }; |
| 500 |
| 501 UsbDeviceManagerClient_OnDeviceRemoved_Params.validate = function(messageValid
ator, offset) { |
| 502 var err; |
| 503 err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize)
; |
| 504 if (err !== validator.validationError.NONE) |
| 505 return err; |
| 506 |
| 507 var kVersionSizes = [ |
| 508 {version: 0, numBytes: 16} |
| 509 ]; |
| 510 err = messageValidator.validateStructVersion(offset, kVersionSizes); |
| 511 if (err !== validator.validationError.NONE) |
| 512 return err; |
| 513 |
| 514 |
| 515 |
| 516 // validate UsbDeviceManagerClient_OnDeviceRemoved_Params.deviceInfo |
| 517 err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSiz
e + 0, device$.UsbDeviceInfo, false); |
| 518 if (err !== validator.validationError.NONE) |
| 519 return err; |
| 520 |
| 521 return validator.validationError.NONE; |
| 522 }; |
| 523 |
| 524 UsbDeviceManagerClient_OnDeviceRemoved_Params.encodedSize = codec.kStructHeade
rSize + 8; |
| 525 |
| 526 UsbDeviceManagerClient_OnDeviceRemoved_Params.decode = function(decoder) { |
| 527 var packed; |
| 528 var val = new UsbDeviceManagerClient_OnDeviceRemoved_Params(); |
| 529 var numberOfBytes = decoder.readUint32(); |
| 530 var version = decoder.readUint32(); |
| 531 val.deviceInfo = decoder.decodeStructPointer(device$.UsbDeviceInfo); |
| 532 return val; |
| 533 }; |
| 534 |
| 535 UsbDeviceManagerClient_OnDeviceRemoved_Params.encode = function(encoder, val)
{ |
| 536 var packed; |
| 537 encoder.writeUint32(UsbDeviceManagerClient_OnDeviceRemoved_Params.encodedSiz
e); |
| 538 encoder.writeUint32(0); |
| 539 encoder.encodeStructPointer(device$.UsbDeviceInfo, val.deviceInfo); |
| 540 }; |
| 541 var kUsbDeviceManager_GetDevices_Name = 0; |
| 542 var kUsbDeviceManager_GetDevice_Name = 1; |
| 543 var kUsbDeviceManager_SetClient_Name = 2; |
| 544 |
| 545 function UsbDeviceManagerPtr(handleOrPtrInfo) { |
| 546 this.ptr = new bindings.InterfacePtrController(UsbDeviceManager, |
| 547 handleOrPtrInfo); |
| 548 } |
| 549 |
| 550 function UsbDeviceManagerAssociatedPtr(associatedInterfacePtrInfo) { |
| 551 this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| 552 UsbDeviceManager, associatedInterfacePtrInfo); |
| 553 } |
| 554 |
| 555 UsbDeviceManagerAssociatedPtr.prototype = |
| 556 Object.create(UsbDeviceManagerPtr.prototype); |
| 557 UsbDeviceManagerAssociatedPtr.prototype.constructor = |
| 558 UsbDeviceManagerAssociatedPtr; |
| 559 |
| 560 function UsbDeviceManagerProxy(receiver) { |
| 561 this.receiver_ = receiver; |
| 562 } |
| 563 UsbDeviceManagerPtr.prototype.getDevices = function() { |
| 564 return UsbDeviceManagerProxy.prototype.getDevices |
| 565 .apply(this.ptr.getProxy(), arguments); |
| 566 }; |
| 567 |
| 568 UsbDeviceManagerProxy.prototype.getDevices = function(options) { |
| 569 var params = new UsbDeviceManager_GetDevices_Params(); |
| 570 params.options = options; |
| 571 return new Promise(function(resolve, reject) { |
| 572 var builder = new codec.MessageV1Builder( |
| 573 kUsbDeviceManager_GetDevices_Name, |
| 574 codec.align(UsbDeviceManager_GetDevices_Params.encodedSize), |
| 575 codec.kMessageExpectsResponse, 0); |
| 576 builder.encodeStruct(UsbDeviceManager_GetDevices_Params, params); |
| 577 var message = builder.finish(); |
| 578 this.receiver_.acceptAndExpectResponse(message).then(function(message) { |
| 579 var reader = new codec.MessageReader(message); |
| 580 var responseParams = |
| 581 reader.decodeStruct(UsbDeviceManager_GetDevices_ResponseParams); |
| 582 resolve(responseParams); |
| 583 }).catch(function(result) { |
| 584 reject(Error("Connection error: " + result)); |
| 585 }); |
| 586 }.bind(this)); |
| 587 }; |
| 588 UsbDeviceManagerPtr.prototype.getDevice = function() { |
| 589 return UsbDeviceManagerProxy.prototype.getDevice |
| 590 .apply(this.ptr.getProxy(), arguments); |
| 591 }; |
| 592 |
| 593 UsbDeviceManagerProxy.prototype.getDevice = function(guid, deviceRequest) { |
| 594 var params = new UsbDeviceManager_GetDevice_Params(); |
| 595 params.guid = guid; |
| 596 params.deviceRequest = deviceRequest; |
| 597 var builder = new codec.MessageV0Builder( |
| 598 kUsbDeviceManager_GetDevice_Name, |
| 599 codec.align(UsbDeviceManager_GetDevice_Params.encodedSize)); |
| 600 builder.encodeStruct(UsbDeviceManager_GetDevice_Params, params); |
| 601 var message = builder.finish(); |
| 602 this.receiver_.accept(message); |
| 603 }; |
| 604 UsbDeviceManagerPtr.prototype.setClient = function() { |
| 605 return UsbDeviceManagerProxy.prototype.setClient |
| 606 .apply(this.ptr.getProxy(), arguments); |
| 607 }; |
| 608 |
| 609 UsbDeviceManagerProxy.prototype.setClient = function(client) { |
| 610 var params = new UsbDeviceManager_SetClient_Params(); |
| 611 params.client = client; |
| 612 var builder = new codec.MessageV0Builder( |
| 613 kUsbDeviceManager_SetClient_Name, |
| 614 codec.align(UsbDeviceManager_SetClient_Params.encodedSize)); |
| 615 builder.encodeStruct(UsbDeviceManager_SetClient_Params, params); |
| 616 var message = builder.finish(); |
| 617 this.receiver_.accept(message); |
| 618 }; |
| 619 |
| 620 function UsbDeviceManagerStub(delegate) { |
| 621 this.delegate_ = delegate; |
| 622 } |
| 623 UsbDeviceManagerStub.prototype.getDevices = function(options) { |
| 624 return this.delegate_ && this.delegate_.getDevices && this.delegate_.getDevi
ces(options); |
| 625 } |
| 626 UsbDeviceManagerStub.prototype.getDevice = function(guid, deviceRequest) { |
| 627 return this.delegate_ && this.delegate_.getDevice && this.delegate_.getDevic
e(guid, deviceRequest); |
| 628 } |
| 629 UsbDeviceManagerStub.prototype.setClient = function(client) { |
| 630 return this.delegate_ && this.delegate_.setClient && this.delegate_.setClien
t(client); |
| 631 } |
| 632 |
| 633 UsbDeviceManagerStub.prototype.accept = function(message) { |
| 634 var reader = new codec.MessageReader(message); |
| 635 switch (reader.messageName) { |
| 636 case kUsbDeviceManager_GetDevice_Name: |
| 637 var params = reader.decodeStruct(UsbDeviceManager_GetDevice_Params); |
| 638 this.getDevice(params.guid, params.deviceRequest); |
| 639 return true; |
| 640 case kUsbDeviceManager_SetClient_Name: |
| 641 var params = reader.decodeStruct(UsbDeviceManager_SetClient_Params); |
| 642 this.setClient(params.client); |
| 643 return true; |
| 644 default: |
| 645 return false; |
| 646 } |
| 647 }; |
| 648 |
| 649 UsbDeviceManagerStub.prototype.acceptWithResponder = |
| 650 function(message, responder) { |
| 651 var reader = new codec.MessageReader(message); |
| 652 switch (reader.messageName) { |
| 653 case kUsbDeviceManager_GetDevices_Name: |
| 654 var params = reader.decodeStruct(UsbDeviceManager_GetDevices_Params); |
| 655 this.getDevices(params.options).then(function(response) { |
| 656 var responseParams = |
| 657 new UsbDeviceManager_GetDevices_ResponseParams(); |
| 658 responseParams.results = response.results; |
| 659 var builder = new codec.MessageV1Builder( |
| 660 kUsbDeviceManager_GetDevices_Name, |
| 661 codec.align(UsbDeviceManager_GetDevices_ResponseParams.encodedSize), |
| 662 codec.kMessageIsResponse, reader.requestID); |
| 663 builder.encodeStruct(UsbDeviceManager_GetDevices_ResponseParams, |
| 664 responseParams); |
| 665 var message = builder.finish(); |
| 666 responder.accept(message); |
| 667 }); |
| 668 return true; |
| 669 default: |
| 670 return false; |
| 671 } |
| 672 }; |
| 673 |
| 674 function validateUsbDeviceManagerRequest(messageValidator) { |
| 675 var message = messageValidator.message; |
| 676 var paramsClass = null; |
| 677 switch (message.getName()) { |
| 678 case kUsbDeviceManager_GetDevices_Name: |
| 679 if (message.expectsResponse()) |
| 680 paramsClass = UsbDeviceManager_GetDevices_Params; |
| 681 break; |
| 682 case kUsbDeviceManager_GetDevice_Name: |
| 683 if (!message.expectsResponse() && !message.isResponse()) |
| 684 paramsClass = UsbDeviceManager_GetDevice_Params; |
| 685 break; |
| 686 case kUsbDeviceManager_SetClient_Name: |
| 687 if (!message.expectsResponse() && !message.isResponse()) |
| 688 paramsClass = UsbDeviceManager_SetClient_Params; |
| 689 break; |
| 690 } |
| 691 if (paramsClass === null) |
| 692 return validator.validationError.NONE; |
| 693 return paramsClass.validate(messageValidator, messageValidator.message.getHe
aderNumBytes()); |
| 694 } |
| 695 |
| 696 function validateUsbDeviceManagerResponse(messageValidator) { |
| 697 var message = messageValidator.message; |
| 698 var paramsClass = null; |
| 699 switch (message.getName()) { |
| 700 case kUsbDeviceManager_GetDevices_Name: |
| 701 if (message.isResponse()) |
| 702 paramsClass = UsbDeviceManager_GetDevices_ResponseParams; |
| 703 break; |
| 704 } |
| 705 if (paramsClass === null) |
| 706 return validator.validationError.NONE; |
| 707 return paramsClass.validate(messageValidator, messageValidator.message.getHe
aderNumBytes()); |
| 708 } |
| 709 |
| 710 var UsbDeviceManager = { |
| 711 name: 'device::mojom::UsbDeviceManager', |
| 712 kVersion: 0, |
| 713 ptrClass: UsbDeviceManagerPtr, |
| 714 proxyClass: UsbDeviceManagerProxy, |
| 715 stubClass: UsbDeviceManagerStub, |
| 716 validateRequest: validateUsbDeviceManagerRequest, |
| 717 validateResponse: validateUsbDeviceManagerResponse, |
| 718 }; |
| 719 UsbDeviceManagerStub.prototype.validator = validateUsbDeviceManagerRequest; |
| 720 UsbDeviceManagerProxy.prototype.validator = validateUsbDeviceManagerResponse; |
| 721 var kUsbDeviceManagerClient_OnDeviceAdded_Name = 0; |
| 722 var kUsbDeviceManagerClient_OnDeviceRemoved_Name = 1; |
| 723 |
| 724 function UsbDeviceManagerClientPtr(handleOrPtrInfo) { |
| 725 this.ptr = new bindings.InterfacePtrController(UsbDeviceManagerClient, |
| 726 handleOrPtrInfo); |
| 727 } |
| 728 |
| 729 function UsbDeviceManagerClientAssociatedPtr(associatedInterfacePtrInfo) { |
| 730 this.ptr = new associatedBindings.AssociatedInterfacePtrController( |
| 731 UsbDeviceManagerClient, associatedInterfacePtrInfo); |
| 732 } |
| 733 |
| 734 UsbDeviceManagerClientAssociatedPtr.prototype = |
| 735 Object.create(UsbDeviceManagerClientPtr.prototype); |
| 736 UsbDeviceManagerClientAssociatedPtr.prototype.constructor = |
| 737 UsbDeviceManagerClientAssociatedPtr; |
| 738 |
| 739 function UsbDeviceManagerClientProxy(receiver) { |
| 740 this.receiver_ = receiver; |
| 741 } |
| 742 UsbDeviceManagerClientPtr.prototype.onDeviceAdded = function() { |
| 743 return UsbDeviceManagerClientProxy.prototype.onDeviceAdded |
| 744 .apply(this.ptr.getProxy(), arguments); |
| 745 }; |
| 746 |
| 747 UsbDeviceManagerClientProxy.prototype.onDeviceAdded = function(deviceInfo) { |
| 748 var params = new UsbDeviceManagerClient_OnDeviceAdded_Params(); |
| 749 params.deviceInfo = deviceInfo; |
| 750 var builder = new codec.MessageV0Builder( |
| 751 kUsbDeviceManagerClient_OnDeviceAdded_Name, |
| 752 codec.align(UsbDeviceManagerClient_OnDeviceAdded_Params.encodedSize)); |
| 753 builder.encodeStruct(UsbDeviceManagerClient_OnDeviceAdded_Params, params); |
| 754 var message = builder.finish(); |
| 755 this.receiver_.accept(message); |
| 756 }; |
| 757 UsbDeviceManagerClientPtr.prototype.onDeviceRemoved = function() { |
| 758 return UsbDeviceManagerClientProxy.prototype.onDeviceRemoved |
| 759 .apply(this.ptr.getProxy(), arguments); |
| 760 }; |
| 761 |
| 762 UsbDeviceManagerClientProxy.prototype.onDeviceRemoved = function(deviceInfo) { |
| 763 var params = new UsbDeviceManagerClient_OnDeviceRemoved_Params(); |
| 764 params.deviceInfo = deviceInfo; |
| 765 var builder = new codec.MessageV0Builder( |
| 766 kUsbDeviceManagerClient_OnDeviceRemoved_Name, |
| 767 codec.align(UsbDeviceManagerClient_OnDeviceRemoved_Params.encodedSize)); |
| 768 builder.encodeStruct(UsbDeviceManagerClient_OnDeviceRemoved_Params, params); |
| 769 var message = builder.finish(); |
| 770 this.receiver_.accept(message); |
| 771 }; |
| 772 |
| 773 function UsbDeviceManagerClientStub(delegate) { |
| 774 this.delegate_ = delegate; |
| 775 } |
| 776 UsbDeviceManagerClientStub.prototype.onDeviceAdded = function(deviceInfo) { |
| 777 return this.delegate_ && this.delegate_.onDeviceAdded && this.delegate_.onDe
viceAdded(deviceInfo); |
| 778 } |
| 779 UsbDeviceManagerClientStub.prototype.onDeviceRemoved = function(deviceInfo) { |
| 780 return this.delegate_ && this.delegate_.onDeviceRemoved && this.delegate_.on
DeviceRemoved(deviceInfo); |
| 781 } |
| 782 |
| 783 UsbDeviceManagerClientStub.prototype.accept = function(message) { |
| 784 var reader = new codec.MessageReader(message); |
| 785 switch (reader.messageName) { |
| 786 case kUsbDeviceManagerClient_OnDeviceAdded_Name: |
| 787 var params = reader.decodeStruct(UsbDeviceManagerClient_OnDeviceAdded_Para
ms); |
| 788 this.onDeviceAdded(params.deviceInfo); |
| 789 return true; |
| 790 case kUsbDeviceManagerClient_OnDeviceRemoved_Name: |
| 791 var params = reader.decodeStruct(UsbDeviceManagerClient_OnDeviceRemoved_Pa
rams); |
| 792 this.onDeviceRemoved(params.deviceInfo); |
| 793 return true; |
| 794 default: |
| 795 return false; |
| 796 } |
| 797 }; |
| 798 |
| 799 UsbDeviceManagerClientStub.prototype.acceptWithResponder = |
| 800 function(message, responder) { |
| 801 var reader = new codec.MessageReader(message); |
| 802 switch (reader.messageName) { |
| 803 default: |
| 804 return false; |
| 805 } |
| 806 }; |
| 807 |
| 808 function validateUsbDeviceManagerClientRequest(messageValidator) { |
| 809 var message = messageValidator.message; |
| 810 var paramsClass = null; |
| 811 switch (message.getName()) { |
| 812 case kUsbDeviceManagerClient_OnDeviceAdded_Name: |
| 813 if (!message.expectsResponse() && !message.isResponse()) |
| 814 paramsClass = UsbDeviceManagerClient_OnDeviceAdded_Params; |
| 815 break; |
| 816 case kUsbDeviceManagerClient_OnDeviceRemoved_Name: |
| 817 if (!message.expectsResponse() && !message.isResponse()) |
| 818 paramsClass = UsbDeviceManagerClient_OnDeviceRemoved_Params; |
| 819 break; |
| 820 } |
| 821 if (paramsClass === null) |
| 822 return validator.validationError.NONE; |
| 823 return paramsClass.validate(messageValidator, messageValidator.message.getHe
aderNumBytes()); |
| 824 } |
| 825 |
| 826 function validateUsbDeviceManagerClientResponse(messageValidator) { |
| 827 return validator.validationError.NONE; |
| 828 } |
| 829 |
| 830 var UsbDeviceManagerClient = { |
| 831 name: 'device::mojom::UsbDeviceManagerClient', |
| 832 kVersion: 0, |
| 833 ptrClass: UsbDeviceManagerClientPtr, |
| 834 proxyClass: UsbDeviceManagerClientProxy, |
| 835 stubClass: UsbDeviceManagerClientStub, |
| 836 validateRequest: validateUsbDeviceManagerClientRequest, |
| 837 validateResponse: null, |
| 838 }; |
| 839 UsbDeviceManagerClientStub.prototype.validator = validateUsbDeviceManagerClien
tRequest; |
| 840 UsbDeviceManagerClientProxy.prototype.validator = null; |
| 841 var exports = mojo.internal.exposeNamespace("device.mojom"); |
| 842 exports.UsbDeviceFilter = UsbDeviceFilter; |
| 843 exports.UsbEnumerationOptions = UsbEnumerationOptions; |
| 844 exports.UsbDeviceManager = UsbDeviceManager; |
| 845 exports.UsbDeviceManagerPtr = UsbDeviceManagerPtr; |
| 846 exports.UsbDeviceManagerAssociatedPtr = UsbDeviceManagerAssociatedPtr; |
| 847 exports.UsbDeviceManagerClient = UsbDeviceManagerClient; |
| 848 exports.UsbDeviceManagerClientPtr = UsbDeviceManagerClientPtr; |
| 849 exports.UsbDeviceManagerClientAssociatedPtr = UsbDeviceManagerClientAssociated
Ptr; |
| 850 })(); |
OLD | NEW |