Add external byte array API and finalize external strings and byte arrays.

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 2678 matching lines @@
   void set_value(double value) const;
 
   HEAP_OBJECT_IMPLEMENTATION(Double, Number);
   friend class Class;
 };
 
 
 // String may not be '\0' terminated.
 class String : public Instance {
  public:
-  typedef void (*PeerFinalizer)(void *peer);
-
   // We use 30 bits for the hash code so that we consistently use a
   // 32bit Smi representation for the hash code on all architectures.
   static const intptr_t kHashBits = 30;
 
   static const intptr_t kOneByteChar = 1;
   static const intptr_t kTwoByteChar = 2;
   static const intptr_t kFourByteChar = 4;
 
   intptr_t Length() const { return Smi::Value(raw_ptr()->length_); }
   static intptr_t length_offset() { return OFFSET_OF(RawString, length_); }
@@ skipping 48 matching lines @@
                         intptr_t len,
                         Heap::Space space = Heap::kNew);
   static RawString* New(const uint32_t* characters,
                         intptr_t len,
                         Heap::Space space = Heap::kNew);
   static RawString* New(const String& str, Heap::Space space = Heap::kNew);
 
   static RawString* NewExternal(const uint8_t* characters,
                                 intptr_t len,
                                 void* peer,
-                                PeerFinalizer callback,
+                                Dart_PeerFinalizer callback,
                                 Heap::Space = Heap::kNew);
   static RawString* NewExternal(const uint16_t* characters,
                                 intptr_t len,
                                 void* peer,
-                                PeerFinalizer callback,
+                                Dart_PeerFinalizer callback,
                                 Heap::Space = Heap::kNew);
   static RawString* NewExternal(const uint32_t* characters,
                                 intptr_t len,
                                 void* peer,
-                                PeerFinalizer callback,
+                                Dart_PeerFinalizer callback,
                                 Heap::Space = Heap::kNew);
 
   static void Copy(const String& dst,
                    intptr_t dst_offset,
                    const uint8_t* characters,
                    intptr_t len);
   static void Copy(const String& dst,
                    intptr_t dst_offset,
                    const uint16_t* characters,
                    intptr_t len);
@@ skipping 233 matching lines @@
   virtual int32_t CharAt(intptr_t index) const {
     return *CharAddr(index);
   }
 
   virtual intptr_t CharSize() const {
     return kOneByteChar;
   }
 
   virtual bool IsExternal() const { return true; }
   virtual void* GetPeer() const {
-    return raw_ptr()->external_data_->peer_;
+    return raw_ptr()->external_data_->peer();
   }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalOneByteString));
   }
 
   static RawExternalOneByteString* New(const uint8_t* characters,
                                        intptr_t len,
                                        void* peer,
-                                       PeerFinalizer callback,
+                                       Dart_PeerFinalizer callback,
                                        Heap::Space space);
 
  private:
   const uint8_t* CharAddr(intptr_t index) const {
     // TODO(iposva): Determine if we should throw an exception here.
     ASSERT((index >= 0) && (index < Length()));
-    return &(raw_ptr()->external_data_->data_[index]);
+    return &(raw_ptr()->external_data_->data()[index]);
   }
 
   void SetExternalData(ExternalStringData<uint8_t>* data) {
     raw_ptr()->external_data_ = data;
   }
 
+  static void Finalize(Dart_Handle handle, void* peer);
+
   HEAP_OBJECT_IMPLEMENTATION(ExternalOneByteString, String);
   friend class Class;
   friend class String;
 };
 
 
 class ExternalTwoByteString : public String {
  public:
   virtual int32_t CharAt(intptr_t index) const {
     return *CharAddr(index);
   }
 
   virtual intptr_t CharSize() const {
     return kTwoByteChar;
   }
 
   virtual bool IsExternal() const { return true; }
   virtual void* GetPeer() const {
-    return raw_ptr()->external_data_->peer_;
+    return raw_ptr()->external_data_->peer();
   }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalTwoByteString));
   }
 
   static RawExternalTwoByteString* New(const uint16_t* characters,
                                        intptr_t len,
                                        void* peer,
-                                       PeerFinalizer callback,
+                                       Dart_PeerFinalizer callback,
                                        Heap::Space space = Heap::kNew);
 
  private:
   const uint16_t* CharAddr(intptr_t index) const {
     // TODO(iposva): Determine if we should throw an exception here.
     ASSERT((index >= 0) && (index < Length()));
-    return &(raw_ptr()->external_data_->data_[index]);
+    return &(raw_ptr()->external_data_->data()[index]);
   }
 
   void SetExternalData(ExternalStringData<uint16_t>* data) {
     raw_ptr()->external_data_ = data;
   }
 
+  static void Finalize(Dart_Handle handle, void* peer);
+
   HEAP_OBJECT_IMPLEMENTATION(ExternalTwoByteString, String);
   friend class Class;
   friend class String;
 };
 
 
 class ExternalFourByteString : public String {
  public:
   virtual int32_t CharAt(intptr_t index) const {
     return *CharAddr(index);
   }
 
   virtual intptr_t CharSize() const {
     return kFourByteChar;
   }
 
   virtual bool IsExternal() const { return true; }
   virtual void* GetPeer() const {
-    return raw_ptr()->external_data_->peer_;
+    return raw_ptr()->external_data_->peer();
   }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalFourByteString));
   }
 
   static RawExternalFourByteString* New(const uint32_t* characters,
                                         intptr_t len,
                                         void* peer,
-                                        PeerFinalizer callback,
+                                        Dart_PeerFinalizer callback,
                                         Heap::Space space = Heap::kNew);
 
  private:
   const uint32_t* CharAddr(intptr_t index) const {
     // TODO(iposva): Determine if we should throw an exception here.
     ASSERT((index >= 0) && (index < Length()));
-    return &(raw_ptr()->external_data_->data_[index]);
+    return &(raw_ptr()->external_data_->data()[index]);
   }
 
   void SetExternalData(ExternalStringData<uint32_t>* data) {
     raw_ptr()->external_data_ = data;
   }
 
+  static void Finalize(Dart_Handle handle, void* peer);
+
   HEAP_OBJECT_IMPLEMENTATION(ExternalFourByteString, String);
   friend class Class;
   friend class String;
 };
 
 
 class Bool : public Instance {
  public:
   bool value() const {
     return raw_ptr()->value_;
@@ skipping 223 matching lines @@
 };
 
 
 class ExternalByteArray : public ByteArray {
  public:
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
   }
 
+  void* GetPeer() const {
+    return raw_ptr()->external_data_->peer();
+  }
+
   template<typename T>
   T At(intptr_t byte_offset) const {
     T* addr = Addr<T>(byte_offset);
     ASSERT(Utils::IsAligned(reinterpret_cast<intptr_t>(addr), sizeof(T)));
     return *addr;
   }
 
   template<typename T>
   void SetAt(intptr_t byte_offset, T value) const {
     T* addr = Addr<T>(byte_offset);
@@ skipping 12 matching lines @@
   void SetUnalignedAt(intptr_t byte_offset, T value) const {
     memmove(Addr<T>(byte_offset), &value, sizeof(T));
   }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalByteArray));
   }
 
   static RawExternalByteArray* New(uint8_t* data,
                                    intptr_t len,
+                                   void* peer,
+                                   Dart_PeerFinalizer callback,
                                    Heap::Space space = Heap::kNew);
 
  private:
   uint8_t* ByteAddr(intptr_t byte_offset) const {
     return Addr<uint8_t>(byte_offset);
   }
 
   template<typename T>
   T* Addr(intptr_t byte_offset) const {
     intptr_t limit = byte_offset + sizeof(T);
     // TODO(iposva): Determine if we should throw an exception here.
     ASSERT((byte_offset >= 0) && (limit <= Length()));
-    uint8_t* addr = &raw_ptr()->data_[byte_offset];
+    uint8_t* addr = &raw_ptr()->external_data_->data()[byte_offset];
     return reinterpret_cast<T*>(addr);
   }
 
   void SetLength(intptr_t value) {
     raw_ptr()->length_ = Smi::New(value);
   }
 
-  void SetData(uint8_t* data) const {
-    raw_ptr()->data_ = data;
+  void SetExternalData(ExternalByteArrayData* data) {
+    raw_ptr()->external_data_ = data;
   }
 
+  static void Finalize(Dart_Handle handle, void* peer);
+
   HEAP_OBJECT_IMPLEMENTATION(ExternalByteArray, ByteArray);
   friend class Class;
 };
 
 
 class Closure : public Instance {
  public:
   RawFunction* function() const { return raw_ptr()->function_; }
   static intptr_t function_offset() {
     return OFFSET_OF(RawClosure, function_);
@@ skipping 198 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_