Index: include/v8-debug.h |
diff --git a/include/v8-debug.h b/include/v8-debug.h |
index 7100925b3a700e18f4e2eafae41aa530533795ac..777b8aaa3e645a1c6024d46ebab5bbc70754cd1b 100644 |
--- a/include/v8-debug.h |
+++ b/include/v8-debug.h |
@@ -24,21 +24,45 @@ |
class V8_EXPORT Debug { |
public: |
/** |
- * An event details object passed to the debug event listener. |
- */ |
- class EventDetails { |
+ * A client object passed to the v8 debugger whose ownership will be taken by |
+ * it. v8 is always responsible for deleting the object. |
+ */ |
+ class ClientData { |
public: |
- /** |
- * Event type. |
- */ |
+ virtual ~ClientData() {} |
+ }; |
+ |
+ |
+ /** |
+ * A message object passed to the debug message handler. |
+ */ |
+ class Message { |
+ public: |
+ /** |
+ * Check type of message. |
+ */ |
+ virtual bool IsEvent() const = 0; |
+ virtual bool IsResponse() const = 0; |
virtual DebugEvent GetEvent() const = 0; |
/** |
- * Access to execution state and event data of the debug event. Don't store |
- * these cross callbacks as their content becomes invalid. |
+ * Indicate whether this is a response to a continue command which will |
+ * start the VM running after this is processed. |
+ */ |
+ virtual bool WillStartRunning() const = 0; |
+ |
+ /** |
+ * Access to execution state and event data. Don't store these cross |
+ * callbacks as their content becomes invalid. These objects are from the |
+ * debugger event that started the debug message loop. |
*/ |
virtual Local<Object> GetExecutionState() const = 0; |
virtual Local<Object> GetEventData() const = 0; |
+ |
+ /** |
+ * Get the debugger protocol JSON. |
+ */ |
+ virtual Local<String> GetJSON() const = 0; |
/** |
* Get the context active when the debug event happened. Note this is not |
@@ -48,11 +72,56 @@ |
virtual Local<Context> GetEventContext() const = 0; |
/** |
+ * Client data passed with the corresponding request if any. This is the |
+ * client_data data value passed into Debug::SendCommand along with the |
+ * request that led to the message or NULL if the message is an event. The |
+ * debugger takes ownership of the data and will delete it even if there is |
+ * no message handler. |
+ */ |
+ virtual ClientData* GetClientData() const = 0; |
+ |
+ virtual Isolate* GetIsolate() const = 0; |
+ |
+ virtual ~Message() {} |
+ }; |
+ |
+ /** |
+ * An event details object passed to the debug event listener. |
+ */ |
+ class EventDetails { |
+ public: |
+ /** |
+ * Event type. |
+ */ |
+ virtual DebugEvent GetEvent() const = 0; |
+ |
+ /** |
+ * Access to execution state and event data of the debug event. Don't store |
+ * these cross callbacks as their content becomes invalid. |
+ */ |
+ virtual Local<Object> GetExecutionState() const = 0; |
+ virtual Local<Object> GetEventData() const = 0; |
+ |
+ /** |
+ * Get the context active when the debug event happened. Note this is not |
+ * the current active context as the JavaScript part of the debugger is |
+ * running in its own context which is entered at this point. |
+ */ |
+ virtual Local<Context> GetEventContext() const = 0; |
+ |
+ /** |
* Client data passed with the corresponding callback when it was |
* registered. |
*/ |
virtual Local<Value> GetCallbackData() const = 0; |
+ /** |
+ * Client data passed to DebugBreakForCommand function. The |
+ * debugger takes ownership of the data and will delete it even if |
+ * there is no message handler. |
+ */ |
+ virtual ClientData* GetClientData() const = 0; |
+ |
virtual Isolate* GetIsolate() const = 0; |
virtual ~EventDetails() {} |
@@ -63,10 +132,25 @@ |
* |
* \param event_details object providing information about the debug event |
* |
- * A EventCallback does not take possession of the event data, |
+ * A EventCallback2 does not take possession of the event data, |
* and must not rely on the data persisting after the handler returns. |
*/ |
typedef void (*EventCallback)(const EventDetails& event_details); |
+ |
+ /** |
+ * Debug message callback function. |
+ * |
+ * \param message the debug message handler message object |
+ * |
+ * A MessageHandler does not take possession of the message data, |
+ * and must not rely on the data persisting after the handler returns. |
+ */ |
+ typedef void (*MessageHandler)(const Message& message); |
+ |
+ /** |
+ * Callback function for the host to ensure debug messages are processed. |
+ */ |
+ typedef void (*DebugMessageDispatchHandler)(); |
static bool SetDebugEventListener(Isolate* isolate, EventCallback that, |
Local<Value> data = Local<Value>()); |
@@ -82,6 +166,16 @@ |
// Check if a debugger break is scheduled in the given isolate. |
V8_DEPRECATED("No longer supported", |
static bool CheckDebugBreak(Isolate* isolate)); |
+ |
+ // Message based interface. The message protocol is JSON. |
+ V8_DEPRECATED("No longer supported", |
+ static void SetMessageHandler(Isolate* isolate, |
+ MessageHandler handler)); |
+ |
+ V8_DEPRECATED("No longer supported", |
+ static void SendCommand(Isolate* isolate, |
+ const uint16_t* command, int length, |
+ ClientData* client_data = NULL)); |
/** |
* Run a JavaScript function in the debugger. |
@@ -114,6 +208,40 @@ |
v8::Local<v8::Value> obj)); |
/** |
+ * Makes V8 process all pending debug messages. |
+ * |
+ * From V8 point of view all debug messages come asynchronously (e.g. from |
+ * remote debugger) but they all must be handled synchronously: V8 cannot |
+ * do 2 things at one time so normal script execution must be interrupted |
+ * for a while. |
+ * |
+ * Generally when message arrives V8 may be in one of 3 states: |
+ * 1. V8 is running script; V8 will automatically interrupt and process all |
+ * pending messages; |
+ * 2. V8 is suspended on debug breakpoint; in this state V8 is dedicated |
+ * to reading and processing debug messages; |
+ * 3. V8 is not running at all or has called some long-working C++ function; |
+ * by default it means that processing of all debug messages will be deferred |
+ * until V8 gets control again; however, embedding application may improve |
+ * this by manually calling this method. |
+ * |
+ * Technically this method in many senses is equivalent to executing empty |
+ * script: |
+ * 1. It does nothing except for processing all pending debug messages. |
+ * 2. It should be invoked with the same precautions and from the same context |
+ * as V8 script would be invoked from, because: |
+ * a. with "evaluate" command it can do whatever normal script can do, |
+ * including all native calls; |
+ * b. no other thread should call V8 while this method is running |
+ * (v8::Locker may be used here). |
+ * |
+ * "Evaluate" debug command behavior currently is not specified in scope |
+ * of this method. |
+ */ |
+ V8_DEPRECATED("No longer supported", |
+ static void ProcessDebugMessages(Isolate* isolate)); |
+ |
+ /** |
* Debugger is running in its own context which is entered while debugger |
* messages are being dispatched. This is an explicit getter for this |
* debugger context. Note that the content of the debugger context is subject |