Remove DebuggerAgent.

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 "debug-agent.h"
 #include "execution.h"
 #include "factory.h"
 #include "flags.h"
 #include "frames-inl.h"
 #include "hashmap.h"
 #include "platform.h"
 #include "string-stream.h"
 #include "v8threads.h"
 
 #include "../include/v8-debug.h"
@@ skipping 754 matching lines @@
   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::MessageHandler2 handler);
-  void SetDebugMessageDispatchHandler(
-      v8::Debug::DebugMessageDispatchHandler handler,
-      bool provide_locker);
-
-  // Invoke the message handler function.
-  void InvokeMessageHandler(MessageImpl message);
 
   // Add a debugger command to the command queue.
-  void ProcessCommand(Vector<const uint16_t> command,
-                      v8::Debug::ClientData* client_data = NULL);
+  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);
 
-  // Start the debugger agent listening on the provided port.
-  bool StartAgent(const char* name, int port,
-                  bool wait_for_connection = false);
-
-  // Stop the debugger agent.
-  void StopAgent();
-
-  // Blocks until the agent has started listening for connections
-  void WaitForAgent();
-
-  void CallMessageDispatchHandler();
-
   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_);
 
@@ skipping 47 matching lines @@
                          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 ListenersChanged();
 
+  // Invoke the message handler function.
+  void InvokeMessageHandler(MessageImpl message);
+
   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::MessageHandler2 message_handler_;
   bool debugger_unload_pending_;  // Was message handler cleared?
 
-  Mutex dispatch_handler_access_;  // Mutex guarding dispatch handler.
-  v8::Debug::DebugMessageDispatchHandler debug_message_dispatch_handler_;
-  MessageDispatchHelperThread* message_dispatch_helper_thread_;
-
-  DebuggerAgent* agent_;
-
   static const int kQueueInitialSize = 4;
   LockingCommandMessageQueue command_queue_;
   Semaphore command_received_;  // Signaled for each command received.
   LockingCommandMessageQueue event_command_queue_;
 
   Isolate* isolate_;
 
   friend class EnterDebugger;
   friend class Isolate;
 
@@ skipping 76 matching lines @@
       default:
         UNREACHABLE();
         return NULL;
     }
   }
 
  private:
   Debug::AddressId id_;
 };
 
-// The optional thread that Debug Agent may use to temporary call V8 to process
-// pending debug requests if debuggee is not running V8 at the moment.
-// Techincally it does not call V8 itself, rather it asks embedding program
-// to do this via v8::Debug::HostDispatchHandler
-class MessageDispatchHelperThread: public Thread {
- public:
-  explicit MessageDispatchHelperThread(Isolate* isolate);
-  ~MessageDispatchHelperThread() {}
-
-  void Schedule();
-
- private:
-  void Run();
-
-  Isolate* isolate_;
-  Semaphore sem_;
-  Mutex mutex_;
-  bool already_signalled_;
-
-  DISALLOW_COPY_AND_ASSIGN(MessageDispatchHelperThread);
-};
-
-
 } }  // namespace v8::internal
 
 #endif  // V8_DEBUG_H_