Implement a garbage collection prologue and epilogue callback mechanism.

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 383 matching lines @@
  private:
   WeakReference* next_;
   Dart_Handle* keys_;
   intptr_t num_keys_;
   Dart_Handle* values_;
   intptr_t num_values_;
   DISALLOW_COPY_AND_ASSIGN(WeakReference);
 };
 
 
+// A container for garbage collection callback function pointers.
+// Pointers to the callback methods are stored within linked list
+// nodes managed by the container.

[turnidge, 2012/03/07 00:25:16]

I dislike how much code ends up in this header file.  Pre-existing problem,
but...

[cshapiro, 2012/03/07 03:06:10]

Yeah, moved to its own file.

+template<typename T>
+class GcCallbacks {
+ public:
+  GcCallbacks() : head_(NULL) {
+  }
+
+  ~GcCallbacks() {
+    while (head_ != NULL) {
+      Link* prev = head_;
+      head_ = head_->next_;
+      delete prev;
+    }
+  }
+
+  // Adds a new callback to the list.  The new callback must not
+  // already be present in the list.
+  void Add(T callback) {
+    ASSERT(callback != NULL);
+    Link* link = new Link(callback, head_);
+    head_ = link;
+  }
+
+  // Removes a callback from the list.  The callback must be present
+  // in the list.
+  void Remove(T callback) {
+    ASSERT(callback != NULL);
+    if (head_ == NULL) return;
+    Link* prev = head_;
+    Link* curr = head_->next_;
+    if (prev->callback_ == callback) {
+      head_ = curr;
+      delete prev;
+      return;
+    }
+    while (curr != NULL) {
+      if (curr->callback_ == callback) {
+        prev->next_ = curr->next_;
+        delete curr;
+        return;
+      }
+      prev = curr;
+      curr = curr->next_;
+    }
+  }
+
+  // Iterates through all of the callbacks in the list and invokes
+  // their callback methods.
+  void Invoke() const {
+    for (Link* curr = head_; curr != NULL; curr = curr->next_) {
+      (*curr->callback_)();
+    }
+  }
+
+  // Returns the number of callbacks stored in the list.
+  intptr_t Count() const {
+    intptr_t sum = 0;
+    for (Link* curr = head_; curr != NULL; curr = curr->next_) {
+      ++sum;
+    }
+    return sum;
+  }
+
+  // Returns true if the specified callback has is present in the

[turnidge, 2012/03/07 00:25:16]

Extra word "has"

+  // container.
+  bool Contains(T callback) const {
+    for (Link* curr = head_; curr != NULL; curr = curr->next_) {
+      if (curr->callback_ == callback) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+ private:
+  // A linked-list element.
+  struct Link {
+    Link(T callback, Link* next) : callback_(callback), next_(next) {
+    }
+    T callback_;
+    Link* next_;
+  };
+
+  Link* head_;
+};
+
+
+// A container for storing garbage collection prologue methods.
+class GcPrologueCallbacks : public GcCallbacks<Dart_GcPrologueCallback> {};
+
+
+// A container for storing garbage collection epilogue methods.
+class GcEpilogueCallbacks : public GcCallbacks<Dart_GcEpilogueCallback> {};
+
+
 // 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 37 matching lines @@
     }
     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;
   }
+
+  GcPrologueCallbacks& gc_prologue_callbacks() {
+    return gc_prologue_callbacks_;
+  };
+
+  GcEpilogueCallbacks& gc_epilogue_callbacks() {
+    return gc_epilogue_callbacks_;
+  };
+
   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 87 matching lines @@
   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_;
 
+  //

[turnidge, 2012/03/07 00:25:16]

<empty comment>

+  GcPrologueCallbacks gc_prologue_callbacks_;
+  GcEpilogueCallbacks gc_epilogue_callbacks_;
+
   // Persistent handles to important objects.
   PersistentHandle* null_;
   PersistentHandle* true_;
   PersistentHandle* false_;
 
   DISALLOW_COPY_AND_ASSIGN(ApiState);
 };
 
 
 class ApiNativeScope {
@@ skipping 35 matching lines @@
           ApiNativeScope::Current()->zone()->GetBaseZone()) {}
   ApiGrowableArray()
       : BaseGrowableArray<T, ValueObject>(
           ApiNativeScope::Current()->zone()->GetBaseZone()) {}
 };
 
 
 }  // namespace dart
 
 #endif  // VM_DART_API_STATE_H_