Dart: Encode/Decode handle and interface types.

mojo/public/dart/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 120 matching lines @@
 
   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(Interface 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(Client 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 '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 'Trying to encode a null pointer for a non-nullable type';
@@ skipping 113 matching lines @@
   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 encodeHandleArray(List<core.MojoHandle> value,
-                         int offset,
-                         int nullability,
-                         int 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 = DataHeader.kHeaderSize + kSerializedHandleSize * i;
-      encoder.encodeHandle(
-          value[i], handleOffset, isElementNullable(nullability));
+      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<Client> value,
+      int offset,
+      int nullability,
+      int expectedLength) =>
+      _handleArrayEncodeHelper(
+          (e, v, o, n) => e.encodeInterfaceRequest(v, o, n),
+          value, offset, nullability, expectedLength);
+
+  void encodeInterfaceArray(
+      List<Interface> 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),
@@ skipping 38 matching lines @@
 
   void appendDoubleArray(List<int> value) =>
       appendBytes(new Uint8List.view(new Float64List.fromList(value)));
 
   Encoder encoderForMap(int offset) {
     encodePointerToNextUnclaimed(offset);
     return getEncoderAtOffset(kMapStructHeader);
   }
 }
 
+
 class Decoder {
   Message _message;
   int _base = 0;
 
   Decoder(this._message, [this._base = 0]);
 
   Decoder getDecoderAtPosition(int offset) => new Decoder(_message, offset);
 
   factory Decoder.atOffset(Decoder d, int offset) =>
       new Decoder(d._message, offset);
@@ skipping 27 matching lines @@
     int index = decodeInt32(offset);
     if (index == -1) {
       if (!nullable) {
         throw 'Trying to decode an invalid handle from a non-nullable type.';
       }
       return new core.MojoHandle(core.MojoHandle.INVALID);
     }
     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));
+
+  Client decodeServiceInterface(
+      int offset, bool nullable, Function clientFactory) {
+    var endpoint = decodeMessagePipeHandle(offset, nullable);
+    return endpoint.handle.isValid ? clientFactory(endpoint) : null;
+  }
+
+  Interface 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 'Trying to decode a null pointer for a non-nullable type';
       }
       return null;
     }
     int newPosition = (basePosition + pointerOffset);
@@ skipping 115 matching lines @@
   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<core.MojoHandle> decodeHandleArray(
-      int offset, int nullability, int 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 core.MojoHandle(header.numFields);
+    var result = new List(header.numFields);
     for (int i = 0; i < result.length; ++i) {
-      result[i] = d.decodeHandle(
+      result[i] = elementDecoder(
+          d,
           DataHeader.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<Interface> decodeInterfaceRequestArray(
+      int offset,
+      int nullability,
+      int expectedLength,
+      Function interfaceFactory) =>
+      _handleArrayDecodeHelper(
+          (d, o, n) => d.decodeInterfaceRequest(o, n, interfaceFactory),
+          offset, nullability, expectedLength);
+
+  List<Client> 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);
   }
 }