Support posting of external data into dart as external uint8 arrays through the Dart API.

runtime/vm/raw_object_snapshot.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 "vm/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/visitor.h"
 
@@ skipping 1758 matching lines @@
 
   // Setup the array elements.
   for (intptr_t i = 0; i < len; ++i) {
     result.SetAt(i, reader->Read<ElementT>());
   }
   return result.raw();
 }
 
 
 #define BYTEARRAY_TYPE_LIST(V)                                                 \
-  V(Int8, int8_t)                                                              \
-  V(Uint8, uint8_t)                                                            \
-  V(Int16, int16_t)                                                            \
-  V(Uint16, uint16_t)                                                          \
-  V(Int32, int32_t)                                                            \
-  V(Uint32, uint32_t)                                                          \
-  V(Int64, int64_t)                                                            \
-  V(Uint64, uint64_t)                                                          \
-  V(Float32, float)                                                            \
-  V(Float64, double)                                                           \
+  V(Int8, int8, int8_t)                                                        \
+  V(Uint8, uint8, uint8_t)                                                     \
+  V(Int16, int16, int16_t)                                                     \
+  V(Uint16, uint16, uint16_t)                                                  \
+  V(Int32, int32, int32_t)                                                     \
+  V(Uint32, uint32, uint32_t)                                                  \
+  V(Int64, int64, int64_t)                                                     \
+  V(Uint64, uint64, uint64_t)                                                  \
+  V(Float32, float32, float)                                                   \
+  V(Float64, float64, double)                                                  \
 
 
-#define BYTEARRAY_READ_FROM(name, type)                                        \
+#define BYTEARRAY_READ_FROM(name, lname, type)                                 \
 Raw##name##Array* name##Array::ReadFrom(SnapshotReader* reader,                \
                                           intptr_t object_id,                  \
                                           intptr_t tags,                       \
                                           Snapshot::Kind kind) {               \
   return ReadFromImpl<name##Array, Raw##name##Array, type>(reader,             \
                                                            object_id,          \
                                                            tags,               \
                                                            kind);              \
 }                                                                              \
 
 
 BYTEARRAY_TYPE_LIST(BYTEARRAY_READ_FROM)
 #undef BYTEARRAY_READ_FROM
 
 
-#define EXTERNALARRAY_READ_FROM(name, type)                                    \
+#define EXTERNALARRAY_READ_FROM(name, lname, type)                             \
 RawExternal##name##Array* External##name##Array::ReadFrom(                     \
     SnapshotReader* reader,                                                    \
     intptr_t object_id,                                                        \
     intptr_t tags,                                                             \
     Snapshot::Kind kind) {                                                     \

[siva, 2012/06/28 16:44:05]

ASSERT(kind != Snapshot::kFull);
or
if (kind == Snapshot::kFull) {
  UNREACHABLE();
}

[Mads Ager (google), 2012/06/28 18:06:51]

Added the ASSERT. Thanks!

-  UNREACHABLE();                                                               \
-  return External##name##Array::null();                                        \
+  intptr_t length = reader->ReadSmiValue();                                    \
+  type* data = reinterpret_cast<type*>(reader->ReadIntptrValue());             \
+  void* peer = reinterpret_cast<void*>(reader->ReadIntptrValue());             \
+  Dart_PeerFinalizer callback =                                                \
+      reinterpret_cast<Dart_PeerFinalizer>(reader->ReadIntptrValue());         \
+  const Class& cls = Class::Handle(                                            \
+      reader->isolate()->object_store()->external_##lname##_array_class());    \
+  return NewExternalImpl<External##name##Array, RawExternal##name##Array>(     \
+      cls, data, length, peer, callback, Heap::kNew);                          \
 }                                                                              \
 
 
 BYTEARRAY_TYPE_LIST(EXTERNALARRAY_READ_FROM)
 #undef EXTERNALARRAY_READ_FROM
 
 
 static void ByteArrayWriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind,
@@ skipping 20 matching lines @@
 }
 
 
 void RawByteArray::WriteTo(SnapshotWriter* writer,
                            intptr_t object_id,
                            Snapshot::Kind kind) {
   UNREACHABLE();  // ByteArray is an abstract class
 }
 
 
-#define BYTEARRAY_WRITE_TO(name, type)                                         \
+#define BYTEARRAY_WRITE_TO(name, lname, type)                                  \
 void Raw##name##Array::WriteTo(SnapshotWriter* writer,                         \
                                intptr_t object_id,                             \
                                Snapshot::Kind kind) {                          \
   ByteArrayWriteTo(writer,                                                     \
                    object_id,                                                  \
                    kind,                                                       \
                    ObjectStore::k##name##ArrayClass,                           \
                    writer->GetObjectTags(this),                                \
                    ptr()->length_,                                             \
                    reinterpret_cast<uint8_t*>(ptr()->data_));                  \
 }                                                                              \
 
 
 BYTEARRAY_TYPE_LIST(BYTEARRAY_WRITE_TO)
 #undef BYTEARRAY_WRITE_TO
 
 
-#define EXTERNALARRAY_WRITE_TO(name, type)                                     \
+#define EXTERNALARRAY_WRITE_TO(name, lname, type)                              \
 void RawExternal##name##Array::WriteTo(SnapshotWriter* writer,                 \
                                        intptr_t object_id,                     \
                                        Snapshot::Kind kind) {                  \
   ByteArrayWriteTo(writer,                                                     \
                    object_id,                                                  \
                    kind,                                                       \
                    ObjectStore::k##name##ArrayClass,                           \
                    writer->GetObjectTags(this),                                \
                    ptr()->length_,                                             \
                    reinterpret_cast<uint8_t*>(ptr()->external_data_->data())); \
@@ skipping 89 matching lines @@
   writer->Write<RawObject*>(ptr()->num_bracket_expressions_);
   writer->WriteObjectImpl(ptr()->pattern_);
   writer->WriteIntptrValue(ptr()->type_);
   writer->WriteIntptrValue(ptr()->flags_);
 
   // Do not write out the data part which is native.
 }
 
 
 }  // namespace dart