Add a second kind of HandleScope that ties the lifetime of Handles created in its scope to the life…

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 391 matching lines @@
 // 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) { }
+        call_depth_(0),
+        last_non_persistent_block_(NULL),
+        last_non_persistent_handle_(NULL),
+        persistent_extensions_head_(NULL) { }
 
   ~HandleScopeImplementer() {
     DeleteArray(spare_);
   }
 
   // Threading support for handle data.
   static int ArchiveSpacePerThread();
   char* RestoreThread(char* from);
   char* ArchiveThread(char* to);
   void FreeThreadResources();
 
   // Garbage collection support.
   void Iterate(v8::internal::ObjectVisitor* v);
   static char* Iterate(v8::internal::ObjectVisitor* v, char* data);
 
+  struct PersistentExtensions {

[danno, 2012/06/24 11:07:03]

Perhaps DeferredReleaseHandleScope?

+    List<Object**> blocks;
+    Object** last_block_end;
+    PersistentExtensions* previous;
+    PersistentExtensions* next;
+  };
 
   inline internal::Object** GetSpareOrNewBlock();
   inline void DeleteExtensions(internal::Object** prev_limit);
 
+  // HideExtensions must be called _before_ the next field in
+  // HandleScopeData is reverted.
+  PersistentExtensions* PersistExtensions(internal::Object** prev_limit);

[danno, 2012/06/24 11:07:03]

BeginDeferredHandleScope?

+  void ReleaseExtensions(PersistentExtensions* extension);

[danno, 2012/06/24 11:07:03]

Should be a private method only called by the DeferredReleaseHandleScopes'
destructor.

+
   inline void IncrementCallDepth() {call_depth_++;}
   inline void DecrementCallDepth() {call_depth_--;}
   inline bool CallDepthIsZero() { return call_depth_ == 0; }
 
   inline void EnterContext(Handle<Object> context);
   inline bool LeaveLastContext();
 
   // Returns the last entered context or an empty handle if no
   // 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_; }
 
+  void begin_persistence() {

[danno, 2012/06/24 11:07:03]

I think you can merge this with PersistExtensions if it becomes
BeginDeferredHandleScope.

+    // We only track one such special block.
+    ASSERT(!last_non_persistent_block_);
+    last_non_persistent_block_ = blocks_.last();
+    last_non_persistent_handle_ = isolate_->handle_scope_data()->next;
+  }
+
+  void end_persistence() {

[danno, 2012/06/24 11:07:03]

This should by a private method called "DeferHandleScope" that is only called by
the "Defer" method on the DeferredHandleScope, which itself should only be
called by the CompilationHandleScopes's DetachHandles method.

+    ASSERT(last_non_persistent_block_);
+    last_non_persistent_block_ = NULL;
+    last_non_persistent_handle_ = NULL;
+  }
+
  private:
   void ResetAfterArchive() {
     blocks_.Initialize(0);
     entered_contexts_.Initialize(0);
     saved_contexts_.Initialize(0);
     spare_ = NULL;
     call_depth_ = 0;
   }
 
   void Free() {
@@ skipping 13 matching lines @@
   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_;
   // This is only used for threading support.
   v8::ImplementationUtilities::HandleScopeData handle_scope_data_;
+  Object** last_non_persistent_block_;
+  Object** last_non_persistent_handle_;
+  PersistentExtensions* persistent_extensions_head_;
 
   void IterateThis(ObjectVisitor* v);
   char* RestoreThreadHelper(char* from);
   char* ArchiveThreadHelper(char* to);
 
   DISALLOW_COPY_AND_ASSIGN(HandleScopeImplementer);
 };
 
 
 const int kHandleBlockSize = v8::internal::KB - 2;  // fit in one page
@@ skipping 74 matching lines @@
     stress_type_ = stress_type;
   }
 
  private:
   static v8::Testing::StressType stress_type_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_API_H_