Revert the commits adding new GC-related APIs.

src/global-handles.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 18 matching lines @@
 
 #include "api.h"
 #include "global-handles.h"
 
 #include "vm-state-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
+ObjectGroup::~ObjectGroup() {
+  if (info_ != NULL) info_->Dispose();
+}
+
+
 class GlobalHandles::Node {
  public:
   // State transition diagram:
   // FREE -> NORMAL <-> WEAK -> PENDING -> NEAR_DEATH -> { NORMAL, WEAK, FREE }
   enum State {
     FREE = 0,
     NORMAL,     // Normal global handle.
     WEAK,       // Flagged as weak but not yet finalized.
     PENDING,    // Has been recognized as only reachable by weak handles.
     NEAR_DEATH  // Callback has informed the handle is near death.
@@ skipping 517 matching lines @@
     if ((node->is_independent() || node->is_partially_dependent()) &&
         node->IsWeakRetainer()) {
       v->VisitPointer(node->location());
     }
   }
 }
 
 
 bool GlobalHandles::IterateObjectGroups(ObjectVisitor* v,
                                         WeakSlotCallbackWithHeap can_skip) {
-  if (object_groups_.length() == 0)
-    return false;
+  int last = 0;
+  bool any_group_was_visited = false;
+  for (int i = 0; i < object_groups_.length(); i++) {
+    ObjectGroup* entry = object_groups_.at(i);
+    ASSERT(entry != NULL);
 
-  object_groups_.Sort();
-  retainer_infos_.Sort();
-
-  // During the iteration, some of the elements of object_groups are
-  // deleted. This is done by moving surviving elements at the front of the list
-  // and deleting from the end. This index tracks where the next surviving
-  // element should be moved.
-  int surviving_element_index = 0;
-  int info_index = 0;  // For iterating retainer_infos_.
-  int surviving_info_index = 0;
-
-  UniqueId current_group_id(0);
-  int current_group_start = 0;
-  bool any_group_was_visited = false;
-
-  for (int i = 0; i <= object_groups_.length(); ++i) {
-    if (i == 0)
-      current_group_id = object_groups_[i].id;
-    if (i == object_groups_.length() ||
-        current_group_id != object_groups_[i].id) {
-      // Group detected: objects in indices [current_group_start, i[.
-      bool group_should_be_visited = false;
-      for (int j = current_group_start; j < i; ++j) {
-        Object* object = *(object_groups_[j].object);
-        if (object->IsHeapObject()) {
-          if (!can_skip(isolate_->heap(), &object)) {
-            group_should_be_visited = true;
-            break;
-          }
+    Object*** objects = entry->objects_;
+    bool group_should_be_visited = false;
+    for (size_t j = 0; j < entry->length_; j++) {
+      Object* object = *objects[j];
+      if (object->IsHeapObject()) {
+        if (!can_skip(isolate_->heap(), &object)) {
+          group_should_be_visited = true;
+          break;
         }
       }
+    }
 
-      if (!group_should_be_visited) {
-        for (int j = current_group_start; j < i; ++j)
-          object_groups_[surviving_element_index++] = object_groups_[j];
-      } else {
-        // An object in the group requires visiting, so iterate over all
-        // objects in the group.
-        for (int j = current_group_start; j < i; ++j) {
-          Object* object = *(object_groups_[j].object);
-          if (object->IsHeapObject()) {
-            v->VisitPointer(&object);
-            any_group_was_visited = true;
-          }
-        }
-      }
+    if (!group_should_be_visited) {
+      object_groups_[last++] = entry;
+      continue;
+    }
 
-      if (info_index < retainer_infos_.length() &&
-          retainer_infos_[info_index].id ==
-          object_groups_[current_group_start].id) {
-        // This object group has an associated ObjectGroupRetainerInfo.
-        if (!group_should_be_visited) {
-          retainer_infos_[surviving_info_index++] =
-              retainer_infos_[info_index];
-        } else if (retainer_infos_[info_index].info != NULL) {
-          retainer_infos_[info_index].info->Dispose();
-          retainer_infos_[info_index].info = NULL;
-        }
-        ++info_index;
-      }
-      if (i < object_groups_.length()) {
-        current_group_id = object_groups_[i].id;
-        current_group_start = i;
+    // An object in the group requires visiting, so iterate over all
+    // objects in the group.
+    for (size_t j = 0; j < entry->length_; ++j) {
+      Object* object = *objects[j];
+      if (object->IsHeapObject()) {
+        v->VisitPointer(&object);
+        any_group_was_visited = true;
       }
     }
+
+    // Once the entire group has been iterated over, set the object
+    // group to NULL so it won't be processed again.
+    entry->Dispose();
+    object_groups_.at(i) = NULL;
   }
-  object_groups_.Rewind(surviving_element_index);
-  retainer_infos_.Rewind(surviving_info_index);
+  object_groups_.Rewind(last);
   return any_group_was_visited;
 }
 
 
 bool GlobalHandles::PostGarbageCollectionProcessing(
     GarbageCollector collector, GCTracer* tracer) {
   // Process weak global handle callbacks. This must be done after the
   // GC is completely done, because the callbacks may invoke arbitrary
   // API functions.
   ASSERT(isolate_->heap()->gc_state() == Heap::NOT_IN_GC);
@@ skipping 187 matching lines @@
                                    v8::RetainedObjectInfo* info) {
 #ifdef DEBUG
   for (size_t i = 0; i < length; ++i) {
     ASSERT(!Node::FromLocation(handles[i])->is_independent());
   }
 #endif
   if (length == 0) {
     if (info != NULL) info->Dispose();
     return;
   }
-  for (size_t i = 0; i < length; ++i) {
-    object_groups_.Add(ObjectGroupConnection(
-        UniqueId(reinterpret_cast<intptr_t>(handles[0])), handles[i]));
-  }
-  for (size_t i = 0; i < length; ++i) {
-    if ((*handles[i])->IsHeapObject()) {
-      representative_objects_.Add(ObjectGroupRepresentative(
-          UniqueId(reinterpret_cast<intptr_t>(handles[0])),
-          reinterpret_cast<HeapObject**>(handles[i])));
-      break;
-    }
-  }
-  if (info != NULL) {
-    retainer_infos_.Add(ObjectGroupRetainerInfo(
-        UniqueId(reinterpret_cast<intptr_t>(handles[0])), info));
-  }
-}
-
-void GlobalHandles::SetObjectGroupId(Object** handle,
-                                     UniqueId id) {
-  object_groups_.Add(ObjectGroupConnection(id, handle));
+  object_groups_.Add(ObjectGroup::New(handles, length, info));
 }
 
 
-void GlobalHandles::SetRetainedObjectInfo(UniqueId id,
-                                          RetainedObjectInfo* info) {
-  retainer_infos_.Add(ObjectGroupRetainerInfo(id, info));
-}
-
-
-void GlobalHandles::SetObjectGroupRepresentative(
-    UniqueId id,
-    HeapObject** representative_object) {
-  representative_objects_.Add(
-      ObjectGroupRepresentative(id, representative_object));
-}
-
 void GlobalHandles::AddImplicitReferences(HeapObject** parent,
                                           Object*** children,
                                           size_t length) {
 #ifdef DEBUG
   ASSERT(!Node::FromLocation(BitCast<Object**>(parent))->is_independent());
   for (size_t i = 0; i < length; ++i) {
     ASSERT(!Node::FromLocation(children[i])->is_independent());
   }
 #endif
-  for (size_t i = 0; i < length; ++i) {
-    implicit_ref_groups_.Add(ObjectGroupConnection(
-        UniqueId(reinterpret_cast<intptr_t>(parent)), children[i]));
-  }
-}
-
-
-void GlobalHandles::AddImplicitReference(UniqueId id, Object** child) {
-  ASSERT(!Node::FromLocation(child)->is_independent());
-  implicit_ref_groups_.Add(ObjectGroupConnection(id, child));
+  if (length == 0) return;
+  implicit_ref_groups_.Add(ImplicitRefGroup::New(parent, children, length));
 }
 
 
 void GlobalHandles::RemoveObjectGroups() {
+  for (int i = 0; i < object_groups_.length(); i++) {
+    object_groups_.at(i)->Dispose();
+  }
   object_groups_.Clear();
-  for (int i = 0; i < retainer_infos_.length(); ++i) {
-    if (retainer_infos_[i].info != NULL)
-      retainer_infos_[i].info->Dispose();
-  }
-  retainer_infos_.Clear();
 }
 
 
 void GlobalHandles::RemoveImplicitRefGroups() {
-  representative_objects_.Clear();
+  for (int i = 0; i < implicit_ref_groups_.length(); i++) {
+    implicit_ref_groups_.at(i)->Dispose();
+  }
   implicit_ref_groups_.Clear();
 }
 
 
 void GlobalHandles::TearDown() {
   // TODO(1428): invoke weak callbacks.
 }
 
 
 } }  // namespace v8::internal