[inspector] introduced debug::SetBreakEventListener,SetExceptionEventListener

src/debug/debug-interface.h

 // Copyright 2016 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_DEBUG_INTERFACE_H_
 #define V8_DEBUG_DEBUG_INTERFACE_H_
 
 #include <functional>
 
 #include "include/v8-debug.h"
 #include "include/v8-util.h"
 #include "include/v8.h"
 
 #include "src/debug/interface-types.h"
 
 namespace v8 {
 namespace debug {
 
 /**
- * An event details object passed to the debug event listener.
- */
-class EventDetails : public v8::Debug::EventDetails {
- public:
-  /**
-   * Event type.
-   */
-  virtual v8::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;
-
-  virtual ~EventDetails() {}
-};
-
-/**
- * Debug event callback function.
- *
- * \param event_details object providing information about the debug event
- *
- * A EventCallback 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);
-
-bool SetDebugEventListener(Isolate* isolate, EventCallback that,
-                           Local<Value> data = Local<Value>());
-
-/**
  * 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
  * to change. The Context exists only when the debugger is active, i.e. at
  * least one DebugEventListener or MessageHandler is set.
  */
 Local<Context> GetDebugContext(Isolate* isolate);
 
 /**
  * Run a JavaScript function in the debugger.
@@ skipping 122 matching lines @@
     AsyncTaskListener;
 void SetAsyncTaskListener(Isolate* isolate, AsyncTaskListener listener,
                           void* data);
 
 typedef std::function<void(v8::Local<Script> script, bool has_compile_error,
                            void* data)>
     CompileEventListener;
 void SetCompileEventListener(Isolate* isolate, CompileEventListener listener,
                              void* data);
 
+typedef void (*BreakEventListener)(v8::Local<v8::Context> paused_context,
+                                   v8::Local<v8::Object> exec_state,
+                                   v8::Local<v8::Value> break_points_hit,
+                                   void* data);
+void SetBreakEventListener(Isolate* isolate, BreakEventListener listener,
+                           void* data);
+
+typedef void (*ExceptionEventListener)(v8::Local<v8::Context> paused_context,
+                                       v8::Local<v8::Object> exec_state,
+                                       v8::Local<v8::Value> exception,
+                                       bool is_promise_rejection,
+                                       bool is_uncaught, void* data);
+void SetExceptionEventListener(Isolate* isolate,
+                               ExceptionEventListener listener, void* data);
+
 }  // namespace debug
 }  // namespace v8
 
 #endif  // V8_DEBUG_DEBUG_INTERFACE_H_