Revert "Simplify debugger state."

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 472 matching lines @@
     // A number of words that should be reserved on stack for the LiveEdit use.
     // Normally equals 1. Stored on stack in form of Smi.
     static const int kInitialSize;
     // A value that padding words are filled with (in form of Smi). Going
     // bottom-top, the first word not having this value is a counter word.
     static const int kPaddingValue;
   };
 
  private:
   explicit Debug(Isolate* isolate);
+  ~Debug();
 
   static bool CompileDebuggerScript(Isolate* isolate, int index);
   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);
   void SetAfterBreakTarget(JavaScriptFrame* frame);
@@ skipping 232 matching lines @@
  private:
   Logger* logger_;
   CommandMessageQueue queue_;
   mutable Mutex mutex_;
   DISALLOW_COPY_AND_ASSIGN(LockingCommandMessageQueue);
 };
 
 
 class Debugger {
  public:
+  ~Debugger();
+
+  void DebugRequest(const uint16_t* json_request, int length);
+
+  MUST_USE_RESULT MaybeHandle<Object> MakeJSObject(
+      Vector<const char> constructor_name,
+      int argc,
+      Handle<Object> argv[]);
+  MUST_USE_RESULT MaybeHandle<Object> MakeExecutionState();
+  MUST_USE_RESULT MaybeHandle<Object> MakeBreakEvent(
+      Handle<Object> break_points_hit);
+  MUST_USE_RESULT MaybeHandle<Object> MakeExceptionEvent(
+      Handle<Object> exception,
+      bool uncaught,
+      Handle<Object> promise);
+  MUST_USE_RESULT MaybeHandle<Object> MakeCompileEvent(
+      Handle<Script> script, bool before);
+  MUST_USE_RESULT MaybeHandle<Object> MakeScriptCollectedEvent(int id);
+
   void OnDebugBreak(Handle<Object> break_points_hit, bool auto_continue);
   void OnException(Handle<Object> exception, bool uncaught);
   void OnBeforeCompile(Handle<Script> script);
 
   enum AfterCompileFlags {
     NO_AFTER_COMPILE_FLAGS,
     SEND_WHEN_DEBUGGING
   };
   void OnAfterCompile(Handle<Script> script,
                       AfterCompileFlags after_compile_flags);
   void OnScriptCollected(int id);
-
+  void ProcessDebugEvent(v8::DebugEvent event,
+                         Handle<JSObject> event_data,
+                         bool auto_continue);
+  void NotifyMessageHandler(v8::DebugEvent event,
+                            Handle<JSObject> exec_state,
+                            Handle<JSObject> event_data,
+                            bool auto_continue);
   void SetEventListener(Handle<Object> callback, Handle<Object> data);
   void SetMessageHandler(v8::Debug::MessageHandler handler);
 
   // Add a debugger command to the command queue.
   void EnqueueCommandMessage(Vector<const uint16_t> command,
                              v8::Debug::ClientData* client_data = NULL);
 
   // Check whether there are commands in the command queue.
   bool HasCommands();
 
   // Enqueue a debugger command to the command queue for event listeners.
   void EnqueueDebugCommand(v8::Debug::ClientData* client_data = NULL);
 
   MUST_USE_RESULT MaybeHandle<Object> Call(Handle<JSFunction> fun,
                                            Handle<Object> data);
 
   Handle<Context> GetDebugContext();
 
+  // Unload the debugger if possible. Only called when no debugger is currently
+  // active.
+  void UnloadDebugger();
+  friend void ForceUnloadDebugger();  // In test-debug.cc
+
+  inline bool EventActive() {
+    LockGuard<RecursiveMutex> lock_guard(&debugger_access_);
+
+    // Check whether the message handler was been cleared.
+    // TODO(yangguo): handle loading and unloading of the debugger differently.
+    if (debugger_unload_pending_) {
+      if (isolate_->debug()->debugger_entry() == NULL) {
+        UnloadDebugger();
+      }
+    }
+
+    // Currently argument event is not used.
+    return !ignore_debugger_ && is_active_;
+  }
+
   bool ignore_debugger() const { return ignore_debugger_; }
   void set_live_edit_enabled(bool v) { live_edit_enabled_ = v; }
   bool live_edit_enabled() const {
     return FLAG_enable_liveedit && live_edit_enabled_ ;
   }
 
-  bool is_active() { return is_active_; }
+  bool is_active() {
+    LockGuard<RecursiveMutex> lock_guard(&debugger_access_);
+    return is_active_;
+  }
 
   class IgnoreScope {
    public:
     explicit IgnoreScope(Debugger* debugger)
         : debugger_(debugger),
           old_state_(debugger_->ignore_debugger_) {
       debugger_->ignore_debugger_ = true;
     }
 
     ~IgnoreScope() {
       debugger_->ignore_debugger_ = old_state_;
     }
 
    private:
     Debugger* debugger_;
     bool old_state_;
     DISALLOW_COPY_AND_ASSIGN(IgnoreScope);
   };
 
  private:
   explicit Debugger(Isolate* isolate);
-  ~Debugger();
-
-  MUST_USE_RESULT MaybeHandle<Object> MakeJSObject(
-      Vector<const char> constructor_name,
-      int argc,
-      Handle<Object> argv[]);
-  MUST_USE_RESULT MaybeHandle<Object> MakeExecutionState();
-  MUST_USE_RESULT MaybeHandle<Object> MakeBreakEvent(
-      Handle<Object> break_points_hit);
-  MUST_USE_RESULT MaybeHandle<Object> MakeExceptionEvent(
-      Handle<Object> exception,
-      bool uncaught,
-      Handle<Object> promise);
-  MUST_USE_RESULT MaybeHandle<Object> MakeCompileEvent(
-      Handle<Script> script, bool before);
-  MUST_USE_RESULT MaybeHandle<Object> MakeScriptCollectedEvent(int id);
 
   void CallEventCallback(v8::DebugEvent event,
                          Handle<Object> exec_state,
                          Handle<Object> event_data,
                          v8::Debug::ClientData* client_data);
   void CallCEventCallback(v8::DebugEvent event,
                           Handle<Object> exec_state,
                           Handle<Object> event_data,
                           v8::Debug::ClientData* client_data);
   void CallJSEventCallback(v8::DebugEvent event,
                            Handle<Object> exec_state,
                            Handle<Object> event_data);
-  void UpdateState();
-
-  void ProcessDebugEvent(v8::DebugEvent event,
-                         Handle<JSObject> event_data,
-                         bool auto_continue);
-  void NotifyMessageHandler(v8::DebugEvent event,
-                            Handle<JSObject> exec_state,
-                            Handle<JSObject> event_data,
-                            bool auto_continue);
+  void ListenersChanged();
 
   // Invoke the message handler function.
   void InvokeMessageHandler(MessageImpl message);
 
-  inline bool EventActive() {
-    // Check whether the message handler was been cleared.
-    // TODO(yangguo): handle loading and unloading of the debugger differently.
-    // Currently argument event is not used.
-    return !ignore_debugger_ && is_active_;
-  }
-
+  RecursiveMutex debugger_access_;  // Mutex guarding debugger variables.
   Handle<Object> event_listener_;  // Global handle to listener.
   Handle<Object> event_listener_data_;
   bool is_active_;
   bool ignore_debugger_;  // Are we temporarily ignoring the debugger?
   bool live_edit_enabled_;  // Enable LiveEdit.
+  bool never_unload_debugger_;  // Can we unload the debugger?
   v8::Debug::MessageHandler message_handler_;
   bool debugger_unload_pending_;  // Was message handler cleared?
 
   static const int kQueueInitialSize = 4;
   LockingCommandMessageQueue command_queue_;
   Semaphore command_received_;  // Signaled for each command received.
   LockingCommandMessageQueue event_command_queue_;
 
   Isolate* isolate_;
 
@@ skipping 18 matching lines @@
 
   // Check whether there are any JavaScript frames on the stack.
   inline bool HasJavaScriptFrames() { return has_js_frames_; }
 
   // 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.
-  bool has_js_frames_;  // Were there any JavaScript frames?
+  JavaScriptFrameIterator it_;
+  const bool has_js_frames_;  // Were there any JavaScript frames?
   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.
 };
 
 
 // Stack allocated class for disabling break.
 class DisableBreak BASE_EMBEDDED {
  public:
@@ skipping 42 matching lines @@
     }
   }
 
  private:
   Debug::AddressId id_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEBUG_H_