Dart: Merge message pipe query and read into one native call

mojo/public/dart/mojo/lib/src/codec.dart

 // 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;
@@ skipping 87 matching lines @@
     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);
+  Message get message => new Message(
+      _buffer.trimmed, _buffer.handles, _buffer.extent, _buffer.handles.length);
 
   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);
@@ skipping 44 matching lines @@
   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: $value');
     }
     _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 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 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.pass());
     }
   }
 
@@ skipping 80 matching lines @@
       encodeNullPointer(offset, nullable);
       return;
     }
     encodePointerToNextUnclaimed(offset);
     value.encode(this);
   }
 
   void encodeUnion(Union value, int offset, bool nullable) {
     if (value == null) {
       if (!nullable) {
-        throw new MojoCodecError(
-            'Trying to encode a non-nullable null union.');
+        throw new MojoCodecError('Trying to encode a non-nullable null union.');
       }
       encodeUint64(0, offset);
       encodeUint64(0, offset + 8);
       return;
     }
     value.encode(this, offset);
   }
 
   void encodeEnum(MojoEnum value, int offset) =>
       encodeUint32(value.value, offset);
@@ skipping 125 matching lines @@
     var encoder =
         encoderForArray(elementSize, value.length, offset, expectedLength);
     for (int i = 0; i < value.length; ++i) {
       int elementOffset = ArrayDataHeader.kHeaderSize + elementSize * i;
       elementEncoder(
           encoder, value[i], elementOffset, 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,
-          kSerializedHandleSize, nullability, expectedLength);
+          int nullability, int expectedLength) =>
+      _handleArrayEncodeHelper((e, v, o, n) => e.encodeHandle(v, o, n), value,
+          offset, kSerializedHandleSize, 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,
-          kSerializedHandleSize, nullability, expectedLength);
+          (e, v, o, n) => e.encodeMessagePipeHandle(v, o, n),
+          value,
+          offset,
+          kSerializedHandleSize,
+          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, kSerializedHandleSize, 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, kSerializedHandleSize, 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,
-          kSerializedHandleSize, nullability, expectedLength);
+          (e, v, o, n) => e.encodeSharedBufferHandle(v, o, n),
+          value,
+          offset,
+          kSerializedHandleSize,
+          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,
-          kSerializedHandleSize, nullability, expectedLength);
+          (e, v, o, n) => e.encodeInterfaceRequest(v, o, n),
+          value,
+          offset,
+          kSerializedHandleSize,
+          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, kSerializedInterfaceSize, 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);
+    _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));
@@ skipping 64 matching lines @@
   }
 }
 
 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);
+      _validator = new _Validator(_message.dataLength, _message.handlesLength);
     }
   }
 
   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;
-  List<core.MojoHandle> get excessHandles => new List.from(_message.handles
-      .getRange(_validator._minNextClaimedHandle, _message.handles.length))
-    ..addAll(_validator._skippedIndices.map((i) => _message.handles[i]));
+  List<core.MojoHandle> get excessHandles {
+    if (_message.handlesLength == 0) return null;
+    var leftAtEnd = _message.handles
+        .getRange(_validator._minNextClaimedHandle, _message.handlesLength);
+    var skipped = _validator._skippedIndices.map((i) => _message.handles[i]);
+    return new List.from(leftAtEnd)..addAll(skipped);
+  }
 
   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) =>
@@ skipping 112 matching lines @@
     }
     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,
+    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;
         }
       }
@@ skipping 28 matching lines @@
   ArrayDataHeader decodeDataHeaderForEnumArray(int expectedLength) =>
       decodeDataHeaderForArray(kEnumSize, 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,
+    return arrayViewer(
+        d._buffer.buffer,
         d._buffer.offsetInBytes + d._base + ArrayDataHeader.kHeaderSize,
-        header.numElements);
+        header.numElements).toList();
   }
 
   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);
+          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);
+          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);
+          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);
+          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);
+          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 elementSize, int nullability, int expectedLength) {
     Decoder d = decodePointer(offset, isArrayNullable(nullability));
     if (d == null) {
       return null;
     }
     var header = d.decodeDataHeaderForArray(elementSize, expectedLength);
     var result = new List(header.numElements);
     for (int i = 0; i < result.length; ++i) {
-      result[i] = elementDecoder(d,
+      result[i] = elementDecoder(
+          d,
           ArrayDataHeader.kHeaderSize + elementSize * i,
           isElementNullable(nullability));
     }
     return result;
   }
 
   List<core.MojoHandle> decodeHandleArray(
           int offset, int nullability, int expectedLength) =>
       _handleArrayDecodeHelper((d, o, n) => d.decodeHandle(o, n), offset,
           kSerializedHandleSize, nullability, expectedLength);
@@ skipping 14 matching lines @@
           offset, kSerializedHandleSize, nullability, expectedLength);
 
   List<core.MojoSharedBuffer> decodeSharedBufferHandleArray(
           int offset, int nullability, int expectedLength) =>
       _handleArrayDecodeHelper((d, o, n) => d.decodeSharedBufferHandle(o, n),
           offset, kSerializedHandleSize, nullability, expectedLength);
 
   List<Stub> decodeInterfaceRequestArray(int offset, int nullability,
           int expectedLength, Function interfaceFactory) =>
       _handleArrayDecodeHelper(
-          (d, o, n) => d.decodeInterfaceRequest(o, n, interfaceFactory), offset,
-          kSerializedHandleSize, nullability, expectedLength);
+          (d, o, n) => d.decodeInterfaceRequest(o, n, interfaceFactory),
+          offset,
+          kSerializedHandleSize,
+          nullability,
+          expectedLength);
 
   List<Proxy> decodeServiceInterfaceArray(int offset, int nullability,
-      int expectedLength, Function clientFactory) => _handleArrayDecodeHelper(
-          (d, o, n) => d.decodeServiceInterface(o, n, clientFactory), offset,
-          kSerializedInterfaceSize, nullability, expectedLength);
-
-  static String _stringOfUtf8(Uint8List bytes) =>
-      (const Utf8Decoder()).convert(bytes.toList());
+          int expectedLength, Function clientFactory) =>
+      _handleArrayDecodeHelper(
+          (d, o, n) => d.decodeServiceInterface(o, n, clientFactory),
+          offset,
+          kSerializedInterfaceSize,
+          nullability,
+          expectedLength);
 
   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);
+    return (const Utf8Decoder()).convert(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;
   }
 }