| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| part of bindings; |
| |
| int align(int size) => size + (kAlignment - (size % kAlignment)) % kAlignment; |
| |
| const int kAlignment = 8; |
| const int kSerializedHandleSize = 4; |
| const int kPointerSize = 8; |
| // TODO(yzshen): In order to work with other bindings which still interprets |
| // the |version| field as |num_fields|, set it to version 2 for now. |
| const StructDataHeader kMapStructHeader = const StructDataHeader(24, 2); |
| const int kUnspecifiedArrayLength = -1; |
| const int kNothingNullable = 0; |
| const int kArrayNullable = (1 << 0); |
| const int kElementNullable = (1 << 1); |
| |
| bool isArrayNullable(int nullability) => (nullability & kArrayNullable) > 0; |
| bool isElementNullable(int nullability) => (nullability & kElementNullable) > 0; |
| |
| class StructDataHeader { |
| static const int kHeaderSize = 8; |
| static const int kSizeOffset = 0; |
| static const int kVersionOffset = 4; |
| final int size; |
| final int version; |
| |
| const StructDataHeader(this.size, this.version); |
| |
| String toString() => "StructDataHeader($size, $version)"; |
| } |
| |
| class ArrayDataHeader { |
| static const int kHeaderSize = 8; |
| static const int kSizeOffset = 0; |
| static const int kNumElementsOffset = 4; |
| final int size; |
| final int numElements; |
| |
| const ArrayDataHeader(this.size, this.numElements); |
| |
| String toString() => "ArrayDataHeader($size, $numElements)"; |
| } |
| |
| class MojoCodecError { |
| final String message; |
| MojoCodecError(this.message); |
| String toString() => message; |
| } |
| |
| class _EncoderBuffer { |
| ByteData buffer; |
| List<core.MojoHandle> handles; |
| int extent; |
| |
| static const int kInitialBufferSize = 1024; |
| |
| _EncoderBuffer([int size = -1]) : |
| buffer = new ByteData(size > 0 ? size : kInitialBufferSize), |
| handles = [], |
| extent = 0; |
| |
| void _grow(int newSize) { |
| Uint8List newBuffer = new Uint8List(newSize); |
| newBuffer.setRange(0, buffer.lengthInBytes, buffer.buffer.asUint8List()); |
| buffer = newBuffer.buffer.asByteData(); |
| } |
| |
| void claimMemory(int claimSize) { |
| extent += claimSize; |
| if (extent > buffer.lengthInBytes) { |
| int newSize = buffer.lengthInBytes + claimSize; |
| newSize += newSize ~/ 2; |
| _grow(newSize); |
| } |
| } |
| |
| ByteData get trimmed => new ByteData.view(buffer.buffer, 0, extent); |
| } |
| |
| class Encoder { |
| _EncoderBuffer _buffer; |
| int _base; |
| |
| Encoder([int size = -1]) : _buffer = new _EncoderBuffer(size), _base = 0; |
| |
| Encoder._fromBuffer(_EncoderBuffer buffer) : |
| _buffer = buffer, |
| _base = buffer.extent; |
| |
| Encoder getStructEncoderAtOffset(StructDataHeader dataHeader) { |
| var result = new Encoder._fromBuffer(_buffer); |
| result.encodeStructDataHeader(dataHeader); |
| return result; |
| } |
| |
| Encoder getArrayEncoderAtOffset(ArrayDataHeader dataHeader) { |
| var result = new Encoder._fromBuffer(_buffer); |
| result.encodeArrayDataHeader(dataHeader); |
| return result; |
| } |
| |
| Message get message => new Message(_buffer.trimmed, _buffer.handles); |
| |
| void encodeStructDataHeader(StructDataHeader dataHeader) { |
| _buffer.claimMemory(align(dataHeader.size)); |
| encodeUint32(dataHeader.size, StructDataHeader.kSizeOffset); |
| encodeUint32(dataHeader.version, StructDataHeader.kVersionOffset); |
| } |
| |
| void encodeArrayDataHeader(ArrayDataHeader dataHeader) { |
| _buffer.claimMemory(align(dataHeader.size)); |
| encodeUint32(dataHeader.size, ArrayDataHeader.kSizeOffset); |
| encodeUint32(dataHeader.numElements, ArrayDataHeader.kNumElementsOffset); |
| } |
| |
| static const String kErrorUnsigned = |
| 'Passing negative value to unsigned encoder'; |
| |
| void encodeBool(bool value, int offset, int bit) { |
| if (value) { |
| int encodedValue = _buffer.buffer.getUint8(_base + offset); |
| encodedValue |= (1 << bit); |
| _buffer.buffer.setUint8(_base + offset, encodedValue); |
| } |
| } |
| |
| void encodeInt8(int value, int offset) => |
| _buffer.buffer.setInt8(_base + offset, value); |
| |
| void encodeUint8(int value, int offset) { |
| if (value < 0) { |
| throw new MojoCodecError('$kErrorUnsigned: $val'); |
| } |
| _buffer.buffer.setUint8(_base + offset, value); |
| } |
| |
| void encodeInt16(int value, int offset) => |
| _buffer.buffer.setInt16(_base + offset, value, Endianness.LITTLE_ENDIAN); |
| |
| void encodeUint16(int value, int offset) { |
| if (value < 0) { |
| throw new MojoCodecError('$kErrorUnsigned: $val'); |
| } |
| _buffer.buffer.setUint16(_base + offset, value, Endianness.LITTLE_ENDIAN); |
| } |
| |
| void encodeInt32(int value, int offset) => |
| _buffer.buffer.setInt32(_base + offset, value, Endianness.LITTLE_ENDIAN); |
| |
| void encodeUint32(int value, int offset) { |
| if (value < 0) { |
| throw new MojoCodecError('$kErrorUnsigned: $val'); |
| } |
| _buffer.buffer.setUint32(_base + offset, value, Endianness.LITTLE_ENDIAN); |
| } |
| |
| void encodeInt64(int value, int offset) => |
| _buffer.buffer.setInt64(_base + offset, value, Endianness.LITTLE_ENDIAN); |
| |
| void encodeUint64(int value, int offset) { |
| if (value < 0) { |
| throw new MojoCodecError('$kErrorUnsigned: $val'); |
| } |
| _buffer.buffer.setUint64(_base + offset, value, Endianness.LITTLE_ENDIAN); |
| } |
| |
| void encodeFloat(double value, int offset) => |
| _buffer.buffer.setFloat32(_base + offset, value, Endianness.LITTLE_ENDIAN); |
| |
| void encodeDouble(double value, int offset) => |
| _buffer.buffer.setFloat64(_base + offset, value, Endianness.LITTLE_ENDIAN); |
| |
| void encodeHandle(core.MojoHandle value, int offset, bool nullable) { |
| if ((value == null) || !value.isValid) { |
| encodeInvalideHandle(offset, nullable); |
| } else { |
| encodeUint32(_buffer.handles.length, offset); |
| _buffer.handles.add(value); |
| } |
| } |
| |
| void encodeMessagePipeHandle( |
| core.MojoMessagePipeEndpoint value, int offset, bool nullable) => |
| encodeHandle(value != null ? value.handle : null, offset, nullable); |
| |
| void encodeConsumerHandle( |
| core.MojoDataPipeConsumer value, int offset, bool nullable) => |
| encodeHandle(value != null ? value.handle : null, offset, nullable); |
| |
| void encodeProducerHandle( |
| core.MojoDataPipeProducer value, int offset, bool nullable) => |
| encodeHandle(value != null ? value.handle : null, offset, nullable); |
| |
| void encodeSharedBufferHandle( |
| core.MojoSharedBuffer value, int offset, bool nullable) => |
| encodeHandle(value != null ? value.handle : null, offset, nullable); |
| |
| void encodeInterface(Stub interface, int offset, bool nullable) { |
| if (interface == null) { |
| encodeInvalideHandle(offset, nullable); |
| return; |
| } |
| var pipe = new core.MojoMessagePipe(); |
| interface.bind(pipe.endpoints[0]); |
| encodeMessagePipeHandle(pipe.endpoints[1], offset, nullable); |
| } |
| |
| void encodeInterfaceRequest(Proxy client, int offset, bool nullable) { |
| if (client == null) { |
| encodeInvalideHandle(offset, nullable); |
| return; |
| } |
| var pipe = new core.MojoMessagePipe(); |
| client.bind(pipe.endpoints[0]); |
| encodeMessagePipeHandle(pipe.endpoints[1], offset, nullable); |
| } |
| |
| void encodeNullPointer(int offset, bool nullable) { |
| if (!nullable) { |
| throw new MojoCodecError( |
| 'Trying to encode a null pointer for a non-nullable type'); |
| } |
| _buffer.buffer.setUint64(_base + offset, 0, Endianness.LITTLE_ENDIAN); |
| } |
| |
| void encodeInvalideHandle(int offset, bool nullable) { |
| if (!nullable) { |
| throw new MojoCodecError( |
| 'Trying to encode a null pointer for a non-nullable type'); |
| } |
| _buffer.buffer.setInt32(_base + offset, -1, Endianness.LITTLE_ENDIAN); |
| } |
| |
| void encodePointerToNextUnclaimed(int offset) => |
| encodeUint64(_buffer.extent - (_base + offset), offset); |
| |
| void encodeStruct(Struct value, int offset, bool nullable) { |
| if (value == null) { |
| encodeNullPointer(offset, nullable); |
| return; |
| } |
| encodePointerToNextUnclaimed(offset); |
| value.encode(this); |
| } |
| |
| Encoder encodePointerArray(int length, int offset, int expectedLength) => |
| encoderForArray(kPointerSize, length, offset, expectedLength); |
| |
| Encoder encoderForArray( |
| int elementSize, int length, int offset, int expectedLength) { |
| if ((expectedLength != kUnspecifiedArrayLength) && |
| (expectedLength != length)) { |
| throw new MojoCodecError( |
| 'Trying to encode a fixed array of incorrect length'); |
| } |
| return encoderForArrayByTotalSize(length * elementSize, length, offset); |
| } |
| |
| Encoder encoderForArrayByTotalSize(int size, int length, int offset) { |
| encodePointerToNextUnclaimed(offset); |
| return getArrayEncoderAtOffset( |
| new ArrayDataHeader(ArrayDataHeader.kHeaderSize + size, length)); |
| } |
| |
| void encodeBoolArray( |
| List<bool> value, int offset, int nullability, int expectedLength) { |
| if (value == null) { |
| encodeNullPointer(offset, isArrayNullable(nullability)); |
| return; |
| } |
| if ((expectedLength != kUnspecifiedArrayLength) && |
| (expectedLength != value.length)) { |
| throw new MojoCodecError( |
| 'Trying to encode a fixed array of incorrect size.'); |
| } |
| var bytes = new Uint8List((value.length + 7) ~/ kAlignment); |
| for (int i = 0; i < bytes.length; ++i) { |
| for (int j = 0; j < kAlignment; ++j) { |
| int boolIndex = kAlignment * i + j; |
| if ((boolIndex < value.length) && value[boolIndex]) { |
| bytes[i] |= (1 << j); |
| } |
| } |
| } |
| var encoder = encoderForArrayByTotalSize( |
| bytes.length, value.length, offset); |
| encoder.appendUint8Array(bytes); |
| } |
| |
| void encodeArray(Function arrayAppend, |
| int elementBytes, |
| List<int> value, |
| int offset, |
| int nullability, |
| int expectedLength) { |
| if (value == null) { |
| encodeNullPointer(offset, isArrayNullable(nullability)); |
| return; |
| } |
| var encoder = encoderForArray( |
| elementBytes, value.length, offset, expectedLength); |
| arrayAppend(encoder, value); |
| } |
| |
| void encodeInt8Array( |
| List<int> value, int offset, int nullability, int expectedLength) => |
| encodeArray((e, v) => e.appendInt8Array(v), |
| 1, value, offset, nullability, expectedLength); |
| |
| void encodeUint8Array( |
| List<int> value, int offset, int nullability, int expectedLength) => |
| encodeArray((e, v) => e.appendUint8Array(v), |
| 1, value, offset, nullability, expectedLength); |
| |
| void encodeInt16Array( |
| List<int> value, int offset, int nullability, int expectedLength) => |
| encodeArray((e, v) => e.appendInt16Array(v), |
| 2, value, offset, nullability, expectedLength); |
| |
| void encodeUint16Array( |
| List<int> value, int offset, int nullability, int expectedLength) => |
| encodeArray((e, v) => e.appendUint16Array(v), |
| 2, value, offset, nullability, expectedLength); |
| |
| void encodeInt32Array( |
| List<int> value, int offset, int nullability, int expectedLength) => |
| encodeArray((e, v) => e.appendInt32Array(v), |
| 4, value, offset, nullability, expectedLength); |
| |
| void encodeUint32Array( |
| List<int> value, int offset, int nullability, int expectedLength) => |
| encodeArray((e, v) => e.appendUint32Array(v), |
| 4, value, offset, nullability, expectedLength); |
| |
| void encodeInt64Array( |
| List<int> value, int offset, int nullability, int expectedLength) => |
| encodeArray((e, v) => e.appendInt64Array(v), |
| 8, value, offset, nullability, expectedLength); |
| |
| void encodeUint64Array( |
| List<int> value, int offset, int nullability, int expectedLength) => |
| encodeArray((e, v) => e.appendUint64Array(v), |
| 8, value, offset, nullability, expectedLength); |
| |
| void encodeFloatArray( |
| List<int> value, int offset, int nullability, int expectedLength) => |
| encodeArray((e, v) => e.appendFloatArray(v), |
| 4, value, offset, nullability, expectedLength); |
| |
| void encodeDoubleArray( |
| List<int> value, int offset, int nullability, int expectedLength) => |
| encodeArray((e, v) => e.appendDoubleArray(v), |
| 8, value, offset, nullability, expectedLength); |
| |
| void _handleArrayEncodeHelper(Function elementEncoder, |
| List value, |
| int offset, |
| int nullability, |
| int expectedLength) { |
| if (value == null) { |
| encodeNullPointer(offset, isArrayNullable(nullability)); |
| return; |
| } |
| var encoder = encoderForArray( |
| kSerializedHandleSize, value.length, offset, expectedLength); |
| for (int i = 0; i < value.length; ++i) { |
| int handleOffset = |
| ArrayDataHeader.kHeaderSize + kSerializedHandleSize * i; |
| elementEncoder( |
| encoder, value[i], handleOffset, isElementNullable(nullability)); |
| } |
| } |
| |
| void encodeHandleArray( |
| List<core.MojoHandle> value, |
| int offset, |
| int nullability, |
| int expectedLength) => |
| _handleArrayEncodeHelper( |
| (e, v, o, n) => e.encodeHandle(v, o, n), |
| value, offset, nullability, expectedLength); |
| |
| void encodeMessagePipeHandleArray( |
| List<core.MojoMessagePipeEndpoint> value, |
| int offset, |
| int nullability, |
| int expectedLength) => |
| _handleArrayEncodeHelper( |
| (e, v, o, n) => e.encodeMessagePipeHandle(v, o, n), |
| value, offset, nullability, expectedLength); |
| |
| void encodeConsumerHandleArray( |
| List<core.MojoDataPipeConsumer> value, |
| int offset, |
| int nullability, |
| int expectedLength) => |
| _handleArrayEncodeHelper( |
| (e, v, o, n) => e.encodeConsumerHandle(v, o, n), |
| value, offset, nullability, expectedLength); |
| |
| void encodeProducerHandleArray( |
| List<core.MojoDataPipeProducer> value, |
| int offset, |
| int nullability, |
| int expectedLength) => |
| _handleArrayEncodeHelper( |
| (e, v, o, n) => e.encodeProducerHandle(v, o, n), |
| value, offset, nullability, expectedLength); |
| |
| void encodeSharedBufferHandleArray( |
| List<core.MojoSharedBuffer> value, |
| int offset, |
| int nullability, |
| int expectedLength) => |
| _handleArrayEncodeHelper( |
| (e, v, o, n) => e.encodeSharedBufferHandle(v, o, n), |
| value, offset, nullability, expectedLength); |
| |
| void encodeInterfaceRequestArray( |
| List<Proxy> value, |
| int offset, |
| int nullability, |
| int expectedLength) => |
| _handleArrayEncodeHelper( |
| (e, v, o, n) => e.encodeInterfaceRequest(v, o, n), |
| value, offset, nullability, expectedLength); |
| |
| void encodeInterfaceArray( |
| List<Stub> value, |
| int offset, |
| int nullability, |
| int expectedLength) => |
| _handleArrayEncodeHelper( |
| (e, v, o, n) => e.encodeInterface(v, o, n), |
| value, offset, nullability, expectedLength); |
| |
| static Uint8List _utf8OfString(String s) => |
| (new Uint8List.fromList((const Utf8Encoder()).convert(s))); |
| |
| void encodeString(String value, int offset, bool nullable) { |
| if (value == null) { |
| encodeNullPointer(offset, nullable); |
| return; |
| } |
| int nullability = nullable ? kArrayNullable : kNothingNullable; |
| encodeUint8Array(_utf8OfString(value), |
| offset, |
| nullability, |
| kUnspecifiedArrayLength); |
| } |
| |
| void appendBytes(Uint8List value) { |
| _buffer.buffer.buffer.asUint8List().setRange( |
| _base + ArrayDataHeader.kHeaderSize, |
| _base + ArrayDataHeader.kHeaderSize + value.lengthInBytes, |
| value); |
| } |
| |
| void appendInt8Array(List<int> value) => |
| appendBytes(new Uint8List.view(new Int8List.fromList(value).buffer)); |
| |
| void appendUint8Array(List<int> value) => |
| appendBytes(new Uint8List.fromList(value)); |
| |
| void appendInt16Array(List<int> value) => |
| appendBytes(new Uint8List.view(new Int16List.fromList(value).buffer)); |
| |
| void appendUint16Array(List<int> value) => |
| appendBytes(new Uint8List.view(new Uint16List.fromList(value).buffer)); |
| |
| void appendInt32Array(List<int> value) => |
| appendBytes(new Uint8List.view(new Int32List.fromList(value).buffer)); |
| |
| void appendUint32Array(List<int> value) => |
| appendBytes(new Uint8List.view(new Uint32List.fromList(value).buffer)); |
| |
| void appendInt64Array(List<int> value) => |
| appendBytes(new Uint8List.view(new Int64List.fromList(value).buffer)); |
| |
| void appendUint64Array(List<int> value) => |
| appendBytes(new Uint8List.view(new Uint64List.fromList(value).buffer)); |
| |
| void appendFloatArray(List<int> value) => |
| appendBytes(new Uint8List.view(new Float32List.fromList(value).buffer)); |
| |
| void appendDoubleArray(List<int> value) => |
| appendBytes(new Uint8List.view(new Float64List.fromList(value).buffer)); |
| |
| Encoder encoderForMap(int offset) { |
| encodePointerToNextUnclaimed(offset); |
| return getStructEncoderAtOffset(kMapStructHeader); |
| } |
| } |
| |
| |
| class _Validator { |
| final int _maxMemory; |
| final int _numberOfHandles; |
| int _minNextClaimedHandle = 0; |
| int _minNextMemory = 0; |
| |
| _Validator(this._maxMemory, this._numberOfHandles); |
| |
| void claimHandle(int handle) { |
| if (handle < _minNextClaimedHandle) { |
| throw new MojoCodecError('Trying to access handle out of order.'); |
| } |
| if (handle >= _numberOfHandles) { |
| throw new MojoCodecError('Trying to access non present handle.'); |
| } |
| _minNextClaimedHandle = handle + 1; |
| } |
| |
| void claimMemory(int start, int end) { |
| if ((start % kAlignment) != 0) { |
| throw new MojoCodecError('Incorrect starting alignment: $start.'); |
| } |
| if (start < _minNextMemory) { |
| throw new MojoCodecError('Trying to access memory out of order.'); |
| } |
| if (end < start) { |
| throw new MojoCodecError('Incorrect memory range.'); |
| } |
| if (end > _maxMemory) { |
| throw new MojoCodecError('Trying to access out of range memory.'); |
| } |
| _minNextMemory = align(end); |
| } |
| } |
| |
| |
| class Decoder { |
| _Validator _validator; |
| Message _message; |
| int _base = 0; |
| |
| Decoder(this._message, [this._base = 0, this._validator = null]) { |
| if (_validator == null) { |
| _validator = new _Validator( |
| _message.buffer.lengthInBytes, _message.handles.length); |
| } |
| } |
| |
| Decoder getDecoderAtPosition(int offset) => |
| new Decoder(_message, offset, _validator); |
| |
| factory Decoder.atOffset(Decoder d, int offset, _Validator validator) => |
| new Decoder(d._message, offset, validator); |
| |
| ByteData get _buffer => _message.buffer; |
| List<core.MojoHandle> get _handles => _message.handles; |
| |
| int decodeInt8(int offset) => _buffer.getInt8(_base + offset); |
| int decodeUint8(int offset) => _buffer.getUint8(_base + offset); |
| int decodeInt16(int offset) => |
| _buffer.getInt16(_base + offset, Endianness.LITTLE_ENDIAN); |
| int decodeUint16(int offset) => |
| _buffer.getUint16(_base + offset, Endianness.LITTLE_ENDIAN); |
| int decodeInt32(int offset) => |
| _buffer.getInt32(_base + offset, Endianness.LITTLE_ENDIAN); |
| int decodeUint32(int offset) => |
| _buffer.getUint32(_base + offset, Endianness.LITTLE_ENDIAN); |
| int decodeInt64(int offset) => |
| _buffer.getInt64(_base + offset, Endianness.LITTLE_ENDIAN); |
| int decodeUint64(int offset) => |
| _buffer.getUint64(_base + offset,Endianness.LITTLE_ENDIAN); |
| double decodeFloat(int offset) => |
| _buffer.getFloat32(_base + offset, Endianness.LITTLE_ENDIAN); |
| double decodeDouble(int offset) => |
| _buffer.getFloat64(_base + offset, Endianness.LITTLE_ENDIAN); |
| |
| bool decodeBool(int offset, int bit) => |
| (decodeUint8(offset) & (1 << bit)) != 0; |
| |
| core.MojoHandle decodeHandle(int offset, bool nullable) { |
| int index = decodeInt32(offset); |
| if (index == -1) { |
| if (!nullable) { |
| throw new MojoCodecError( |
| 'Trying to decode an invalid handle from a non-nullable type.'); |
| } |
| return new core.MojoHandle(core.MojoHandle.INVALID); |
| } |
| _validator.claimHandle(index); |
| return _handles[index]; |
| } |
| |
| core.MojoMessagePipeEndpoint decodeMessagePipeHandle( |
| int offset, bool nullable) => |
| new core.MojoMessagePipeEndpoint(decodeHandle(offset, nullable)); |
| |
| core.MojoDataPipeConsumer decodeConsumerHandle(int offset, bool nullable) => |
| new core.MojoDataPipeConsumer(decodeHandle(offset, nullable)); |
| |
| core.MojoDataPipeProducer decodeProducerHandle(int offset, bool nullable) => |
| new core.MojoDataPipeProducer(decodeHandle(offset, nullable)); |
| |
| core.MojoSharedBuffer decodeSharedBufferHandle(int offset, bool nullable) => |
| new core.MojoSharedBuffer(decodeHandle(offset, nullable)); |
| |
| Proxy decodeServiceInterface( |
| int offset, bool nullable, Function clientFactory) { |
| var endpoint = decodeMessagePipeHandle(offset, nullable); |
| return endpoint.handle.isValid ? clientFactory(endpoint) : null; |
| } |
| |
| Stub decodeInterfaceRequest( |
| int offset, bool nullable, Function interfaceFactory) { |
| var endpoint = decodeMessagePipeHandle(offset, nullable); |
| return endpoint.handle.isValid ? interfaceFactory(endpoint) : null; |
| } |
| |
| Decoder decodePointer(int offset, bool nullable) { |
| int basePosition = _base + offset; |
| int pointerOffset = decodeUint64(offset); |
| if (pointerOffset == 0) { |
| if (!nullable) { |
| throw new MojoCodecError( |
| 'Trying to decode a null pointer for a non-nullable type'); |
| } |
| return null; |
| } |
| int newPosition = (basePosition + pointerOffset); |
| return new Decoder.atOffset(this, newPosition, _validator); |
| } |
| |
| StructDataHeader decodeStructDataHeader() { |
| _validator.claimMemory(_base, _base + StructDataHeader.kHeaderSize); |
| int size = decodeUint32(StructDataHeader.kSizeOffset); |
| int version = decodeUint32(StructDataHeader.kVersionOffset); |
| if (size < 0) { |
| throw new MojoCodecError('Negative size.'); |
| } |
| if (version < 0) { |
| throw new MojoCodecError('Negative version number.'); |
| } |
| _validator.claimMemory(_base + StructDataHeader.kHeaderSize, _base + size); |
| return new StructDataHeader(size, version); |
| } |
| |
| ArrayDataHeader decodeArrayDataHeader() { |
| _validator.claimMemory(_base, _base + ArrayDataHeader.kHeaderSize); |
| int size = decodeUint32(ArrayDataHeader.kSizeOffset); |
| int numElements = decodeUint32(ArrayDataHeader.kNumElementsOffset); |
| if (size < 0) { |
| throw new MojoCodecError('Negative size.'); |
| } |
| if (numElements < 0) { |
| throw new MojoCodecError('Negative number of elements.'); |
| } |
| _validator.claimMemory(_base + ArrayDataHeader.kHeaderSize, _base + size); |
| return new ArrayDataHeader(size, numElements); |
| } |
| |
| // Decode arrays. |
| ArrayDataHeader decodeDataHeaderForBoolArray(int expectedLength) { |
| var header = decodeArrayDataHeader(); |
| var arrayByteCount = |
| ArrayDataHeader.kHeaderSize + (header.numElements + 7) ~/ 8; |
| if (header.size < arrayByteCount) { |
| throw new MojoCodecError('Array header is incorrect'); |
| } |
| if ((expectedLength != kUnspecifiedArrayLength) && |
| (header.numElements != expectedLength)) { |
| throw new MojoCodecError( |
| 'Incorrect array length. Expected $expectedLength, but got ' |
| '${header.numElements}.'); |
| } |
| return header; |
| } |
| |
| List<bool> decodeBoolArray(int offset, int nullability, int expectedLength) { |
| Decoder d = decodePointer(offset, isArrayNullable(nullability)); |
| if (d == null) { |
| return null; |
| } |
| var header = d.decodeDataHeaderForBoolArray(expectedLength); |
| var bytes = new Uint8List.view( |
| d._buffer.buffer, |
| d._buffer.offsetInBytes + d._base + ArrayDataHeader.kHeaderSize, |
| (header.numElements + 7) ~/ kAlignment); |
| var result = new List<bool>(header.numElements); |
| for (int i = 0; i < bytes.lengthInBytes; ++i) { |
| for (int j = 0; j < kAlignment; ++j) { |
| int boolIndex = i * kAlignment + j; |
| if (boolIndex < result.length) { |
| result[boolIndex] = (bytes[i] & (1 << j)) != 0; |
| } |
| } |
| } |
| return result; |
| } |
| |
| ArrayDataHeader decodeDataHeaderForArray(int elementSize, |
| int expectedLength) { |
| var header = decodeArrayDataHeader(); |
| var arrayByteCount = |
| ArrayDataHeader.kHeaderSize + header.numElements * elementSize; |
| if (header.size < arrayByteCount) { |
| throw new MojoCodecError( |
| 'Array header is incorrect: $header, elementSize = $elementSize'); |
| } |
| if ((expectedLength != kUnspecifiedArrayLength) && |
| (header.numElements != expectedLength)) { |
| throw new MojoCodecError( |
| 'Incorrect array length. Expected $expectedLength, but got ' |
| '${header.numElements}'); |
| } |
| return header; |
| } |
| |
| ArrayDataHeader decodeDataHeaderForPointerArray(int expectedLength) => |
| decodeDataHeaderForArray(kPointerSize, expectedLength); |
| |
| List decodeArray(Function arrayViewer, |
| int elementSize, |
| int offset, |
| int nullability, |
| int expectedLength) { |
| Decoder d = decodePointer(offset, isArrayNullable(nullability)); |
| if (d == null) { |
| return null; |
| } |
| var header = d.decodeDataHeaderForArray(elementSize, expectedLength); |
| return arrayViewer( |
| d._buffer.buffer, |
| d._buffer.offsetInBytes + d._base + ArrayDataHeader.kHeaderSize, |
| header.numElements); |
| } |
| |
| List<int> decodeInt8Array( |
| int offset, int nullability, int expectedLength) => |
| decodeArray((b, s, l) => new Int8List.view(b, s, l), |
| 1, offset, nullability, expectedLength); |
| |
| List<int> decodeUint8Array( |
| int offset, int nullability, int expectedLength) => |
| decodeArray((b, s, l) => new Uint8List.view(b, s, l), |
| 1, offset, nullability, expectedLength); |
| |
| List<int> decodeInt16Array( |
| int offset, int nullability, int expectedLength) => |
| decodeArray((b, s, l) => new Int16List.view(b, s, l), |
| 2, offset, nullability, expectedLength); |
| |
| List<int> decodeUint16Array( |
| int offset, int nullability, int expectedLength) => |
| decodeArray((b, s, l) => new Uint16List.view(b, s, l), |
| 2, offset, nullability, expectedLength); |
| |
| List<int> decodeInt32Array( |
| int offset, int nullability, int expectedLength) => |
| decodeArray((b, s, l) => new Int32List.view(b, s, l), |
| 4, offset, nullability, expectedLength); |
| |
| List<int> decodeUint32Array( |
| int offset, int nullability, int expectedLength) => |
| decodeArray((b, s, l) => new Uint32List.view(b, s, l), |
| 4, offset, nullability, expectedLength); |
| |
| List<int> decodeInt64Array( |
| int offset, int nullability, int expectedLength) => |
| decodeArray((b, s, l) => new Int64List.view(b, s, l), |
| 8, offset, nullability, expectedLength); |
| |
| List<int> decodeUint64Array( |
| int offset, int nullability, int expectedLength) => |
| decodeArray((b, s, l) => new Uint64List.view(b, s, l), |
| 8, offset, nullability, expectedLength); |
| |
| List<double> decodeFloatArray( |
| int offset, int nullability, int expectedLength) => |
| decodeArray((b, s, l) => new Float32List.view(b, s, l), |
| 4, offset, nullability, expectedLength); |
| |
| List<double> decodeDoubleArray( |
| int offset, int nullability, int expectedLength) => |
| decodeArray((b, s, l) => new Float64List.view(b, s, l), |
| 8, offset, nullability, expectedLength); |
| |
| List _handleArrayDecodeHelper(Function elementDecoder, |
| int offset, |
| int nullability, |
| int expectedLength) { |
| Decoder d = decodePointer(offset, isArrayNullable(nullability)); |
| if (d == null) { |
| return null; |
| } |
| var header = d.decodeDataHeaderForArray(4, expectedLength); |
| var result = new List(header.numElements); |
| for (int i = 0; i < result.length; ++i) { |
| result[i] = elementDecoder( |
| d, |
| ArrayDataHeader.kHeaderSize + kSerializedHandleSize * i, |
| isElementNullable(nullability)); |
| } |
| return result; |
| |
| } |
| |
| List<core.MojoHandle> decodeHandleArray( |
| int offset, int nullability, int expectedLength) => |
| _handleArrayDecodeHelper((d, o, n) => d.decodeHandle(o, n), |
| offset, nullability, expectedLength); |
| |
| List<core.MojoDataPipeConsumer> decodeConsumerHandleArray( |
| int offset, int nullability, int expectedLength) => |
| _handleArrayDecodeHelper((d, o, n) => d.decodeConsumerHandle(o, n), |
| offset, nullability, expectedLength); |
| |
| List<core.MojoDataPipeProducer> decodeProducerHandleArray( |
| int offset, int nullability, int expectedLength) => |
| _handleArrayDecodeHelper((d, o, n) => d.decodeProducerHandle(o, n), |
| offset, nullability, expectedLength); |
| |
| List<core.MojoMessagePipeEndpoint> decodeMessagePipeHandleArray( |
| int offset, int nullability, int expectedLength) => |
| _handleArrayDecodeHelper((d, o, n) => d.decodeMessagePipeHandle(o, n), |
| offset, nullability, expectedLength); |
| |
| List<core.MojoSharedBuffer> decodeSharedBufferHandleArray( |
| int offset, int nullability, int expectedLength) => |
| _handleArrayDecodeHelper((d, o, n) => d.decodeSharedBufferHandle(o, n), |
| offset, nullability, expectedLength); |
| |
| List<Stub> decodeInterfaceRequestArray( |
| int offset, |
| int nullability, |
| int expectedLength, |
| Function interfaceFactory) => |
| _handleArrayDecodeHelper( |
| (d, o, n) => d.decodeInterfaceRequest(o, n, interfaceFactory), |
| offset, nullability, expectedLength); |
| |
| List<Proxy> decodeServiceInterfaceArray( |
| int offset, |
| int nullability, |
| int expectedLength, |
| Function clientFactory) => |
| _handleArrayDecodeHelper( |
| (d, o, n) => d.decodeServiceInterface(o, n, clientFactory), |
| offset, nullability, expectedLength); |
| |
| static String _stringOfUtf8(Uint8List bytes) => |
| (const Utf8Decoder()).convert(bytes.toList()); |
| |
| String decodeString(int offset, bool nullable) { |
| int nullability = nullable ? kArrayNullable : 0; |
| var bytes = decodeUint8Array(offset, nullability, kUnspecifiedArrayLength); |
| if (bytes == null) { |
| return null; |
| } |
| return _stringOfUtf8(bytes); |
| } |
| |
| StructDataHeader decodeDataHeaderForMap() { |
| var header = decodeStructDataHeader(); |
| if (header.size != kMapStructHeader.size) { |
| throw new MojoCodecError( |
| 'Incorrect header for map. The size is incorrect.'); |
| } |
| if (header.version != kMapStructHeader.version) { |
| throw new MojoCodecError( |
| 'Incorrect header for map. The version is incorrect.'); |
| } |
| return header; |
| } |
| } |
