v8  10.1.124 (node 18.2.0)
V8 is Google's open source JavaScript engine
v8-inspector.h
Go to the documentation of this file.
1 // Copyright 2016 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #ifndef V8_V8_INSPECTOR_H_
6 #define V8_V8_INSPECTOR_H_
7 
8 #include <stdint.h>
9 
10 #include <cctype>
11 #include <memory>
12 
13 #include "v8-isolate.h" // NOLINT(build/include_directory)
14 #include "v8-local-handle.h" // NOLINT(build/include_directory)
15 
16 namespace v8 {
17 class Context;
18 class Name;
19 class Object;
20 class StackTrace;
21 class Value;
22 } // namespace v8
23 
24 namespace v8_inspector {
25 
26 namespace internal {
27 class V8DebuggerId;
28 } // namespace internal
29 
30 namespace protocol {
31 namespace Debugger {
32 namespace API {
33 class SearchMatch;
34 }
35 }
36 namespace Runtime {
37 namespace API {
38 class RemoteObject;
39 class StackTrace;
40 class StackTraceId;
41 }
42 }
43 namespace Schema {
44 namespace API {
45 class Domain;
46 }
47 }
48 } // namespace protocol
49 
51  public:
52  StringView() : m_is8Bit(true), m_length(0), m_characters8(nullptr) {}
53 
54  StringView(const uint8_t* characters, size_t length)
55  : m_is8Bit(true), m_length(length), m_characters8(characters) {}
56 
57  StringView(const uint16_t* characters, size_t length)
58  : m_is8Bit(false), m_length(length), m_characters16(characters) {}
59 
60  bool is8Bit() const { return m_is8Bit; }
61  size_t length() const { return m_length; }
62 
63  // TODO(dgozman): add DCHECK(m_is8Bit) to accessors once platform can be used
64  // here.
65  const uint8_t* characters8() const { return m_characters8; }
66  const uint16_t* characters16() const { return m_characters16; }
67 
68  private:
69  bool m_is8Bit;
70  size_t m_length;
71  union {
72  const uint8_t* m_characters8;
73  const uint16_t* m_characters16;
74  };
75 };
76 
78  public:
79  virtual ~StringBuffer() = default;
80  virtual StringView string() const = 0;
81  // This method copies contents.
82  static std::unique_ptr<StringBuffer> create(StringView);
83 };
84 
86  public:
87  V8ContextInfo(v8::Local<v8::Context> context, int contextGroupId,
88  StringView humanReadableName)
89  : context(context),
90  contextGroupId(contextGroupId),
91  humanReadableName(humanReadableName),
92  hasMemoryOnConsole(false) {}
93 
95  // Each v8::Context is a part of a group. The group id must be non-zero.
101 
102  static int executionContextId(v8::Local<v8::Context> context);
103 
104  // Disallow copying and allocating this one.
106  void* operator new(size_t) = delete;
107  void* operator new(size_t, NotNullTagEnum, void*) = delete;
108  void* operator new(size_t, void*) = delete;
109  V8ContextInfo(const V8ContextInfo&) = delete;
111 };
112 
113 // This debugger id tries to be unique by generating two random
114 // numbers, which should most likely avoid collisions.
115 // Debugger id has a 1:1 mapping to context group. It is used to
116 // attribute stack traces to a particular debugging, when doing any
117 // cross-debugger operations (e.g. async step in).
118 // See also Runtime.UniqueDebuggerId in the protocol.
120  public:
121  V8DebuggerId() = default;
122  V8DebuggerId(const V8DebuggerId&) = default;
123  V8DebuggerId& operator=(const V8DebuggerId&) = default;
124 
125  std::unique_ptr<StringBuffer> toString() const;
126  bool isValid() const;
127  std::pair<int64_t, int64_t> pair() const;
128 
129  private:
130  friend class internal::V8DebuggerId;
131  explicit V8DebuggerId(std::pair<int64_t, int64_t>);
132 
133  int64_t m_first = 0;
134  int64_t m_second = 0;
135 };
136 
138  public:
139  virtual StringView firstNonEmptySourceURL() const = 0;
140  virtual bool isEmpty() const = 0;
141  virtual StringView topSourceURL() const = 0;
142  virtual int topLineNumber() const = 0;
143  virtual int topColumnNumber() const = 0;
144  virtual int topScriptId() const = 0;
145  virtual StringView topFunctionName() const = 0;
146 
147  virtual ~V8StackTrace() = default;
148  virtual std::unique_ptr<protocol::Runtime::API::StackTrace>
149  buildInspectorObject(int maxAsyncDepth) const = 0;
150  virtual std::unique_ptr<StringBuffer> toString() const = 0;
151 
152  // Safe to pass between threads, drops async chain.
153  virtual std::unique_ptr<V8StackTrace> clone() = 0;
154 };
155 
157  public:
158  virtual ~V8InspectorSession() = default;
159 
160  // Cross-context inspectable values (DOM nodes in different worlds, etc.).
162  public:
163  virtual v8::Local<v8::Value> get(v8::Local<v8::Context>) = 0;
164  virtual ~Inspectable() = default;
165  };
167  public:
168  virtual ~CommandLineAPIScope() = default;
169  };
170  virtual void addInspectedObject(std::unique_ptr<Inspectable>) = 0;
171 
172  // Dispatching protocol messages.
173  static bool canDispatchMethod(StringView method);
174  virtual void dispatchProtocolMessage(StringView message) = 0;
175  virtual std::vector<uint8_t> state() = 0;
176  virtual std::vector<std::unique_ptr<protocol::Schema::API::Domain>>
178 
179  virtual std::unique_ptr<V8InspectorSession::CommandLineAPIScope>
180  initializeCommandLineAPIScope(int executionContextId) = 0;
181 
182  // Debugger actions.
183  virtual void schedulePauseOnNextStatement(StringView breakReason,
184  StringView breakDetails) = 0;
185  virtual void cancelPauseOnNextStatement() = 0;
186  virtual void breakProgram(StringView breakReason,
187  StringView breakDetails) = 0;
188  virtual void setSkipAllPauses(bool) = 0;
189  virtual void resume(bool setTerminateOnResume = false) = 0;
190  virtual void stepOver() = 0;
191  virtual std::vector<std::unique_ptr<protocol::Debugger::API::SearchMatch>>
192  searchInTextByLines(StringView text, StringView query, bool caseSensitive,
193  bool isRegex) = 0;
194 
195  // Remote objects.
196  virtual std::unique_ptr<protocol::Runtime::API::RemoteObject> wrapObject(
197  v8::Local<v8::Context>, v8::Local<v8::Value>, StringView groupName,
198  bool generatePreview) = 0;
199 
200  virtual bool unwrapObject(std::unique_ptr<StringBuffer>* error,
201  StringView objectId, v8::Local<v8::Value>*,
202  v8::Local<v8::Context>*,
203  std::unique_ptr<StringBuffer>* objectGroup) = 0;
204  virtual void releaseObjectGroup(StringView) = 0;
205  virtual void triggerPreciseCoverageDeltaUpdate(StringView occasion) = 0;
206 };
207 
209  public:
210  virtual ~V8InspectorClient() = default;
211 
212  virtual void runMessageLoopOnPause(int contextGroupId) {}
213  virtual void quitMessageLoopOnPause() {}
214  virtual void runIfWaitingForDebugger(int contextGroupId) {}
215 
216  virtual void muteMetrics(int contextGroupId) {}
217  virtual void unmuteMetrics(int contextGroupId) {}
218 
219  virtual void beginUserGesture() {}
220  virtual void endUserGesture() {}
221 
222  virtual std::unique_ptr<StringBuffer> valueSubtype(v8::Local<v8::Value>) {
223  return nullptr;
224  }
225  virtual std::unique_ptr<StringBuffer> descriptionForValueSubtype(
226  v8::Local<v8::Context>, v8::Local<v8::Value>) {
227  return nullptr;
228  }
229  virtual bool isInspectableHeapObject(v8::Local<v8::Object>) { return true; }
230 
232  int contextGroupId) {
234  }
235  virtual void beginEnsureAllContextsInGroup(int contextGroupId) {}
236  virtual void endEnsureAllContextsInGroup(int contextGroupId) {}
237 
239  v8::Local<v8::Object>) {}
240  virtual void consoleAPIMessage(int contextGroupId,
241  v8::Isolate::MessageErrorLevel level,
242  const StringView& message,
243  const StringView& url, unsigned lineNumber,
244  unsigned columnNumber, V8StackTrace*) {}
246  v8::Local<v8::Context>) {
248  }
249 
250  virtual void consoleTime(const StringView& title) {}
251  virtual void consoleTimeEnd(const StringView& title) {}
252  virtual void consoleTimeStamp(const StringView& title) {}
253  virtual void consoleClear(int contextGroupId) {}
254  virtual double currentTimeMS() { return 0; }
255  typedef void (*TimerCallback)(void*);
256  virtual void startRepeatingTimer(double, TimerCallback, void* data) {}
257  virtual void cancelTimer(void* data) {}
258 
259  // TODO(dgozman): this was added to support service worker shadow page. We
260  // should not connect at all.
261  virtual bool canExecuteScripts(int contextGroupId) { return true; }
262 
263  virtual void maxAsyncCallStackDepthChanged(int depth) {}
264 
265  virtual std::unique_ptr<StringBuffer> resourceNameToUrl(
266  const StringView& resourceName) {
267  return nullptr;
268  }
269 
270  // The caller would defer to generating a random 64 bit integer if
271  // this method returns 0.
272  virtual int64_t generateUniqueId() { return 0; }
273 };
274 
275 // These stack trace ids are intended to be passed between debuggers and be
276 // resolved later. This allows to track cross-debugger calls and step between
277 // them if a single client connects to multiple debuggers.
279  uintptr_t id;
280  std::pair<int64_t, int64_t> debugger_id;
281  bool should_pause = false;
282 
284  V8StackTraceId(const V8StackTraceId&) = default;
285  V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id);
286  V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id,
287  bool should_pause);
290  V8StackTraceId& operator=(V8StackTraceId&&) noexcept = default;
291  ~V8StackTraceId() = default;
292 
293  bool IsInvalid() const;
294  std::unique_ptr<StringBuffer> ToString();
295 };
296 
298  public:
299  static std::unique_ptr<V8Inspector> create(v8::Isolate*, V8InspectorClient*);
300  virtual ~V8Inspector() = default;
301 
302  // Contexts instrumentation.
303  virtual void contextCreated(const V8ContextInfo&) = 0;
304  virtual void contextDestroyed(v8::Local<v8::Context>) = 0;
305  virtual void resetContextGroup(int contextGroupId) = 0;
306  virtual v8::MaybeLocal<v8::Context> contextById(int contextId) = 0;
307  virtual V8DebuggerId uniqueDebuggerId(int contextId) = 0;
308 
309  // Various instrumentation.
310  virtual void idleStarted() = 0;
311  virtual void idleFinished() = 0;
312 
313  // Async stack traces instrumentation.
314  virtual void asyncTaskScheduled(StringView taskName, void* task,
315  bool recurring) = 0;
316  virtual void asyncTaskCanceled(void* task) = 0;
317  virtual void asyncTaskStarted(void* task) = 0;
318  virtual void asyncTaskFinished(void* task) = 0;
319  virtual void allAsyncTasksCanceled() = 0;
320 
322  virtual void externalAsyncTaskStarted(const V8StackTraceId& parent) = 0;
323  virtual void externalAsyncTaskFinished(const V8StackTraceId& parent) = 0;
324 
325  // Exceptions instrumentation.
326  virtual unsigned exceptionThrown(v8::Local<v8::Context>, StringView message,
327  v8::Local<v8::Value> exception,
328  StringView detailedMessage, StringView url,
329  unsigned lineNumber, unsigned columnNumber,
330  std::unique_ptr<V8StackTrace>,
331  int scriptId) = 0;
332  virtual void exceptionRevoked(v8::Local<v8::Context>, unsigned exceptionId,
333  StringView message) = 0;
335  v8::Local<v8::Value> exception,
336  v8::Local<v8::Name> key,
337  v8::Local<v8::Value> value) = 0;
338 
339  // Connection.
341  public:
342  virtual ~Channel() = default;
343  virtual void sendResponse(int callId,
344  std::unique_ptr<StringBuffer> message) = 0;
345  virtual void sendNotification(std::unique_ptr<StringBuffer> message) = 0;
346  virtual void flushProtocolNotifications() = 0;
347  };
348  virtual std::unique_ptr<V8InspectorSession> connect(int contextGroupId,
349  Channel*,
350  StringView state) = 0;
351 
352  // API methods.
353  virtual std::unique_ptr<V8StackTrace> createStackTrace(
354  v8::Local<v8::StackTrace>) = 0;
355  virtual std::unique_ptr<V8StackTrace> captureStackTrace(bool fullStack) = 0;
356 };
357 
358 } // namespace v8_inspector
359 
360 #endif // V8_V8_INSPECTOR_H_