Move promises recorded for debugging to thread local data.

src/debug.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_DEBUG_H_
 #define V8_DEBUG_H_
 
 #include "allocation.h"
 #include "arguments.h"
 #include "assembler.h"
@@ skipping 501 matching lines @@
   // Cache of all scripts in the heap.
   ScriptCache* script_cache_;
 
   // List of active debug info objects.
   DebugInfoListNode* debug_info_list_;
 
   bool disable_break_;
   bool break_on_exception_;
   bool break_on_uncaught_exception_;
 
-  // When a promise is being resolved, we may want to trigger a debug event for
-  // the case we catch a throw.  For this purpose we remember the try-catch
-  // handler address that would catch the exception.  We also hold onto a
-  // closure that returns a promise if the exception is considered uncaught.
-  // Due to the possibility of reentry we use a list to form a stack.
-  List<StackHandler*> promise_catch_handlers_;
-  List<Handle<JSFunction> > promise_getters_;
+  class PromiseOnStack {
+   public:
+    PromiseOnStack(Isolate* isolate,
+                   PromiseOnStack* prev,
+                   Handle<JSFunction> getter);
+    ~PromiseOnStack();
+    StackHandler* handler() { return handler_; }
+    Handle<JSFunction> getter() { return getter_; }
+    PromiseOnStack* prev() { return prev_; }
+   private:
+    Isolate* isolate_;
+    StackHandler* handler_;
+    Handle<JSFunction> getter_;
+    PromiseOnStack* prev_;
+  };
 
   // Per-thread data.
   class ThreadLocal {
    public:
     // Counter for generating next break id.
     int break_count_;
 
     // Current break id.
     int break_id_;
 
@@ skipping 32 matching lines @@
     // Top debugger entry.
     EnterDebugger* debugger_entry_;
 
     // Pending interrupts scheduled while debugging.
     bool has_pending_interrupt_;
 
     // When restarter frame is on stack, stores the address
     // of the pointer to function being restarted. Otherwise (most of the time)
     // stores NULL. This pointer is used with 'step in' implementation.
     Object** restarter_frame_function_pointer_;
+
+    // When a promise is being resolved, we may want to trigger a debug event
+    // if we catch a throw.  For this purpose we remember the try-catch
+    // handler address that would catch the exception.  We also hold onto a
+    // closure that returns a promise if the exception is considered uncaught.
+    // Due to the possibility of reentry we use a linked list.
+    PromiseOnStack* promise_on_stack_;
   };
 
   // Storage location for registers when handling debug break calls
   ThreadLocal thread_local_;
   void ThreadInit();
 
   Isolate* isolate_;
 
   friend class Isolate;
 
@@ skipping 350 matching lines @@
     }
   }
 
  private:
   Debug::AddressId id_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEBUG_H_