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 (function() { | 5 (function() { |
6 var internal = mojo.internal; | 6 var internal = mojo.internal; |
7 | 7 |
8 var kErrorUnsigned = "Passing negative value to unsigned"; | 8 var kErrorUnsigned = "Passing negative value to unsigned"; |
9 var kErrorArray = "Passing non Array for array type"; | 9 var kErrorArray = "Passing non Array for array type"; |
10 var kErrorString = "Passing non String for string type"; | 10 var kErrorString = "Passing non String for string type"; |
11 var kErrorMap = "Passing non Map for map type"; | 11 var kErrorMap = "Passing non Map for map type"; |
12 | 12 |
13 // Memory ------------------------------------------------------------------- | 13 // Memory ------------------------------------------------------------------- |
14 | 14 |
15 var kAlignment = 8; | 15 var kAlignment = 8; |
16 | 16 |
17 function align(size) { | 17 function align(size) { |
18 return size + (kAlignment - (size % kAlignment)) % kAlignment; | 18 return size + (kAlignment - (size % kAlignment)) % kAlignment; |
19 } | 19 } |
20 | 20 |
21 function isAligned(offset) { | 21 function isAligned(offset) { |
22 return offset >= 0 && (offset % kAlignment) === 0; | 22 return offset >= 0 && (offset % kAlignment) === 0; |
23 } | 23 } |
24 | 24 |
25 // Constants ---------------------------------------------------------------- | 25 // Constants ---------------------------------------------------------------- |
26 | 26 |
27 var kArrayHeaderSize = 8; | 27 var kArrayHeaderSize = 8; |
28 var kStructHeaderSize = 8; | 28 var kStructHeaderSize = 8; |
29 var kMessageHeaderSize = 24; | 29 var kMessageV0HeaderSize = 24; |
30 var kMessageWithRequestIDHeaderSize = 32; | 30 var kMessageV1HeaderSize = 32; |
| 31 var kMessageV2HeaderSize = 48; |
31 var kMapStructPayloadSize = 16; | 32 var kMapStructPayloadSize = 16; |
32 | 33 |
33 var kStructHeaderNumBytesOffset = 0; | 34 var kStructHeaderNumBytesOffset = 0; |
34 var kStructHeaderVersionOffset = 4; | 35 var kStructHeaderVersionOffset = 4; |
35 | 36 |
36 var kEncodedInvalidHandleValue = 0xFFFFFFFF; | 37 var kEncodedInvalidHandleValue = 0xFFFFFFFF; |
37 | 38 |
38 // Decoder ------------------------------------------------------------------ | 39 // Decoder ------------------------------------------------------------------ |
39 | 40 |
40 function Decoder(buffer, handles, base) { | 41 function Decoder(buffer, handles, associatedEndpointHandles, base) { |
41 this.buffer = buffer; | 42 this.buffer = buffer; |
42 this.handles = handles; | 43 this.handles = handles; |
| 44 this.associatedEndpointHandles = associatedEndpointHandles; |
43 this.base = base; | 45 this.base = base; |
44 this.next = base; | 46 this.next = base; |
45 } | 47 } |
46 | 48 |
47 Decoder.prototype.align = function() { | 49 Decoder.prototype.align = function() { |
48 this.next = align(this.next); | 50 this.next = align(this.next); |
49 }; | 51 }; |
50 | 52 |
51 Decoder.prototype.skip = function(offset) { | 53 Decoder.prototype.skip = function(offset) { |
52 this.next += offset; | 54 this.next += offset; |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
116 // TODO(abarth): To correctly decode a pointer, we need to know the real | 118 // TODO(abarth): To correctly decode a pointer, we need to know the real |
117 // base address of the array buffer. | 119 // base address of the array buffer. |
118 var offsetPointer = this.next; | 120 var offsetPointer = this.next; |
119 var offset = this.readUint64(); | 121 var offset = this.readUint64(); |
120 if (!offset) | 122 if (!offset) |
121 return 0; | 123 return 0; |
122 return offsetPointer + offset; | 124 return offsetPointer + offset; |
123 }; | 125 }; |
124 | 126 |
125 Decoder.prototype.decodeAndCreateDecoder = function(pointer) { | 127 Decoder.prototype.decodeAndCreateDecoder = function(pointer) { |
126 return new Decoder(this.buffer, this.handles, pointer); | 128 return new Decoder(this.buffer, this.handles, |
| 129 this.associatedEndpointHandles, pointer); |
127 }; | 130 }; |
128 | 131 |
129 Decoder.prototype.decodeHandle = function() { | 132 Decoder.prototype.decodeHandle = function() { |
130 return this.handles[this.readUint32()] || null; | 133 return this.handles[this.readUint32()] || null; |
131 }; | 134 }; |
132 | 135 |
| 136 Decoder.prototype.decodeAssociatedEndpointHandle = function() { |
| 137 return this.associatedEndpointHandles[this.readUint32()] || null; |
| 138 }; |
| 139 |
133 Decoder.prototype.decodeString = function() { | 140 Decoder.prototype.decodeString = function() { |
134 var numberOfBytes = this.readUint32(); | 141 var numberOfBytes = this.readUint32(); |
135 var numberOfElements = this.readUint32(); | 142 var numberOfElements = this.readUint32(); |
136 var base = this.next; | 143 var base = this.next; |
137 this.next += numberOfElements; | 144 this.next += numberOfElements; |
138 return internal.decodeUtf8String( | 145 return internal.decodeUtf8String( |
139 new Uint8Array(this.buffer.arrayBuffer, base, numberOfElements)); | 146 new Uint8Array(this.buffer.arrayBuffer, base, numberOfElements)); |
140 }; | 147 }; |
141 | 148 |
142 Decoder.prototype.decodeArray = function(cls) { | 149 Decoder.prototype.decodeArray = function(cls) { |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
201 var pointer = this.decodePointer(); | 208 var pointer = this.decodePointer(); |
202 if (!pointer) { | 209 if (!pointer) { |
203 return null; | 210 return null; |
204 } | 211 } |
205 var decoder = this.decodeAndCreateDecoder(pointer); | 212 var decoder = this.decodeAndCreateDecoder(pointer); |
206 return decoder.decodeMap(keyClass, valueClass); | 213 return decoder.decodeMap(keyClass, valueClass); |
207 }; | 214 }; |
208 | 215 |
209 // Encoder ------------------------------------------------------------------ | 216 // Encoder ------------------------------------------------------------------ |
210 | 217 |
211 function Encoder(buffer, handles, base) { | 218 function Encoder(buffer, handles, associatedEndpointHandles, base) { |
212 this.buffer = buffer; | 219 this.buffer = buffer; |
213 this.handles = handles; | 220 this.handles = handles; |
| 221 this.associatedEndpointHandles = associatedEndpointHandles; |
214 this.base = base; | 222 this.base = base; |
215 this.next = base; | 223 this.next = base; |
216 } | 224 } |
217 | 225 |
218 Encoder.prototype.align = function() { | 226 Encoder.prototype.align = function() { |
219 this.next = align(this.next); | 227 this.next = align(this.next); |
220 }; | 228 }; |
221 | 229 |
222 Encoder.prototype.skip = function(offset) { | 230 Encoder.prototype.skip = function(offset) { |
223 this.next += offset; | 231 this.next += offset; |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
290 return this.writeUint64(0); | 298 return this.writeUint64(0); |
291 // TODO(abarth): To correctly encode a pointer, we need to know the real | 299 // TODO(abarth): To correctly encode a pointer, we need to know the real |
292 // base address of the array buffer. | 300 // base address of the array buffer. |
293 var offset = pointer - this.next; | 301 var offset = pointer - this.next; |
294 this.writeUint64(offset); | 302 this.writeUint64(offset); |
295 }; | 303 }; |
296 | 304 |
297 Encoder.prototype.createAndEncodeEncoder = function(size) { | 305 Encoder.prototype.createAndEncodeEncoder = function(size) { |
298 var pointer = this.buffer.alloc(align(size)); | 306 var pointer = this.buffer.alloc(align(size)); |
299 this.encodePointer(pointer); | 307 this.encodePointer(pointer); |
300 return new Encoder(this.buffer, this.handles, pointer); | 308 return new Encoder(this.buffer, this.handles, |
| 309 this.associatedEndpointHandles, pointer); |
301 }; | 310 }; |
302 | 311 |
303 Encoder.prototype.encodeHandle = function(handle) { | 312 Encoder.prototype.encodeHandle = function(handle) { |
304 if (handle) { | 313 if (handle) { |
305 this.handles.push(handle); | 314 this.handles.push(handle); |
306 this.writeUint32(this.handles.length - 1); | 315 this.writeUint32(this.handles.length - 1); |
307 } else { | 316 } else { |
308 this.writeUint32(kEncodedInvalidHandleValue); | 317 this.writeUint32(kEncodedInvalidHandleValue); |
309 } | 318 } |
310 }; | 319 }; |
311 | 320 |
| 321 Encoder.prototype.encodeAssociatedEndpointHandle = function(endpointHandle) { |
| 322 if (endpointHandle) { |
| 323 this.associatedEndpointHandles.push(endpointHandle); |
| 324 this.writeUint32(this.associatedEndpointHandles.length - 1); |
| 325 } else { |
| 326 this.writeUint32(kEncodedInvalidHandleValue); |
| 327 } |
| 328 }; |
| 329 |
312 Encoder.prototype.encodeString = function(val) { | 330 Encoder.prototype.encodeString = function(val) { |
313 var base = this.next + kArrayHeaderSize; | 331 var base = this.next + kArrayHeaderSize; |
314 var numberOfElements = internal.encodeUtf8String( | 332 var numberOfElements = internal.encodeUtf8String( |
315 val, new Uint8Array(this.buffer.arrayBuffer, base)); | 333 val, new Uint8Array(this.buffer.arrayBuffer, base)); |
316 var numberOfBytes = kArrayHeaderSize + numberOfElements; | 334 var numberOfBytes = kArrayHeaderSize + numberOfElements; |
317 this.writeUint32(numberOfBytes); | 335 this.writeUint32(numberOfBytes); |
318 this.writeUint32(numberOfElements); | 336 this.writeUint32(numberOfElements); |
319 this.next += numberOfElements; | 337 this.next += numberOfElements; |
320 }; | 338 }; |
321 | 339 |
(...skipping 96 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
418 var encoder = this.createAndEncodeEncoder(encodedSize); | 436 var encoder = this.createAndEncodeEncoder(encodedSize); |
419 encoder.encodeMap(keyClass, valueClass, val); | 437 encoder.encodeMap(keyClass, valueClass, val); |
420 }; | 438 }; |
421 | 439 |
422 // Message ------------------------------------------------------------------ | 440 // Message ------------------------------------------------------------------ |
423 | 441 |
424 var kMessageInterfaceIdOffset = kStructHeaderSize; | 442 var kMessageInterfaceIdOffset = kStructHeaderSize; |
425 var kMessageNameOffset = kMessageInterfaceIdOffset + 4; | 443 var kMessageNameOffset = kMessageInterfaceIdOffset + 4; |
426 var kMessageFlagsOffset = kMessageNameOffset + 4; | 444 var kMessageFlagsOffset = kMessageNameOffset + 4; |
427 var kMessageRequestIDOffset = kMessageFlagsOffset + 8; | 445 var kMessageRequestIDOffset = kMessageFlagsOffset + 8; |
| 446 var kMessagePayloadInterfaceIdsPointerOffset = kMessageV2HeaderSize - 8; |
428 | 447 |
429 var kMessageExpectsResponse = 1 << 0; | 448 var kMessageExpectsResponse = 1 << 0; |
430 var kMessageIsResponse = 1 << 1; | 449 var kMessageIsResponse = 1 << 1; |
431 | 450 |
432 function Message(buffer, handles) { | 451 function Message(buffer, handles, associatedEndpointHandles) { |
| 452 if (associatedEndpointHandles === undefined) { |
| 453 associatedEndpointHandles = []; |
| 454 } |
| 455 |
433 this.buffer = buffer; | 456 this.buffer = buffer; |
434 this.handles = handles; | 457 this.handles = handles; |
| 458 this.associatedEndpointHandles = associatedEndpointHandles; |
435 } | 459 } |
436 | 460 |
437 Message.prototype.getHeaderNumBytes = function() { | 461 Message.prototype.getHeaderNumBytes = function() { |
438 return this.buffer.getUint32(kStructHeaderNumBytesOffset); | 462 return this.buffer.getUint32(kStructHeaderNumBytesOffset); |
439 }; | 463 }; |
440 | 464 |
441 Message.prototype.getHeaderVersion = function() { | 465 Message.prototype.getHeaderVersion = function() { |
442 return this.buffer.getUint32(kStructHeaderVersionOffset); | 466 return this.buffer.getUint32(kStructHeaderVersionOffset); |
443 }; | 467 }; |
444 | 468 |
445 Message.prototype.getName = function() { | 469 Message.prototype.getName = function() { |
446 return this.buffer.getUint32(kMessageNameOffset); | 470 return this.buffer.getUint32(kMessageNameOffset); |
447 }; | 471 }; |
448 | 472 |
449 Message.prototype.getFlags = function() { | 473 Message.prototype.getFlags = function() { |
450 return this.buffer.getUint32(kMessageFlagsOffset); | 474 return this.buffer.getUint32(kMessageFlagsOffset); |
451 }; | 475 }; |
452 | 476 |
| 477 Message.prototype.getInterfaceId = function() { |
| 478 return this.buffer.getUint32(kMessageInterfaceIdOffset); |
| 479 }; |
| 480 |
| 481 Message.prototype.getPayloadInterfaceIds = function() { |
| 482 if (this.getHeaderVersion() < 2) { |
| 483 return null; |
| 484 } |
| 485 |
| 486 var decoder = new Decoder(this.buffer, this.handles, |
| 487 this.associatedEndpointHandles, |
| 488 kMessagePayloadInterfaceIdsPointerOffset); |
| 489 var payloadInterfaceIds = decoder.decodeArrayPointer(Uint32); |
| 490 return payloadInterfaceIds; |
| 491 }; |
| 492 |
453 Message.prototype.isResponse = function() { | 493 Message.prototype.isResponse = function() { |
454 return (this.getFlags() & kMessageIsResponse) != 0; | 494 return (this.getFlags() & kMessageIsResponse) != 0; |
455 }; | 495 }; |
456 | 496 |
457 Message.prototype.expectsResponse = function() { | 497 Message.prototype.expectsResponse = function() { |
458 return (this.getFlags() & kMessageExpectsResponse) != 0; | 498 return (this.getFlags() & kMessageExpectsResponse) != 0; |
459 }; | 499 }; |
460 | 500 |
461 Message.prototype.setRequestID = function(requestID) { | 501 Message.prototype.setRequestID = function(requestID) { |
462 // TODO(darin): Verify that space was reserved for this field! | 502 // TODO(darin): Verify that space was reserved for this field! |
463 this.buffer.setUint64(kMessageRequestIDOffset, requestID); | 503 this.buffer.setUint64(kMessageRequestIDOffset, requestID); |
464 }; | 504 }; |
465 | 505 |
| 506 Message.prototype.setInterfaceId = function(interfaceId) { |
| 507 this.buffer.setUint32(kMessageInterfaceIdOffset, interfaceId); |
| 508 }; |
| 509 |
| 510 Message.prototype.setPayloadInterfaceIds_ = function(payloadInterfaceIds) { |
| 511 if (this.getHeaderVersion() < 2) { |
| 512 throw new Error( |
| 513 "Version of message does not support payload interface ids"); |
| 514 } |
| 515 |
| 516 var decoder = new Decoder(this.buffer, this.handles, |
| 517 this.associatedEndpointHandles, |
| 518 kMessagePayloadInterfaceIdsPointerOffset); |
| 519 var payloadInterfaceIdsOffset = decoder.decodePointer(); |
| 520 var encoder = new Encoder(this.buffer, this.handles, |
| 521 this.associatedEndpointHandles, |
| 522 payloadInterfaceIdsOffset); |
| 523 encoder.encodeArray(Uint32, payloadInterfaceIds); |
| 524 }; |
| 525 |
| 526 Message.prototype.serializeAssociatedEndpointHandles = function( |
| 527 associatedGroupController) { |
| 528 if (this.associatedEndpointHandles.length > 0) { |
| 529 if (this.getHeaderVersion() < 2) { |
| 530 throw new Error( |
| 531 "Version of message does not support associated endpoint handles"); |
| 532 } |
| 533 |
| 534 var data = []; |
| 535 for (var i = 0; i < this.associatedEndpointHandles.length; i++) { |
| 536 var handle = this.associatedEndpointHandles[i]; |
| 537 data.push(associatedGroupController.associateInterface(handle)); |
| 538 } |
| 539 this.associatedEndpointHandles = []; |
| 540 this.setPayloadInterfaceIds_(data); |
| 541 } |
| 542 }; |
| 543 |
| 544 Message.prototype.deserializeAssociatedEndpointHandles = function( |
| 545 associatedGroupController) { |
| 546 if (this.getHeaderVersion() < 2) { |
| 547 return true; |
| 548 } |
| 549 |
| 550 this.associatedEndpointHandles = []; |
| 551 var ids = this.getPayloadInterfaceIds(); |
| 552 |
| 553 var result = true; |
| 554 for (var i = 0; i < ids.length; i++) { |
| 555 var handle = associatedGroupController.createLocalEndpointHandle(ids[i]); |
| 556 if (internal.isValidInterfaceId(ids[i]) && !handle.isValid()) { |
| 557 // |ids[i]| itself is valid but handle creation failed. In that case, |
| 558 // mark deserialization as failed but continue to deserialize the |
| 559 // rest of handles. |
| 560 result = false; |
| 561 } |
| 562 this.associatedEndpointHandles.push(handle); |
| 563 ids[i] = internal.kInvalidInterfaceId; |
| 564 } |
| 565 |
| 566 this.setPayloadInterfaceIds_(ids); |
| 567 return result; |
| 568 }; |
| 569 |
466 | 570 |
467 // MessageV0Builder --------------------------------------------------------- | 571 // MessageV0Builder --------------------------------------------------------- |
468 | 572 |
469 function MessageV0Builder(messageName, payloadSize) { | 573 function MessageV0Builder(messageName, payloadSize) { |
470 // Currently, we don't compute the payload size correctly ahead of time. | 574 // Currently, we don't compute the payload size correctly ahead of time. |
471 // Instead, we resize the buffer at the end. | 575 // Instead, we resize the buffer at the end. |
472 var numberOfBytes = kMessageHeaderSize + payloadSize; | 576 var numberOfBytes = kMessageV0HeaderSize + payloadSize; |
473 this.buffer = new internal.Buffer(numberOfBytes); | 577 this.buffer = new internal.Buffer(numberOfBytes); |
474 this.handles = []; | 578 this.handles = []; |
475 var encoder = this.createEncoder(kMessageHeaderSize); | 579 var encoder = this.createEncoder(kMessageV0HeaderSize); |
476 encoder.writeUint32(kMessageHeaderSize); | 580 encoder.writeUint32(kMessageV0HeaderSize); |
477 encoder.writeUint32(0); // version. | 581 encoder.writeUint32(0); // version. |
478 encoder.writeUint32(0); // interface ID. | 582 encoder.writeUint32(0); // interface ID. |
479 encoder.writeUint32(messageName); | 583 encoder.writeUint32(messageName); |
480 encoder.writeUint32(0); // flags. | 584 encoder.writeUint32(0); // flags. |
481 encoder.writeUint32(0); // padding. | 585 encoder.writeUint32(0); // padding. |
482 } | 586 } |
483 | 587 |
484 MessageV0Builder.prototype.createEncoder = function(size) { | 588 MessageV0Builder.prototype.createEncoder = function(size) { |
485 var pointer = this.buffer.alloc(size); | 589 var pointer = this.buffer.alloc(size); |
486 return new Encoder(this.buffer, this.handles, pointer); | 590 return new Encoder(this.buffer, this.handles, [], pointer); |
487 }; | 591 }; |
488 | 592 |
489 MessageV0Builder.prototype.encodeStruct = function(cls, val) { | 593 MessageV0Builder.prototype.encodeStruct = function(cls, val) { |
490 cls.encode(this.createEncoder(cls.encodedSize), val); | 594 cls.encode(this.createEncoder(cls.encodedSize), val); |
491 }; | 595 }; |
492 | 596 |
493 MessageV0Builder.prototype.finish = function() { | 597 MessageV0Builder.prototype.finish = function() { |
494 // TODO(abarth): Rather than resizing the buffer at the end, we could | 598 // TODO(abarth): Rather than resizing the buffer at the end, we could |
495 // compute the size we need ahead of time, like we do in C++. | 599 // compute the size we need ahead of time, like we do in C++. |
496 this.buffer.trim(); | 600 this.buffer.trim(); |
497 var message = new Message(this.buffer, this.handles); | 601 var message = new Message(this.buffer, this.handles); |
498 this.buffer = null; | 602 this.buffer = null; |
499 this.handles = null; | 603 this.handles = null; |
500 this.encoder = null; | 604 this.encoder = null; |
501 return message; | 605 return message; |
502 }; | 606 }; |
503 | 607 |
504 // MessageV1Builder ----------------------------------------------- | 608 // MessageV1Builder ----------------------------------------------- |
505 | 609 |
506 function MessageV1Builder(messageName, payloadSize, flags, | 610 function MessageV1Builder(messageName, payloadSize, flags, |
507 requestID) { | 611 requestID) { |
508 // Currently, we don't compute the payload size correctly ahead of time. | 612 // Currently, we don't compute the payload size correctly ahead of time. |
509 // Instead, we resize the buffer at the end. | 613 // Instead, we resize the buffer at the end. |
510 var numberOfBytes = kMessageWithRequestIDHeaderSize + payloadSize; | 614 var numberOfBytes = kMessageV1HeaderSize + payloadSize; |
511 this.buffer = new internal.Buffer(numberOfBytes); | 615 this.buffer = new internal.Buffer(numberOfBytes); |
512 this.handles = []; | 616 this.handles = []; |
513 var encoder = this.createEncoder(kMessageWithRequestIDHeaderSize); | 617 var encoder = this.createEncoder(kMessageV1HeaderSize); |
514 encoder.writeUint32(kMessageWithRequestIDHeaderSize); | 618 encoder.writeUint32(kMessageV1HeaderSize); |
515 encoder.writeUint32(1); // version. | 619 encoder.writeUint32(1); // version. |
516 encoder.writeUint32(0); // interface ID. | 620 encoder.writeUint32(0); // interface ID. |
517 encoder.writeUint32(messageName); | 621 encoder.writeUint32(messageName); |
518 encoder.writeUint32(flags); | 622 encoder.writeUint32(flags); |
519 encoder.writeUint32(0); // padding. | 623 encoder.writeUint32(0); // padding. |
520 encoder.writeUint64(requestID); | 624 encoder.writeUint64(requestID); |
521 } | 625 } |
522 | 626 |
523 MessageV1Builder.prototype = | 627 MessageV1Builder.prototype = |
524 Object.create(MessageV0Builder.prototype); | 628 Object.create(MessageV0Builder.prototype); |
525 | 629 |
526 MessageV1Builder.prototype.constructor = | 630 MessageV1Builder.prototype.constructor = |
527 MessageV1Builder; | 631 MessageV1Builder; |
528 | 632 |
| 633 // MessageV2 ----------------------------------------------- |
| 634 |
| 635 function MessageV2Builder(messageName, payloadSize, flags, requestID) { |
| 636 // Currently, we don't compute the payload size correctly ahead of time. |
| 637 // Instead, we resize the buffer at the end. |
| 638 var numberOfBytes = kMessageV2HeaderSize + payloadSize; |
| 639 this.buffer = new internal.Buffer(numberOfBytes); |
| 640 this.handles = []; |
| 641 |
| 642 this.payload = null; |
| 643 this.associatedEndpointHandles = []; |
| 644 |
| 645 this.encoder = this.createEncoder(kMessageV2HeaderSize); |
| 646 this.encoder.writeUint32(kMessageV2HeaderSize); |
| 647 this.encoder.writeUint32(2); // version. |
| 648 // Gets set to an appropriate interfaceId for the endpoint by the Router. |
| 649 this.encoder.writeUint32(0); // interface ID. |
| 650 this.encoder.writeUint32(messageName); |
| 651 this.encoder.writeUint32(flags); |
| 652 this.encoder.writeUint32(0); // padding. |
| 653 this.encoder.writeUint64(requestID); |
| 654 } |
| 655 |
| 656 MessageV2Builder.prototype.createEncoder = function(size) { |
| 657 var pointer = this.buffer.alloc(size); |
| 658 return new Encoder(this.buffer, this.handles, |
| 659 this.associatedEndpointHandles, pointer); |
| 660 }; |
| 661 |
| 662 MessageV2Builder.prototype.setPayload = function(cls, val) { |
| 663 this.payload = {cls: cls, val: val}; |
| 664 }; |
| 665 |
| 666 MessageV2Builder.prototype.finish = function() { |
| 667 if (!this.payload) { |
| 668 throw new Error("Payload needs to be set before calling finish"); |
| 669 } |
| 670 |
| 671 this.encoder.encodeStructPointer(this.payload.cls, this.payload.val); |
| 672 this.encoder.encodeArrayPointer(Uint32, |
| 673 new Array(this.associatedEndpointHandles.length)); |
| 674 |
| 675 this.buffer.trim(); |
| 676 var message = new Message(this.buffer, this.handles, |
| 677 this.associatedEndpointHandles); |
| 678 this.buffer = null; |
| 679 this.handles = null; |
| 680 this.encoder = null; |
| 681 this.payload = null; |
| 682 this.associatedEndpointHandles = null; |
| 683 |
| 684 return message; |
| 685 }; |
| 686 |
529 // MessageReader ------------------------------------------------------------ | 687 // MessageReader ------------------------------------------------------------ |
530 | 688 |
531 function MessageReader(message) { | 689 function MessageReader(message) { |
532 this.decoder = new Decoder(message.buffer, message.handles, 0); | 690 this.decoder = new Decoder(message.buffer, message.handles, |
| 691 message.associatedEndpointHandles, 0); |
533 var messageHeaderSize = this.decoder.readUint32(); | 692 var messageHeaderSize = this.decoder.readUint32(); |
534 this.payloadSize = message.buffer.byteLength - messageHeaderSize; | 693 this.payloadSize = message.buffer.byteLength - messageHeaderSize; |
535 var version = this.decoder.readUint32(); | 694 var version = this.decoder.readUint32(); |
536 var interface_id = this.decoder.readUint32(); | 695 var interface_id = this.decoder.readUint32(); |
537 if (interface_id != 0) { | |
538 throw new Error("Receiving non-zero interface ID. Associated interfaces "
+ | |
539 "are not yet supported."); | |
540 } | |
541 this.messageName = this.decoder.readUint32(); | 696 this.messageName = this.decoder.readUint32(); |
542 this.flags = this.decoder.readUint32(); | 697 this.flags = this.decoder.readUint32(); |
543 // Skip the padding. | 698 // Skip the padding. |
544 this.decoder.skip(4); | 699 this.decoder.skip(4); |
545 if (version >= 1) | 700 if (version >= 1) |
546 this.requestID = this.decoder.readUint64(); | 701 this.requestID = this.decoder.readUint64(); |
547 this.decoder.skip(messageHeaderSize - this.decoder.next); | 702 this.decoder.skip(messageHeaderSize - this.decoder.next); |
548 } | 703 } |
549 | 704 |
550 MessageReader.prototype.decodeStruct = function(cls) { | 705 MessageReader.prototype.decodeStruct = function(cls) { |
(...skipping 273 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
824 encoder.encodeHandle(interfacePtrInfo.handle); | 979 encoder.encodeHandle(interfacePtrInfo.handle); |
825 encoder.writeUint32(interfacePtrInfo.version); | 980 encoder.writeUint32(interfacePtrInfo.version); |
826 }; | 981 }; |
827 | 982 |
828 function NullableInterface(cls) { | 983 function NullableInterface(cls) { |
829 Interface.call(this, cls); | 984 Interface.call(this, cls); |
830 } | 985 } |
831 | 986 |
832 NullableInterface.prototype = Object.create(Interface.prototype); | 987 NullableInterface.prototype = Object.create(Interface.prototype); |
833 | 988 |
| 989 function AssociatedInterfacePtrInfo() { |
| 990 } |
| 991 |
| 992 AssociatedInterfacePtrInfo.prototype.encodedSize = 8; |
| 993 |
| 994 AssociatedInterfacePtrInfo.decode = function(decoder) { |
| 995 return new mojo.AssociatedInterfacePtrInfo( |
| 996 decoder.decodeAssociatedEndpointHandle(), decoder.readUint32()); |
| 997 }; |
| 998 |
| 999 AssociatedInterfacePtrInfo.encode = function(encoder, val) { |
| 1000 var associatedinterfacePtrInfo = |
| 1001 val ? val : new mojo.AssociatedInterfacePtrInfo(null, 0); |
| 1002 encoder.encodeAssociatedEndpointHandle( |
| 1003 associatedinterfacePtrInfo.interfaceEndpointHandle); |
| 1004 encoder.writeUint32(associatedinterfacePtrInfo.version); |
| 1005 }; |
| 1006 |
| 1007 function NullableAssociatedInterfacePtrInfo() { |
| 1008 } |
| 1009 |
| 1010 NullableAssociatedInterfacePtrInfo.encodedSize = |
| 1011 AssociatedInterfacePtrInfo.encodedSize; |
| 1012 |
| 1013 NullableAssociatedInterfacePtrInfo.decode = |
| 1014 AssociatedInterfacePtrInfo.decode; |
| 1015 |
| 1016 NullableAssociatedInterfacePtrInfo.encode = |
| 1017 AssociatedInterfacePtrInfo.encode; |
| 1018 |
834 function InterfaceRequest() { | 1019 function InterfaceRequest() { |
835 } | 1020 } |
836 | 1021 |
837 InterfaceRequest.encodedSize = 4; | 1022 InterfaceRequest.encodedSize = 4; |
838 | 1023 |
839 InterfaceRequest.decode = function(decoder) { | 1024 InterfaceRequest.decode = function(decoder) { |
840 return new mojo.InterfaceRequest(decoder.decodeHandle()); | 1025 return new mojo.InterfaceRequest(decoder.decodeHandle()); |
841 }; | 1026 }; |
842 | 1027 |
843 InterfaceRequest.encode = function(encoder, val) { | 1028 InterfaceRequest.encode = function(encoder, val) { |
844 encoder.encodeHandle(val ? val.handle : null); | 1029 encoder.encodeHandle(val ? val.handle : null); |
845 }; | 1030 }; |
846 | 1031 |
847 function NullableInterfaceRequest() { | 1032 function NullableInterfaceRequest() { |
848 } | 1033 } |
849 | 1034 |
850 NullableInterfaceRequest.encodedSize = InterfaceRequest.encodedSize; | 1035 NullableInterfaceRequest.encodedSize = InterfaceRequest.encodedSize; |
851 | 1036 |
852 NullableInterfaceRequest.decode = InterfaceRequest.decode; | 1037 NullableInterfaceRequest.decode = InterfaceRequest.decode; |
853 | 1038 |
854 NullableInterfaceRequest.encode = InterfaceRequest.encode; | 1039 NullableInterfaceRequest.encode = InterfaceRequest.encode; |
855 | 1040 |
| 1041 function AssociatedInterfaceRequest() { |
| 1042 } |
| 1043 |
| 1044 AssociatedInterfaceRequest.decode = function(decoder) { |
| 1045 var handle = decoder.decodeAssociatedEndpointHandle(); |
| 1046 return new mojo.AssociatedInterfaceRequest(handle); |
| 1047 }; |
| 1048 |
| 1049 AssociatedInterfaceRequest.encode = function(encoder, val) { |
| 1050 encoder.encodeAssociatedEndpointHandle( |
| 1051 val ? val.interfaceEndpointHandle : null); |
| 1052 }; |
| 1053 |
| 1054 AssociatedInterfaceRequest.encodedSize = 4; |
| 1055 |
| 1056 function NullableAssociatedInterfaceRequest() { |
| 1057 } |
| 1058 |
| 1059 NullableAssociatedInterfaceRequest.encodedSize = |
| 1060 AssociatedInterfaceRequest.encodedSize; |
| 1061 |
| 1062 NullableAssociatedInterfaceRequest.decode = |
| 1063 AssociatedInterfaceRequest.decode; |
| 1064 |
| 1065 NullableAssociatedInterfaceRequest.encode = |
| 1066 AssociatedInterfaceRequest.encode; |
| 1067 |
856 function MapOf(keyClass, valueClass) { | 1068 function MapOf(keyClass, valueClass) { |
857 this.keyClass = keyClass; | 1069 this.keyClass = keyClass; |
858 this.valueClass = valueClass; | 1070 this.valueClass = valueClass; |
859 } | 1071 } |
860 | 1072 |
861 MapOf.prototype.encodedSize = 8; | 1073 MapOf.prototype.encodedSize = 8; |
862 | 1074 |
863 MapOf.prototype.decode = function(decoder) { | 1075 MapOf.prototype.decode = function(decoder) { |
864 return decoder.decodeMapPointer(this.keyClass, this.valueClass); | 1076 return decoder.decodeMapPointer(this.keyClass, this.valueClass); |
865 }; | 1077 }; |
866 | 1078 |
867 MapOf.prototype.encode = function(encoder, val) { | 1079 MapOf.prototype.encode = function(encoder, val) { |
868 encoder.encodeMapPointer(this.keyClass, this.valueClass, val); | 1080 encoder.encodeMapPointer(this.keyClass, this.valueClass, val); |
869 }; | 1081 }; |
870 | 1082 |
871 function NullableMapOf(keyClass, valueClass) { | 1083 function NullableMapOf(keyClass, valueClass) { |
872 MapOf.call(this, keyClass, valueClass); | 1084 MapOf.call(this, keyClass, valueClass); |
873 } | 1085 } |
874 | 1086 |
875 NullableMapOf.prototype = Object.create(MapOf.prototype); | 1087 NullableMapOf.prototype = Object.create(MapOf.prototype); |
876 | 1088 |
877 internal.align = align; | 1089 internal.align = align; |
878 internal.isAligned = isAligned; | 1090 internal.isAligned = isAligned; |
879 internal.Message = Message; | 1091 internal.Message = Message; |
880 internal.MessageV0Builder = MessageV0Builder; | 1092 internal.MessageV0Builder = MessageV0Builder; |
881 internal.MessageV1Builder = MessageV1Builder; | 1093 internal.MessageV1Builder = MessageV1Builder; |
| 1094 internal.MessageV2Builder = MessageV2Builder; |
882 internal.MessageReader = MessageReader; | 1095 internal.MessageReader = MessageReader; |
883 internal.kArrayHeaderSize = kArrayHeaderSize; | 1096 internal.kArrayHeaderSize = kArrayHeaderSize; |
884 internal.kMapStructPayloadSize = kMapStructPayloadSize; | 1097 internal.kMapStructPayloadSize = kMapStructPayloadSize; |
885 internal.kStructHeaderSize = kStructHeaderSize; | 1098 internal.kStructHeaderSize = kStructHeaderSize; |
886 internal.kEncodedInvalidHandleValue = kEncodedInvalidHandleValue; | 1099 internal.kEncodedInvalidHandleValue = kEncodedInvalidHandleValue; |
887 internal.kMessageHeaderSize = kMessageHeaderSize; | 1100 internal.kMessageV0HeaderSize = kMessageV0HeaderSize; |
888 internal.kMessageWithRequestIDHeaderSize = kMessageWithRequestIDHeaderSize; | 1101 internal.kMessageV1HeaderSize = kMessageV1HeaderSize; |
| 1102 internal.kMessageV2HeaderSize = kMessageV2HeaderSize; |
| 1103 internal.kMessagePayloadInterfaceIdsPointerOffset = |
| 1104 kMessagePayloadInterfaceIdsPointerOffset; |
889 internal.kMessageExpectsResponse = kMessageExpectsResponse; | 1105 internal.kMessageExpectsResponse = kMessageExpectsResponse; |
890 internal.kMessageIsResponse = kMessageIsResponse; | 1106 internal.kMessageIsResponse = kMessageIsResponse; |
891 internal.Int8 = Int8; | 1107 internal.Int8 = Int8; |
892 internal.Uint8 = Uint8; | 1108 internal.Uint8 = Uint8; |
893 internal.Int16 = Int16; | 1109 internal.Int16 = Int16; |
894 internal.Uint16 = Uint16; | 1110 internal.Uint16 = Uint16; |
895 internal.Int32 = Int32; | 1111 internal.Int32 = Int32; |
896 internal.Uint32 = Uint32; | 1112 internal.Uint32 = Uint32; |
897 internal.Int64 = Int64; | 1113 internal.Int64 = Int64; |
898 internal.Uint64 = Uint64; | 1114 internal.Uint64 = Uint64; |
899 internal.Float = Float; | 1115 internal.Float = Float; |
900 internal.Double = Double; | 1116 internal.Double = Double; |
901 internal.String = String; | 1117 internal.String = String; |
902 internal.Enum = Enum; | 1118 internal.Enum = Enum; |
903 internal.NullableString = NullableString; | 1119 internal.NullableString = NullableString; |
904 internal.PointerTo = PointerTo; | 1120 internal.PointerTo = PointerTo; |
905 internal.NullablePointerTo = NullablePointerTo; | 1121 internal.NullablePointerTo = NullablePointerTo; |
906 internal.ArrayOf = ArrayOf; | 1122 internal.ArrayOf = ArrayOf; |
907 internal.NullableArrayOf = NullableArrayOf; | 1123 internal.NullableArrayOf = NullableArrayOf; |
908 internal.PackedBool = PackedBool; | 1124 internal.PackedBool = PackedBool; |
909 internal.Handle = Handle; | 1125 internal.Handle = Handle; |
910 internal.NullableHandle = NullableHandle; | 1126 internal.NullableHandle = NullableHandle; |
911 internal.Interface = Interface; | 1127 internal.Interface = Interface; |
912 internal.NullableInterface = NullableInterface; | 1128 internal.NullableInterface = NullableInterface; |
913 internal.InterfaceRequest = InterfaceRequest; | 1129 internal.InterfaceRequest = InterfaceRequest; |
914 internal.NullableInterfaceRequest = NullableInterfaceRequest; | 1130 internal.NullableInterfaceRequest = NullableInterfaceRequest; |
| 1131 internal.AssociatedInterfacePtrInfo = AssociatedInterfacePtrInfo; |
| 1132 internal.NullableAssociatedInterfacePtrInfo = |
| 1133 NullableAssociatedInterfacePtrInfo; |
| 1134 internal.AssociatedInterfaceRequest = AssociatedInterfaceRequest; |
| 1135 internal.NullableAssociatedInterfaceRequest = |
| 1136 NullableAssociatedInterfaceRequest; |
915 internal.MapOf = MapOf; | 1137 internal.MapOf = MapOf; |
916 internal.NullableMapOf = NullableMapOf; | 1138 internal.NullableMapOf = NullableMapOf; |
917 })(); | 1139 })(); |
OLD | NEW |