Rename WeakReference to WeakReferenceSet.

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 343 matching lines @@
   int CountHandles() const {
     return CountScopedHandles();
   }
 
  private:
   FinalizablePersistentHandle* free_list_;
   DISALLOW_COPY_AND_ASSIGN(FinalizablePersistentHandles);
 };
 
 
-class WeakReference {
+class WeakReferenceSet {
  public:
-  WeakReference(Dart_Handle* keys, intptr_t keys_length,
-                Dart_Handle* values, intptr_t values_length)
+  WeakReferenceSet(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() {}
+  ~WeakReferenceSet() {}
 
-  WeakReference* next() const { return next_; }
+  WeakReferenceSet* 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) {
+  static WeakReferenceSet* Pop(WeakReferenceSet** queue) {
     ASSERT(queue != NULL);
-    WeakReference* head = *queue;
+    WeakReferenceSet* head = *queue;
     if (head != NULL) {
       *queue = head->next();
       head->next_ = NULL;
     }
     return head;
   }
 
-  static void Push(WeakReference* reference, WeakReference** queue) {
-    ASSERT(reference != NULL);
+  static void Push(WeakReferenceSet* reference_set, WeakReferenceSet** queue) {
+    ASSERT(reference_set != NULL);
     ASSERT(queue != NULL);
-    reference->next_ = *queue;
-    *queue = reference;
+    reference_set->next_ = *queue;
+    *queue = reference_set;
   }
 
  private:
-  WeakReference* next_;
+  WeakReferenceSet* next_;
   Dart_Handle* keys_;
   intptr_t num_keys_;
   Dart_Handle* values_;
   intptr_t num_values_;
-  DISALLOW_COPY_AND_ASSIGN(WeakReference);
+  DISALLOW_COPY_AND_ASSIGN(WeakReferenceSet);
 };
 
 
 // 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() {
@@ skipping 15 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), delayed_weak_references_(NULL),
+  ApiState() : top_scope_(NULL), delayed_weak_reference_sets_(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;
@@ skipping 15 matching lines @@
   PersistentHandles& persistent_handles() { return persistent_handles_; }
 
   FinalizablePersistentHandles& weak_persistent_handles() {
     return weak_persistent_handles_;
   }
 
   FinalizablePersistentHandles& prologue_weak_persistent_handles() {
     return prologue_weak_persistent_handles_;
   }
 
-  WeakReference* delayed_weak_references() { return delayed_weak_references_; }
-  void set_delayed_weak_references(WeakReference* reference) {
-    delayed_weak_references_ = reference;
+  WeakReferenceSet* delayed_weak_reference_sets() {
+    return delayed_weak_reference_sets_;
+  }
+  void set_delayed_weak_reference_sets(WeakReferenceSet* reference_set) {
+    delayed_weak_reference_sets_ = reference_set;
   }
 
   void UnwindScopes(uword sp) {
     while (top_scope_ != NULL && top_scope_->stack_marker() < sp) {
       ApiLocalScope* scope = top_scope_;
       top_scope_ = top_scope_->previous();
       delete scope;
     }
   }
 
@@ skipping 91 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_);
+  void DelayWeakReferenceSet(WeakReferenceSet* reference_set) {
+    WeakReferenceSet::Push(reference_set, &delayed_weak_reference_sets_);
   }
 
  private:
   PersistentHandles persistent_handles_;
   FinalizablePersistentHandles weak_persistent_handles_;
   FinalizablePersistentHandles prologue_weak_persistent_handles_;
   ApiLocalScope* top_scope_;
-  WeakReference* delayed_weak_references_;
+  WeakReferenceSet* delayed_weak_reference_sets_;
 
   // 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_