Support sending and receiving Capability objects from C code.

runtime/vm/snapshot_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/globals.h"
 
 #include "include/dart_tools_api.h"
 #include "platform/assert.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
@@ skipping 102 matching lines @@
     case Dart_CObject_kArray:
       // Use invalid type as a visited marker to avoid infinite
       // recursion on graphs with cycles.
       second->type = Dart_CObject_kNumberOfTypes;
       EXPECT_EQ(first->value.as_array.length, second->value.as_array.length);
       for (int i = 0; i < first->value.as_array.length; i++) {
         CompareDartCObjects(first->value.as_array.values[i],
                             second->value.as_array.values[i]);
       }
       break;
+    case Dart_CObject_kCapability:
+      EXPECT_EQ(first->value.as_capability.id, second->value.as_capability.id);
+      break;
     default:
       EXPECT(false);
   }
 }
 
 
 static void CheckEncodeDecodeMessage(Dart_CObject* root) {
   // Encode and decode the message.
   uint8_t* buffer = NULL;
   ApiMessageWriter writer(&buffer, &malloc_allocator);
@@ skipping 262 matching lines @@
   EXPECT_EQ(false, root->value.as_bool);
   CheckEncodeDecodeMessage(root);
 }
 
 
 static uword allocator(intptr_t size) {
   return reinterpret_cast<uword>(malloc(size));
 }
 
 
+TEST_CASE(SerializeCapability) {
+  StackZone zone(Isolate::Current());
+
+  // Write snapshot with object content.
+  const Capability& capability = Capability::Handle(Capability::New(12345));
+  uint8_t* buffer;
+  MessageWriter writer(&buffer, &zone_allocator, true);
+  writer.WriteMessage(capability);
+  intptr_t buffer_len = writer.BytesWritten();
+
+  // Read object back from the snapshot.
+  MessageSnapshotReader reader(buffer,
+                               buffer_len,
+                               Isolate::Current(),
+                               zone.GetZone());
+  Capability& obj = Capability::Handle();
+  obj ^= reader.ReadObject();
+
+  EXPECT_STREQ(12345, obj.Id());
+
+  // Read object back from the snapshot into a C structure.
+  ApiNativeScope scope;
+  ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
+  Dart_CObject* root = api_reader.ReadMessage();
+  EXPECT_NOTNULL(root);
+  EXPECT_EQ(Dart_CObject_kCapability, root->type);
+  int64_t id = root->value.as_capability.id;
+  EXPECT_EQ(12345, id);
+  CheckEncodeDecodeMessage(root);

[siva, 2015/07/30 19:44:06]

You should probably also have a case similar to this where the writing is done
by ApiMessageWriter.

[turnidge, 2015/07/30 21:04:13]

Yes, that's what CheckEncodeDecodeMessage does.

+}
+
+
 TEST_CASE(SerializeBigint) {
   StackZone zone(Isolate::Current());
 
   // Write snapshot with object content.
   const char* cstr = "0x270FFFFFFFFFFFFFD8F0";
   const String& str = String::Handle(String::New(cstr));
   Bigint& bigint = Bigint::Handle();
   bigint ^= Integer::NewCanonical(str);
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
@@ skipping 2603 matching lines @@
   StackZone zone(Isolate::Current());
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteInlinedObjectHeader(kOmittedObjectId);
   // For performance, we'd like single-byte headers when ids are omitted.
   // If this starts failing, consider renumbering the snapshot ids.
   EXPECT_EQ(1, writer.BytesWritten());
 }
 
 }  // namespace dart