Implement weak references sets and provide an embedding API.

runtime/vm/dart_api_state.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_DART_API_STATE_H_
 #define VM_DART_API_STATE_H_
 
 #include "include/dart_api.h"
 
 #include "platform/thread.h"
@@ skipping 330 matching lines @@
   int CountHandles() const {
     return CountScopedHandles();
   }
 
  private:
   WeakPersistentHandle* free_list_;
   DISALLOW_COPY_AND_ASSIGN(WeakPersistentHandles);
 };
 
 
+class WeakReference {
+ public:
+  WeakReference(Dart_Handle* keys, intptr_t keys_length,
+                Dart_Handle* values, intptr_t values_length)
+      : next_(NULL),
+        keys_(keys), num_keys_(keys_length),
+        values_(values), num_values_(values_length) {
+  }
+  ~WeakReference() {}
+
+  WeakReference* next() const { return next_; }
+
+  intptr_t num_keys() const { return num_keys_; }
+  RawObject** get_key(intptr_t i) {
+    ASSERT(i >= 0);
+    ASSERT(i < num_keys_);
+    return reinterpret_cast<RawObject**>(keys_[i]);
+  }
+
+  intptr_t num_values() const { return num_values_; }
+  RawObject** get_value(intptr_t i) {
+    ASSERT(i >= 0);
+    ASSERT(i < num_values_);
+    return reinterpret_cast<RawObject**>(values_[i]);
+  }
+
+  static WeakReference* Pop(WeakReference** queue) {
+    ASSERT(queue != NULL);
+    WeakReference* head = *queue;
+    if (head != NULL) {
+      *queue = head->next();
+      head->next_ = NULL;
+    }
+    return head;
+  }
+
+  static void Push(WeakReference* reference, WeakReference** queue) {
+    ASSERT(reference != NULL);
+    ASSERT(queue != NULL);
+    reference->next_ = *queue;
+    *queue = reference;
+  }
+
+ private:
+  WeakReference* next_;
+  Dart_Handle* keys_;
+  intptr_t num_keys_;
+  Dart_Handle* values_;
+  intptr_t num_values_;
+  DISALLOW_COPY_AND_ASSIGN(WeakReference);
+};
+
+
 // Structure used for the implementation of local scopes used in dart_api.
 // These local scopes manage handles and memory allocated in the scope.
 class ApiLocalScope {
  public:
   ApiLocalScope(ApiLocalScope* previous, uword stack_marker) :
       previous_(previous), stack_marker_(stack_marker) { }
   ~ApiLocalScope() {
     previous_ = NULL;
   }
 
@@ skipping 12 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ApiLocalScope);
 };
 
 
 // Implementation of the API State used in dart api for maintaining
 // local scopes, persistent handles etc. These are setup on a per isolate
 // basis and destroyed when the isolate is shutdown.
 class ApiState {
  public:
-  ApiState() : top_scope_(NULL), null_(NULL), true_(NULL), false_(NULL) { }
+  ApiState() : top_scope_(NULL), delayed_weak_references_(NULL),
+               null_(NULL), true_(NULL), false_(NULL) { }
   ~ApiState() {
     while (top_scope_ != NULL) {
       ApiLocalScope* scope = top_scope_;
       top_scope_ = top_scope_->previous();
       delete scope;
     }
     if (null_ != NULL) {
       persistent_handles().FreeHandle(null_);
       null_ = NULL;
     }
     if (true_ != NULL) {
       persistent_handles().FreeHandle(true_);
       true_ = NULL;
     }
     if (false_ != NULL) {
       persistent_handles().FreeHandle(false_);
       false_ = NULL;
     }
   }
 
   // Accessors.
   ApiLocalScope* top_scope() const { return top_scope_; }
   void set_top_scope(ApiLocalScope* value) { top_scope_ = value; }
   PersistentHandles& persistent_handles() { return persistent_handles_; }
   WeakPersistentHandles& weak_persistent_handles() {
     return weak_persistent_handles_;
   }
-
+  WeakReference* delayed_weak_references() { return delayed_weak_references_; }
+  void set_delayed_weak_references(WeakReference* reference) {
+    delayed_weak_references_ = reference;
+  }
   void UnwindScopes(uword sp) {
     while (top_scope_ != NULL && top_scope_->stack_marker() < sp) {
       ApiLocalScope* scope = top_scope_;
       top_scope_ = top_scope_->previous();
       delete scope;
     }
   }
 
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
     ApiLocalScope* scope = top_scope_;
@@ skipping 77 matching lines @@
     if (false_ == NULL) {
       DARTSCOPE(Isolate::Current());
 
       const Object& false_object = Object::Handle(Bool::False());
       false_ = persistent_handles().AllocateHandle();
       false_->set_raw(false_object);
     }
     return false_;
   }
 
+  void DelayWeakReference(WeakReference* reference) {
+    WeakReference::Push(reference, &delayed_weak_references_);
+  }
+
  private:
   PersistentHandles persistent_handles_;
   WeakPersistentHandles weak_persistent_handles_;
   ApiLocalScope* top_scope_;
+  WeakReference* delayed_weak_references_;
 
   // Persistent handles to important objects.
   PersistentHandle* null_;
   PersistentHandle* true_;
   PersistentHandle* false_;
 
   DISALLOW_COPY_AND_ASSIGN(ApiState);
 };
 
 
@@ skipping 36 matching lines @@
           ApiNativeScope::Current()->zone()->GetBaseZone()) {}
   ApiGrowableArray()
       : BaseGrowableArray<T, ValueObject>(
           ApiNativeScope::Current()->zone()->GetBaseZone()) {}
 };
 
 
 }  // namespace dart
 
 #endif  // VM_DART_API_STATE_H_