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

runtime/vm/raw_object_snapshot.cc

Index: runtime/vm/raw_object_snapshot.cc
diff --git a/runtime/vm/raw_object_snapshot.cc b/runtime/vm/raw_object_snapshot.cc
index 54380b4bb415b501469f5b4755b635c15210eaf6..acab2bb61914bd095393b0f4d3dcc98c216025d8 100644
--- a/runtime/vm/raw_object_snapshot.cc
+++ b/runtime/vm/raw_object_snapshot.cc
@@ -1776,19 +1776,19 @@ RawT* ByteArray::ReadFromImpl(SnapshotReader* reader,
 
 
 #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)                                                           \
-
-
-#define BYTEARRAY_READ_FROM(name, type)                                        \
+  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, lname, type)                                 \
 Raw##name##Array* name##Array::ReadFrom(SnapshotReader* reader,                \
                                           intptr_t object_id,                  \
                                           intptr_t tags,                       \
@@ -1804,14 +1804,21 @@ 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);                          \
 }                                                                              \
 
 
@@ -1852,7 +1859,7 @@ void RawByteArray::WriteTo(SnapshotWriter* writer,
 }
 
 
-#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) {                          \
@@ -1870,7 +1877,7 @@ 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) {                  \