Rename EnterDebugger to DebugScope.

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"
 #include "execution.h"
 #include "factory.h"
 #include "flags.h"
 #include "frames-inl.h"
 #include "hashmap.h"
 #include "liveedit.h"
 #include "platform.h"
 #include "string-stream.h"
 #include "v8threads.h"
 
 #include "../include/v8-debug.h"
 
 namespace v8 {
 namespace internal {
 
 
 // Forward declarations.
-class EnterDebugger;
+class DebugScope;
 
 
 // Step actions. NOTE: These values are in macros.py as well.
 enum StepAction {
   StepNone = -1,  // Stepping not prepared.
   StepOut = 0,   // Step out of the current function.
   StepNext = 1,  // Step to the next statement in the current function.
   StepIn = 2,    // Step into new functions invoked or the next statement
                  // in the current function.
   StepMin = 3,   // Perform a minimum step in the current function.
@@ skipping 440 matching lines @@
   static int ArchiveSpacePerThread();
   void FreeThreadResources() { }
 
   // Record function from which eval was called.
   static void RecordEvalCaller(Handle<Script> script);
 
   // Garbage collection notifications.
   void AfterGarbageCollection();
 
   // Flags and states.
-  EnterDebugger* debugger_entry() { return thread_local_.debugger_entry_; }
+  DebugScope* debugger_entry() { return thread_local_.current_debug_scope_; }
   inline Handle<Context> debug_context() { return debug_context_; }
   void set_live_edit_enabled(bool v) { live_edit_enabled_ = v; }
   bool live_edit_enabled() const {
     return FLAG_enable_liveedit && live_edit_enabled_ ;
   }
 
   inline bool is_active() const { return is_active_; }
   inline bool is_loaded() const { return !debug_context_.is_null(); }
   inline bool has_break_points() const { return has_break_points_; }
-  inline bool is_entered() const {
-    return thread_local_.debugger_entry_ != NULL;
+  inline bool in_debug_scope() const {
+    return thread_local_.current_debug_scope_ != NULL;
   }
   void set_disable_break(bool v) { break_disabled_ = v; }
 
   StackFrame::Id break_frame_id() { return thread_local_.break_frame_id_; }
   int break_id() { return thread_local_.break_id_; }
 
   // Support for embedding into generated code.
   Address after_break_target_address() {
     return reinterpret_cast<Address>(&after_break_target_);
   }
@@ skipping 59 matching lines @@
   void ClearOneShot();
   void ActivateStepIn(StackFrame* frame);
   void ClearStepIn();
   void ActivateStepOut(StackFrame* frame);
   void ClearStepNext();
   // Returns whether the compile succeeded.
   void RemoveDebugInfo(Handle<DebugInfo> debug_info);
   Handle<Object> CheckBreakPoints(Handle<Object> break_point);
   bool CheckBreakPoint(Handle<Object> break_point_object);
 
+  inline void AssertDebugContext() {
+    ASSERT(isolate_->context() == *debug_context());
+    ASSERT(in_debug_scope());
+  }
+
   void ThreadInit();
 
   // Global handles.
   Handle<Context> debug_context_;
   Handle<Object> event_listener_;
   Handle<Object> event_listener_data_;
 
   v8::Debug::MessageHandler message_handler_;
 
   static const int kQueueInitialSize = 4;
@@ skipping 14 matching lines @@
 
   // Storage location for jump when exiting debug break calls.
   // Note that this address is not GC safe.  It should be computed immediately
   // before returning to the DebugBreakCallHelper.
   Address after_break_target_;
 
   // Per-thread data.
   class ThreadLocal {
    public:
     // Top debugger entry.
-    EnterDebugger* debugger_entry_;
+    DebugScope* current_debug_scope_;
 
     // Counter for generating next break id.
     int break_count_;
 
     // Current break id.
     int break_id_;
 
     // Frame id for the frame of the current break.
     StackFrame::Id break_frame_id_;
 
@@ skipping 35 matching lines @@
     // 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_;
 
   Isolate* isolate_;
 
   friend class Isolate;
-  friend class EnterDebugger;
-  friend class FrameDropper;
+  friend class DebugScope;
   friend class DisableBreak;
   friend class SuppressDebug;
 
   friend Handle<FixedArray> GetDebuggedFunctions();  // In test-debug.cc
   friend void CheckDebuggerUnloaded(bool check_functions);  // In test-debug.cc
 
   DISALLOW_COPY_AND_ASSIGN(Debug);
 };
 
 
 DECLARE_RUNTIME_FUNCTION(Debug_Break);
 
 
-// This class is used for entering the debugger. Create an instance in the stack
-// to enter the debugger. This will set the current break state, make sure the
-// debugger is loaded and switch to the debugger context. If the debugger for
-// some reason could not be entered FailedToEnter will return true.
-class EnterDebugger BASE_EMBEDDED {
+// This scope is used to load and enter the debug context and create a new
+// break state.  Leaving the scope will restore the previous state.
+// On failure to load, FailedToEnter returns true.
+class DebugScope BASE_EMBEDDED {
  public:
-  explicit EnterDebugger(Isolate* isolate);
-  ~EnterDebugger();
+  explicit DebugScope(Debug* debug);
+  ~DebugScope();
 
-  // Check whether the debugger could be entered.
-  inline bool FailedToEnter() { return load_failed_; }
+  // Check whether loading was successful.
+  inline bool failed() { return failed_; }
 
   // Get the active context from before entering the debugger.
   inline Handle<Context> GetContext() { return save_.context(); }
 
  private:
-  Isolate* isolate_;
-  EnterDebugger* prev_;  // Previous debugger entry if entered recursively.
+  Isolate* isolate() { return debug_->isolate_; }
+
+  Debug* debug_;
+  DebugScope* prev_;               // Previous scope if entered recursively.
   StackFrame::Id break_frame_id_;  // Previous break frame id.
-  int break_id_;  // Previous break id.
-  bool load_failed_;  // Did the debugger fail to load?
-  SaveContext save_;  // Saves previous context.
+  int break_id_;                   // Previous break id.
+  bool failed_;                    // Did the debug context fail to load?
+  SaveContext save_;               // Saves previous context.
 };
 
 
 // Stack allocated class for disabling break.
 class DisableBreak BASE_EMBEDDED {
  public:
   explicit DisableBreak(Debug* debug, bool disable_break)
     : debug_(debug), old_state_(debug->break_disabled_) {
     debug_->break_disabled_ = disable_break;
   }
@@ skipping 42 matching lines @@
   // several frames above.
   // There is no calling conventions here, because it never actually gets
   // called, it only gets returned to.
   static void GenerateFrameDropperLiveEdit(MacroAssembler* masm);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEBUG_H_