@triniwiz/nativescript-masonkit 1.0.0-alpha.4 → 1.0.0-alpha.6

package/pods/Headers/inspector/src/inspector/v8-debugger.h

@@ -0,0 +1,257 @@
+// 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_INSPECTOR_V8_DEBUGGER_H_
+#define V8_INSPECTOR_V8_DEBUGGER_H_
+
+#include <list>
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "include/v8-inspector.h"
+#include "src/base/macros.h"
+#include "src/inspector/inspected-context.h"
+#include "src/inspector/protocol/Debugger.h"
+#include "src/inspector/protocol/Forward.h"
+#include "src/inspector/protocol/Runtime.h"
+#include "src/inspector/v8-debugger-id.h"
+#include "src/inspector/v8-debugger-script.h"
+
+namespace v8_inspector {
+
+class AsyncStackTrace;
+class StackFrame;
+class V8Debugger;
+class V8DebuggerAgentImpl;
+class V8InspectorImpl;
+class V8StackTraceImpl;
+struct V8StackTraceId;
+
+enum class WrapMode { kForceValue, kNoPreview, kWithPreview };
+
+using protocol::Response;
+using TerminateExecutionCallback =
+    protocol::Runtime::Backend::TerminateExecutionCallback;
+
+class V8Debugger : public v8::debug::DebugDelegate,
+                   public v8::debug::AsyncEventDelegate {
+ public:
+  V8Debugger(v8::Isolate*, V8InspectorImpl*);
+  ~V8Debugger() override;
+  V8Debugger(const V8Debugger&) = delete;
+  V8Debugger& operator=(const V8Debugger&) = delete;
+
+  bool enabled() const;
+  v8::Isolate* isolate() const { return m_isolate; }
+
+  void setBreakpointsActive(bool);
+
+  v8::debug::ExceptionBreakState getPauseOnExceptionsState();
+  void setPauseOnExceptionsState(v8::debug::ExceptionBreakState);
+  bool canBreakProgram();
+  void breakProgram(int targetContextGroupId);
+  void interruptAndBreak(int targetContextGroupId);
+  void continueProgram(int targetContextGroupId,
+                       bool terminateOnResume = false);
+  void breakProgramOnAssert(int targetContextGroupId);
+
+  void setPauseOnNextCall(bool, int targetContextGroupId);
+  void stepIntoStatement(int targetContextGroupId, bool breakOnAsyncCall);
+  void stepOverStatement(int targetContextGroupId);
+  void stepOutOfFunction(int targetContextGroupId);
+
+  void terminateExecution(std::unique_ptr<TerminateExecutionCallback> callback);
+
+  Response continueToLocation(int targetContextGroupId,
+                              V8DebuggerScript* script,
+                              std::unique_ptr<protocol::Debugger::Location>,
+                              const String16& targetCallFramess);
+
+  // Each script inherits debug data from v8::Context where it has been
+  // compiled.
+  // Only scripts whose debug data matches |contextGroupId| will be reported.
+  // Passing 0 will result in reporting all scripts.
+  std::vector<std::unique_ptr<V8DebuggerScript>> getCompiledScripts(
+      int contextGroupId, V8DebuggerAgentImpl* agent);
+  void enable();
+  void disable();
+
+  bool isPaused() const { return m_pausedContextGroupId; }
+  bool isPausedInContextGroup(int contextGroupId) const;
+
+  int maxAsyncCallChainDepth() { return m_maxAsyncCallStackDepth; }
+  void setAsyncCallStackDepth(V8DebuggerAgentImpl*, int);
+
+  std::shared_ptr<AsyncStackTrace> currentAsyncParent();
+  V8StackTraceId currentExternalParent();
+
+  std::shared_ptr<StackFrame> symbolize(v8::Local<v8::StackFrame> v8Frame);
+
+  std::unique_ptr<V8StackTraceImpl> createStackTrace(v8::Local<v8::StackTrace>);
+  std::unique_ptr<V8StackTraceImpl> captureStackTrace(bool fullStack);
+
+  v8::MaybeLocal<v8::Array> internalProperties(v8::Local<v8::Context>,
+                                               v8::Local<v8::Value>);
+
+  v8::Local<v8::Array> queryObjects(v8::Local<v8::Context> context,
+                                    v8::Local<v8::Object> prototype);
+
+  void asyncTaskScheduled(const StringView& taskName, void* task,
+                          bool recurring);
+  void asyncTaskCanceled(void* task);
+  void asyncTaskStarted(void* task);
+  void asyncTaskFinished(void* task);
+  void allAsyncTasksCanceled();
+
+  V8StackTraceId storeCurrentStackTrace(const StringView& description);
+  void externalAsyncTaskStarted(const V8StackTraceId& parent);
+  void externalAsyncTaskFinished(const V8StackTraceId& parent);
+
+  uintptr_t storeStackTrace(std::shared_ptr<AsyncStackTrace> stack);
+
+  void muteScriptParsedEvents();
+  void unmuteScriptParsedEvents();
+
+  V8InspectorImpl* inspector() { return m_inspector; }
+
+  void setMaxAsyncTaskStacksForTest(int limit);
+  void dumpAsyncTaskStacksStateForTest();
+
+  V8DebuggerId debuggerIdFor(int contextGroupId);
+  std::shared_ptr<AsyncStackTrace> stackTraceFor(int contextGroupId,
+                                                 const V8StackTraceId& id);
+
+  void reportTermination();
+
+ private:
+  bool addInternalObject(v8::Local<v8::Context> context,
+                         v8::Local<v8::Object> object,
+                         V8InternalValueType type);
+
+  void clearContinueToLocation();
+  bool shouldContinueToCurrentLocation();
+
+  static size_t nearHeapLimitCallback(void* data, size_t current_heap_limit,
+                                      size_t initial_heap_limit);
+  static void terminateExecutionCompletedCallback(v8::Isolate* isolate);
+  static void terminateExecutionCompletedCallbackIgnoringData(
+      v8::Isolate* isolate, void*);
+  void handleProgramBreak(
+      v8::Local<v8::Context> pausedContext, v8::Local<v8::Value> exception,
+      const std::vector<v8::debug::BreakpointId>& hitBreakpoints,
+      v8::debug::ExceptionType exception_type = v8::debug::kException,
+      bool isUncaught = false);
+
+  enum ScopeTargetKind {
+    FUNCTION,
+    GENERATOR,
+  };
+  v8::MaybeLocal<v8::Value> getTargetScopes(v8::Local<v8::Context>,
+                                            v8::Local<v8::Value>,
+                                            ScopeTargetKind);
+
+  v8::MaybeLocal<v8::Value> functionScopes(v8::Local<v8::Context>,
+                                           v8::Local<v8::Function>);
+  v8::MaybeLocal<v8::Value> generatorScopes(v8::Local<v8::Context>,
+                                            v8::Local<v8::Value>);
+  v8::MaybeLocal<v8::Array> collectionsEntries(v8::Local<v8::Context> context,
+                                               v8::Local<v8::Value> value);
+
+  void asyncTaskScheduledForStack(const String16& taskName, void* task,
+                                  bool recurring);
+  void asyncTaskCanceledForStack(void* task);
+  void asyncTaskStartedForStack(void* task);
+  void asyncTaskFinishedForStack(void* task);
+
+  void asyncTaskCandidateForStepping(void* task);
+  void asyncTaskStartedForStepping(void* task);
+  void asyncTaskFinishedForStepping(void* task);
+  void asyncTaskCanceledForStepping(void* task);
+
+  // v8::debug::DebugEventListener implementation.
+  void AsyncEventOccurred(v8::debug::DebugAsyncActionType type, int id,
+                          bool isBlackboxed) override;
+  void ScriptCompiled(v8::Local<v8::debug::Script> script, bool is_live_edited,
+                      bool has_compile_error) override;
+  void BreakProgramRequested(
+      v8::Local<v8::Context> paused_context,
+      const std::vector<v8::debug::BreakpointId>& break_points_hit) override;
+  void ExceptionThrown(v8::Local<v8::Context> paused_context,
+                       v8::Local<v8::Value> exception,
+                       v8::Local<v8::Value> promise, bool is_uncaught,
+                       v8::debug::ExceptionType exception_type) override;
+  bool IsFunctionBlackboxed(v8::Local<v8::debug::Script> script,
+                            const v8::debug::Location& start,
+                            const v8::debug::Location& end) override;
+
+  bool ShouldBeSkipped(v8::Local<v8::debug::Script> script, int line,
+                       int column) override;
+
+  int currentContextGroupId();
+  bool asyncStepOutOfFunction(int targetContextGroupId, bool onlyAtReturn);
+
+  bool hasScheduledBreakOnNextFunctionCall() const;
+
+  v8::Isolate* m_isolate;
+  V8InspectorImpl* m_inspector;
+  int m_enableCount;
+
+  int m_breakpointsActiveCount = 0;
+  int m_ignoreScriptParsedEventsCounter;
+  size_t m_originalHeapLimit = 0;
+  bool m_scheduledOOMBreak = false;
+  bool m_scheduledAssertBreak = false;
+  int m_targetContextGroupId = 0;
+  int m_pausedContextGroupId = 0;
+  int m_continueToLocationBreakpointId;
+  String16 m_continueToLocationTargetCallFrames;
+  std::unique_ptr<V8StackTraceImpl> m_continueToLocationStack;
+
+  using AsyncTaskToStackTrace =
+      std::unordered_map<void*, std::weak_ptr<AsyncStackTrace>>;
+  AsyncTaskToStackTrace m_asyncTaskStacks;
+  std::unordered_set<void*> m_recurringTasks;
+
+  int m_maxAsyncCallStacks;
+  int m_maxAsyncCallStackDepth;
+
+  std::vector<void*> m_currentTasks;
+  std::vector<std::shared_ptr<AsyncStackTrace>> m_currentAsyncParent;
+  std::vector<V8StackTraceId> m_currentExternalParent;
+
+  void collectOldAsyncStacksIfNeeded();
+  int m_asyncStacksCount = 0;
+  // V8Debugger owns all the async stacks, while most of the other references
+  // are weak, which allows to collect some stacks when there are too many.
+  std::list<std::shared_ptr<AsyncStackTrace>> m_allAsyncStacks;
+
+  std::unordered_map<V8DebuggerAgentImpl*, int> m_maxAsyncCallStackDepthMap;
+  void* m_taskWithScheduledBreak = nullptr;
+
+  // If any of the following three is true, we schedule pause on next JS
+  // execution using SetBreakOnNextFunctionCall.
+  bool m_externalAsyncTaskPauseRequested = false;       // External async task.
+  bool m_taskWithScheduledBreakPauseRequested = false;  // Local async task.
+  bool m_pauseOnNextCallRequested = false;  // setPauseOnNextCall API call.
+
+  v8::debug::ExceptionBreakState m_pauseOnExceptionsState;
+  // Whether we should pause on async call execution (if any) while stepping in.
+  // See Debugger.stepInto for details.
+  bool m_pauseOnAsyncCall = false;
+
+  using StackTraceIdToStackTrace =
+      std::unordered_map<uintptr_t, std::weak_ptr<AsyncStackTrace>>;
+  StackTraceIdToStackTrace m_storedStackTraces;
+  uintptr_t m_lastStackTraceId = 0;
+
+  std::unordered_map<int, V8DebuggerId> m_contextGroupIdToDebuggerId;
+
+  std::unique_ptr<TerminateExecutionCallback> m_terminateExecutionCallback;
+};
+
+}  // namespace v8_inspector
+
+#endif  // V8_INSPECTOR_V8_DEBUGGER_H_

package/pods/Headers/inspector/src/inspector/v8-dom-agent-impl.h

@@ -0,0 +1,91 @@
+#ifndef v8_dom_agent_impl_h
+#define v8_dom_agent_impl_h
+
+#include "src/inspector/v8-inspector-impl.h"
+#include "src/inspector/protocol/DOM.h"
+#include "src/inspector/protocol/Protocol.h"
+
+namespace v8_inspector {
+
+class V8InspectorSessionImpl;
+
+using v8_inspector::protocol::Maybe;
+using String = v8_inspector::String16;
+using v8_inspector::protocol::DispatchResponse;
+
+class V8DOMAgentImpl : public protocol::DOM::Backend {
+public:
+    V8DOMAgentImpl(V8InspectorSessionImpl*, protocol::FrontendChannel*,
+                   protocol::DictionaryValue* state);
+
+    ~V8DOMAgentImpl() override;
+    V8DOMAgentImpl(const V8DOMAgentImpl&) = delete;
+    V8DOMAgentImpl& operator=(const V8DOMAgentImpl&) = delete;
+
+    virtual DispatchResponse enable() override;
+    virtual DispatchResponse disable() override;
+    virtual DispatchResponse getContentQuads(Maybe<int> in_nodeId, Maybe<int> in_backendNodeId, Maybe<String> in_objectId, std::unique_ptr<protocol::Array<protocol::Array<double>>>* out_quads) override;
+    virtual DispatchResponse getDocument(Maybe<int> in_depth, Maybe<bool> in_pierce, std::unique_ptr<protocol::DOM::Node>* out_root) override;
+    virtual DispatchResponse removeNode(int in_nodeId) override;
+    virtual DispatchResponse setAttributeValue(int in_nodeId, const String& in_name, const String& in_value) override;
+    virtual DispatchResponse setAttributesAsText(int in_nodeId, const String& in_text, Maybe<String> in_name) override;
+    virtual DispatchResponse removeAttribute(int in_nodeId, const String& in_name) override;
+    virtual DispatchResponse performSearch(const String& in_query, Maybe<bool> in_includeUserAgentShadowDOM, String* out_searchId, int* out_resultCount) override;
+    virtual DispatchResponse getSearchResults(const String& in_searchId, int in_fromIndex, int in_toIndex, std::unique_ptr<protocol::Array<int>>* out_nodeIds) override;
+    virtual DispatchResponse discardSearchResults(const String& in_searchId) override;
+    virtual DispatchResponse resolveNode(Maybe<int> in_nodeId, Maybe<int> in_backendNodeId, Maybe<String> in_objectGroup, Maybe<int> in_executionContextId, std::unique_ptr<protocol::Runtime::RemoteObject>* out_object) override;
+
+    DispatchResponse collectClassNamesFromSubtree(int in_nodeId, std::unique_ptr<protocol::Array<String>>* out_classNames) override;
+    DispatchResponse copyTo(int in_nodeId, int in_targetNodeId, Maybe<int> in_insertBeforeNodeId, int* out_nodeId) override;
+    DispatchResponse describeNode(Maybe<int> in_nodeId, Maybe<int> in_backendNodeId, Maybe<String> in_objectId, Maybe<int> in_depth, Maybe<bool> in_pierce, std::unique_ptr<protocol::DOM::Node>* out_node) override;
+    DispatchResponse focus(Maybe<int> in_nodeId, Maybe<int> in_backendNodeId, Maybe<String> in_objectId) override;
+    DispatchResponse getAttributes(int in_nodeId, std::unique_ptr<protocol::Array<String>>* out_attributes) override;
+    DispatchResponse getBoxModel(Maybe<int> in_nodeId, Maybe<int> in_backendNodeId, Maybe<String> in_objectId, std::unique_ptr<protocol::DOM::BoxModel>* out_model) override;
+    DispatchResponse getFlattenedDocument(Maybe<int> in_depth, Maybe<bool> in_pierce, std::unique_ptr<protocol::Array<protocol::DOM::Node>>* out_nodes) override;
+    DispatchResponse getNodeForLocation(int in_x, int in_y, Maybe<bool> in_includeUserAgentShadowDOM, Maybe<bool> in_ignorePointerEventsNone, int* out_backendNodeId, String* out_frameId, Maybe<int>* out_nodeId) override;
+    DispatchResponse getOuterHTML(Maybe<int> in_nodeId, Maybe<int> in_backendNodeId, Maybe<String> in_objectId, String* out_outerHTML) override;
+    DispatchResponse getRelayoutBoundary(int in_nodeId, int* out_nodeId) override;
+    DispatchResponse markUndoableState() override;
+    DispatchResponse moveTo(int in_nodeId, int in_targetNodeId, Maybe<int> in_insertBeforeNodeId, int* out_nodeId) override;
+    DispatchResponse pushNodeByPathToFrontend(const String& in_path, int* out_nodeId) override;
+    DispatchResponse pushNodesByBackendIdsToFrontend(std::unique_ptr<protocol::Array<int>> in_backendNodeIds, std::unique_ptr<protocol::Array<int>>* out_nodeIds) override;
+    DispatchResponse querySelector(int in_nodeId, const String& in_selector, int* out_nodeId) override;
+    DispatchResponse querySelectorAll(int in_nodeId, const String& in_selector, std::unique_ptr<protocol::Array<int>>* out_nodeIds) override;
+    DispatchResponse redo() override;
+    DispatchResponse requestChildNodes(int in_nodeId, Maybe<int> in_depth, Maybe<bool> in_pierce) override;
+    DispatchResponse requestNode(const String& in_objectId, int* out_nodeId) override;
+    DispatchResponse setFileInputFiles(std::unique_ptr<protocol::Array<String>> in_files, Maybe<int> in_nodeId, Maybe<int> in_backendNodeId, Maybe<String> in_objectId) override;
+    DispatchResponse getFileInfo(const String& in_objectId, String* out_path) override;
+    DispatchResponse setInspectedNode(int in_nodeId) override;
+    DispatchResponse setNodeName(int in_nodeId, const String& in_name, int* out_nodeId) override;
+    DispatchResponse setNodeValue(int in_nodeId, const String& in_value) override;
+    DispatchResponse setOuterHTML(int in_nodeId, const String& in_outerHTML) override;
+    DispatchResponse undo() override;
+    DispatchResponse getFrameOwner(const String& in_frameId, int* out_backendNodeId, Maybe<int>* out_nodeId) override;
+    DispatchResponse setNodeStackTracesEnabled(bool in_enable) override;
+    DispatchResponse getNodeStackTraces(int in_nodeId, Maybe<protocol::Runtime::StackTrace>* out_creation) override;
+
+
+    const bool enabled() {
+        return m_enabled;
+    };
+
+    void dispatch(std::string message);
+private:
+    protocol::DOM::Frontend m_frontend;
+    protocol::DictionaryValue* m_state;
+    V8InspectorImpl* m_inspector;
+    V8InspectorSessionImpl* m_session;
+
+    bool m_enabled;
+
+    void ChildNodeInserted(const v8::Local<v8::Object>& obj);
+    void ChildNodeRemoved(const v8::Local<v8::Object>& obj);
+    void AttributeModified(const v8::Local<v8::Object>& obj);
+    void AttributeRemoved(const v8::Local<v8::Object>& obj);
+    void DocumentUpdated();
+    std::u16string AddBackendNodeIdProperty(v8::Local<v8::Context> context, v8::Local<v8::Value> jsonInput);
+};
+
+}
+#endif /* v8_dom_agent_impl_h */

package/pods/Headers/inspector/src/inspector/v8-heap-profiler-agent-impl.h

@@ -0,0 +1,80 @@
+// 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_INSPECTOR_V8_HEAP_PROFILER_AGENT_IMPL_H_
+#define V8_INSPECTOR_V8_HEAP_PROFILER_AGENT_IMPL_H_
+
+#include <memory>
+
+#include "src/base/macros.h"
+#include "src/inspector/protocol/Forward.h"
+#include "src/inspector/protocol/HeapProfiler.h"
+
+#include "include/v8.h"
+
+namespace v8_inspector {
+
+class V8InspectorSessionImpl;
+
+using protocol::Maybe;
+using protocol::Response;
+
+class V8HeapProfilerAgentImpl : public protocol::HeapProfiler::Backend {
+ public:
+  V8HeapProfilerAgentImpl(V8InspectorSessionImpl*, protocol::FrontendChannel*,
+                          protocol::DictionaryValue* state);
+  ~V8HeapProfilerAgentImpl() override;
+  V8HeapProfilerAgentImpl(const V8HeapProfilerAgentImpl&) = delete;
+  V8HeapProfilerAgentImpl& operator=(const V8HeapProfilerAgentImpl&) = delete;
+  void restore();
+
+  void collectGarbage(
+      std::unique_ptr<CollectGarbageCallback> callback) override;
+
+  Response enable() override;
+  Response startTrackingHeapObjects(Maybe<bool> trackAllocations) override;
+  Response stopTrackingHeapObjects(Maybe<bool> reportProgress,
+                                   Maybe<bool> treatGlobalObjectsAsRoots,
+                                   Maybe<bool> captureNumericValue) override;
+
+  Response disable() override;
+
+  Response takeHeapSnapshot(Maybe<bool> reportProgress,
+                            Maybe<bool> treatGlobalObjectsAsRoots,
+                            Maybe<bool> captureNumericValue) override;
+
+  Response getObjectByHeapObjectId(
+      const String16& heapSnapshotObjectId, Maybe<String16> objectGroup,
+      std::unique_ptr<protocol::Runtime::RemoteObject>* result) override;
+  Response addInspectedHeapObject(
+      const String16& inspectedHeapObjectId) override;
+  Response getHeapObjectId(const String16& objectId,
+                           String16* heapSnapshotObjectId) override;
+
+  Response startSampling(Maybe<double> samplingInterval) override;
+  Response stopSampling(
+      std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfile>*) override;
+  Response getSamplingProfile(
+      std::unique_ptr<protocol::HeapProfiler::SamplingHeapProfile>*) override;
+
+ private:
+  struct AsyncGC;
+  class GCTask;
+
+  void startTrackingHeapObjectsInternal(bool trackAllocations);
+  void stopTrackingHeapObjectsInternal();
+  void requestHeapStatsUpdate();
+  static void onTimer(void*);
+
+  V8InspectorSessionImpl* m_session;
+  v8::Isolate* m_isolate;
+  protocol::HeapProfiler::Frontend m_frontend;
+  protocol::DictionaryValue* m_state;
+  bool m_hasTimer;
+  std::shared_ptr<AsyncGC> m_async_gc;
+};
+
+}  // namespace v8_inspector
+
+#endif  // V8_INSPECTOR_V8_HEAP_PROFILER_AGENT_IMPL_H_

package/pods/Headers/inspector/src/inspector/v8-inspector-impl.h

@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) 2010, Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef V8_INSPECTOR_V8_INSPECTOR_IMPL_H_
+#define V8_INSPECTOR_V8_INSPECTOR_IMPL_H_
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <unordered_map>
+
+#include "src/base/macros.h"
+#include "src/base/platform/mutex.h"
+#include "src/inspector/injected-script.h"
+#include "src/inspector/protocol/Protocol.h"
+
+#include "include/v8-inspector.h"
+
+namespace v8_inspector {
+
+class InspectedContext;
+class V8Console;
+class V8ConsoleMessageStorage;
+class V8Debugger;
+class V8DebuggerAgentImpl;
+class V8InspectorSessionImpl;
+class V8ProfilerAgentImpl;
+class V8RuntimeAgentImpl;
+class V8StackTraceImpl;
+
+class V8InspectorImpl : public V8Inspector {
+ public:
+  V8InspectorImpl(v8::Isolate*, V8InspectorClient*);
+  ~V8InspectorImpl() override;
+  V8InspectorImpl(const V8InspectorImpl&) = delete;
+  V8InspectorImpl& operator=(const V8InspectorImpl&) = delete;
+
+  v8::Isolate* isolate() const { return m_isolate; }
+  V8InspectorClient* client() { return m_client; }
+  V8Debugger* debugger() { return m_debugger.get(); }
+  int contextGroupId(v8::Local<v8::Context>) const;
+  int contextGroupId(int contextId) const;
+  uint64_t isolateId() const { return m_isolateId; }
+  int resolveUniqueContextId(V8DebuggerId uniqueId) const;
+
+  v8::MaybeLocal<v8::Value> compileAndRunInternalScript(v8::Local<v8::Context>,
+                                                        v8::Local<v8::String>);
+  v8::MaybeLocal<v8::Script> compileScript(v8::Local<v8::Context>,
+                                           const String16& code,
+                                           const String16& fileName);
+  v8::MaybeLocal<v8::Context> regexContext();
+
+  // V8Inspector implementation.
+  std::unique_ptr<V8InspectorSession> connect(int contextGroupId,
+                                              V8Inspector::Channel*,
+                                              StringView state) override;
+  void contextCreated(const V8ContextInfo&) override;
+  void contextDestroyed(v8::Local<v8::Context>) override;
+  v8::MaybeLocal<v8::Context> contextById(int contextId) override;
+  void contextCollected(int contextGroupId, int contextId);
+  void resetContextGroup(int contextGroupId) override;
+  void idleStarted() override;
+  void idleFinished() override;
+  unsigned exceptionThrown(v8::Local<v8::Context>, StringView message,
+                           v8::Local<v8::Value> exception,
+                           StringView detailedMessage, StringView url,
+                           unsigned lineNumber, unsigned columnNumber,
+                           std::unique_ptr<V8StackTrace>,
+                           int scriptId) override;
+  void exceptionRevoked(v8::Local<v8::Context>, unsigned exceptionId,
+                        StringView message) override;
+  std::unique_ptr<V8StackTrace> createStackTrace(
+      v8::Local<v8::StackTrace>) override;
+  std::unique_ptr<V8StackTrace> captureStackTrace(bool fullStack) override;
+  void asyncTaskScheduled(StringView taskName, void* task,
+                          bool recurring) override;
+  void asyncTaskCanceled(void* task) override;
+  void asyncTaskStarted(void* task) override;
+  void asyncTaskFinished(void* task) override;
+  void allAsyncTasksCanceled() override;
+
+  V8StackTraceId storeCurrentStackTrace(StringView description) override;
+  void externalAsyncTaskStarted(const V8StackTraceId& parent) override;
+  void externalAsyncTaskFinished(const V8StackTraceId& parent) override;
+
+  std::shared_ptr<Counters> enableCounters() override;
+
+  unsigned nextExceptionId() { return ++m_lastExceptionId; }
+  void enableStackCapturingIfNeeded();
+  void disableStackCapturingIfNeeded();
+  void muteExceptions(int contextGroupId);
+  void unmuteExceptions(int contextGroupId);
+  V8ConsoleMessageStorage* ensureConsoleMessageStorage(int contextGroupId);
+  bool hasConsoleMessageStorage(int contextGroupId);
+  void discardInspectedContext(int contextGroupId, int contextId);
+  void disconnect(V8InspectorSessionImpl*);
+  V8InspectorSessionImpl* sessionById(int contextGroupId, int sessionId);
+  InspectedContext* getContext(int groupId, int contextId) const;
+  InspectedContext* getContext(int contextId) const;
+  V8Console* console();
+  void forEachContext(int contextGroupId,
+                      const std::function<void(InspectedContext*)>& callback);
+  void forEachSession(
+      int contextGroupId,
+      const std::function<void(V8InspectorSessionImpl*)>& callback);
+  int64_t generateUniqueId();
+
+  class EvaluateScope {
+   public:
+    explicit EvaluateScope(const InjectedScript::Scope& scope);
+    ~EvaluateScope();
+
+    protocol::Response setTimeout(double timeout);
+
+   private:
+    class TerminateTask;
+    struct CancelToken;
+
+    const InjectedScript::Scope& m_scope;
+    v8::Isolate* m_isolate;
+    std::shared_ptr<CancelToken> m_cancelToken;
+    v8::Isolate::SafeForTerminationScope m_safeForTerminationScope;
+  };
+
+ private:
+  friend class Counters;
+
+  v8::Isolate* m_isolate;
+  V8InspectorClient* m_client;
+  std::unique_ptr<V8Debugger> m_debugger;
+  v8::Global<v8::Context> m_regexContext;
+  int m_capturingStackTracesCount;
+  unsigned m_lastExceptionId;
+  int m_lastContextId;
+  int m_lastSessionId = 0;
+  uint64_t m_isolateId;
+
+  using MuteExceptionsMap = std::unordered_map<int, int>;
+  MuteExceptionsMap m_muteExceptionsMap;
+
+  using ContextByIdMap =
+      std::unordered_map<int, std::unique_ptr<InspectedContext>>;
+  using ContextsByGroupMap =
+      std::unordered_map<int, std::unique_ptr<ContextByIdMap>>;
+  ContextsByGroupMap m_contexts;
+
+  // contextGroupId -> sessionId -> session
+  std::unordered_map<int, std::map<int, V8InspectorSessionImpl*>> m_sessions;
+
+  using ConsoleStorageMap =
+      std::unordered_map<int, std::unique_ptr<V8ConsoleMessageStorage>>;
+  ConsoleStorageMap m_consoleStorageMap;
+
+  std::unordered_map<int, int> m_contextIdToGroupIdMap;
+  std::map<std::pair<int64_t, int64_t>, int> m_uniqueIdToContextId;
+
+  std::unique_ptr<V8Console> m_console;
+
+  Counters* m_counters = nullptr;
+};
+
+}  // namespace v8_inspector
+
+#endif  // V8_INSPECTOR_V8_INSPECTOR_IMPL_H_