The deferred handes list belongs to the Isolate and not to the

src/api.h

 // Copyright 2012 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 379 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(StringTracker);
 };
 
 
 class DeferredHandles {
  public:
   ~DeferredHandles();
 
  private:
-  DeferredHandles(DeferredHandles* next, Object** first_block_limit,
-                  HandleScopeImplementer* impl)
-      : next_(next),
+  DeferredHandles(Object** first_block_limit, Isolate* isolate)
+      : next_(isolate->deferred_handles_head_),
         previous_(NULL),
         first_block_limit_(first_block_limit),
-        impl_(impl) {
-    if (next != NULL) next->previous_ = this;
+        isolate_(isolate) {
+    if (next_ != NULL) next_->previous_ = this;
+    isolate->deferred_handles_head_ = this;

[danno, 2012/07/18 13:36:17]

I don't think you should reach into the isolate like this. Expose a protected
next()/previous() and set_next()/set_previous() method on the deferred handles.
From the constructor here, you should call
isolate->RegisterDeferredHandles(this) or something of the like. The
"friendness" should only go in one direction.

[sanjoy, 2012/07/18 14:00:43]

Done.

   }
 
   void Iterate(ObjectVisitor* v);
 
   List<Object**> blocks_;
   DeferredHandles* next_;
   DeferredHandles* previous_;
   Object** first_block_limit_;
-  HandleScopeImplementer* impl_;
+  Isolate* isolate_;
 
   friend class HandleScopeImplementer;
+  friend class Isolate;
 };
 
 
 // This class is here in order to be able to declare it a friend of
 // HandleScope.  Moving these methods to be members of HandleScope would be
 // neat in some ways, but it would expose internal implementation details in
 // our public header file, which is undesirable.
 //
 // An isolate has a single instance of this class to hold the current thread's
 // data. In multithreaded V8 programs this data is copied in and out of storage
 // so that the currently executing thread always has its own copy of this
 // data.
 class HandleScopeImplementer {
  public:
   explicit HandleScopeImplementer(Isolate* isolate)
       : isolate_(isolate),
         blocks_(0),
         entered_contexts_(0),
         saved_contexts_(0),
         spare_(NULL),
         call_depth_(0),
-        last_handle_before_deferred_block_(NULL),
-        deferred_handles_head_(NULL) { }
+        last_handle_before_deferred_block_(NULL) { }
 
   ~HandleScopeImplementer() {
     DeleteArray(spare_);
   }
 
   // Threading support for handle data.
   static int ArchiveSpacePerThread();
   char* RestoreThread(char* from);
   char* ArchiveThread(char* to);
   void FreeThreadResources();
@@ skipping 17 matching lines @@
   // contexts have been entered.
   inline Handle<Object> LastEnteredContext();
 
   inline void SaveContext(Context* context);
   inline Context* RestoreContext();
   inline bool HasSavedContexts();
 
   inline List<internal::Object**>* blocks() { return &blocks_; }
   Isolate* isolate() const { return isolate_; }
 
+  void ReturnBlock(Object** block) {
+    ASSERT(block != NULL);
+    if (spare_ != NULL) DeleteArray(spare_);
+    spare_ = block;
+  }
+
  private:
   void ResetAfterArchive() {
     blocks_.Initialize(0);
     entered_contexts_.Initialize(0);
     saved_contexts_.Initialize(0);
     spare_ = NULL;
-    deferred_handles_head_ = NULL;
     last_handle_before_deferred_block_ = NULL;
     call_depth_ = 0;
   }
 
   void Free() {
     ASSERT(blocks_.length() == 0);
     ASSERT(entered_contexts_.length() == 0);
     ASSERT(saved_contexts_.length() == 0);
-    ASSERT(deferred_handles_head_ == NULL);
     blocks_.Free();
     entered_contexts_.Free();
     saved_contexts_.Free();
     if (spare_ != NULL) {
       DeleteArray(spare_);
       spare_ = NULL;
     }
     ASSERT(call_depth_ == 0);
   }
 
   void BeginDeferredScope();
   DeferredHandles* Detach(Object** prev_limit);
-  void DestroyDeferredHandles(DeferredHandles* handles);
 
   Isolate* isolate_;
   List<internal::Object**> blocks_;
   // Used as a stack to keep track of entered contexts.
   List<Handle<Object> > entered_contexts_;
   // Used as a stack to keep track of saved contexts.
   List<Context*> saved_contexts_;
   Object** spare_;
   int call_depth_;
   Object** last_handle_before_deferred_block_;
-  DeferredHandles* deferred_handles_head_;
   // This is only used for threading support.
   v8::ImplementationUtilities::HandleScopeData handle_scope_data_;
 
   void IterateThis(ObjectVisitor* v);
   char* RestoreThreadHelper(char* from);
   char* ArchiveThreadHelper(char* to);
 
   friend class DeferredHandles;
   friend class DeferredHandleScope;
 
@@ skipping 79 matching lines @@
     stress_type_ = stress_type;
   }
 
  private:
   static v8::Testing::StressType stress_type_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_API_H_