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

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

@@ -0,0 +1,156 @@
+// 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_INSPECTOR_SESSION_IMPL_H_
+#define V8_INSPECTOR_V8_INSPECTOR_SESSION_IMPL_H_
+
+#include <memory>
+#include <vector>
+
+#include "src/base/macros.h"
+#include "src/inspector/protocol/Forward.h"
+#include "src/inspector/protocol/Runtime.h"
+#include "src/inspector/protocol/Schema.h"
+
+#include "src/inspector/v8-css-agent-impl.h"
+#include "src/inspector/v8-dom-agent-impl.h"
+#include "src/inspector/v8-log-agent-impl.h"
+#include "src/inspector/v8-network-agent-impl.h"
+#include "src/inspector/v8-overlay-agent-impl.h"
+#include "src/inspector/v8-page-agent-impl.h"
+
+#include "include/v8-inspector.h"
+
+namespace v8_inspector {
+
+class InjectedScript;
+class RemoteObjectIdBase;
+class V8ConsoleAgentImpl;
+class V8DebuggerAgentImpl;
+class V8InspectorImpl;
+class V8HeapProfilerAgentImpl;
+class V8ProfilerAgentImpl;
+class V8RuntimeAgentImpl;
+class V8SchemaAgentImpl;
+
+using protocol::Response;
+
+class V8InspectorSessionImpl : public V8InspectorSession,
+                               public protocol::FrontendChannel {
+ public:
+  static std::unique_ptr<V8InspectorSessionImpl> create(V8InspectorImpl*,
+                                                        int contextGroupId,
+                                                        int sessionId,
+                                                        V8Inspector::Channel*,
+                                                        StringView state);
+  ~V8InspectorSessionImpl() override;
+  V8InspectorSessionImpl(const V8InspectorSessionImpl&) = delete;
+  V8InspectorSessionImpl& operator=(const V8InspectorSessionImpl&) = delete;
+
+  V8InspectorImpl* inspector() const { return m_inspector; }
+  V8ConsoleAgentImpl* consoleAgent() { return m_consoleAgent.get(); }
+  V8DebuggerAgentImpl* debuggerAgent() { return m_debuggerAgent.get(); }
+  V8SchemaAgentImpl* schemaAgent() { return m_schemaAgent.get(); }
+  V8ProfilerAgentImpl* profilerAgent() { return m_profilerAgent.get(); }
+  V8RuntimeAgentImpl* runtimeAgent() { return m_runtimeAgent.get(); }
+  V8NetworkAgentImpl* networkArgent() { return m_networkAgent.get(); }
+  V8DOMAgentImpl* domArgent() { return m_domAgent.get(); }
+  int contextGroupId() const { return m_contextGroupId; }
+  int sessionId() const { return m_sessionId; }
+
+  std::unique_ptr<V8InspectorSession::CommandLineAPIScope>
+  initializeCommandLineAPIScope(int executionContextId) override;
+
+  Response findInjectedScript(int contextId, InjectedScript*&);
+  Response findInjectedScript(RemoteObjectIdBase*, InjectedScript*&);
+  void reset();
+  void discardInjectedScripts();
+  void reportAllContexts(V8RuntimeAgentImpl*);
+  void setCustomObjectFormatterEnabled(bool);
+  std::unique_ptr<protocol::Runtime::RemoteObject> wrapObject(
+      v8::Local<v8::Context>, v8::Local<v8::Value>, const String16& groupName,
+      bool generatePreview);
+  std::unique_ptr<protocol::Runtime::RemoteObject> wrapTable(
+      v8::Local<v8::Context>, v8::Local<v8::Object> table,
+      v8::MaybeLocal<v8::Array> columns);
+  std::vector<std::unique_ptr<protocol::Schema::Domain>> supportedDomainsImpl();
+  Response unwrapObject(const String16& objectId, v8::Local<v8::Value>*,
+                        v8::Local<v8::Context>*, String16* objectGroup);
+  void releaseObjectGroup(const String16& objectGroup);
+
+  // V8InspectorSession implementation.
+  void dispatchProtocolMessage(StringView message) override;
+  std::vector<uint8_t> state() override;
+  std::vector<std::unique_ptr<protocol::Schema::API::Domain>> supportedDomains()
+      override;
+  void addInspectedObject(
+      std::unique_ptr<V8InspectorSession::Inspectable>) override;
+  void schedulePauseOnNextStatement(StringView breakReason,
+                                    StringView breakDetails) override;
+  void cancelPauseOnNextStatement() override;
+  void breakProgram(StringView breakReason, StringView breakDetails) override;
+  void setSkipAllPauses(bool) override;
+  void resume(bool terminateOnResume = false) override;
+  void stepOver() override;
+  std::vector<std::unique_ptr<protocol::Debugger::API::SearchMatch>>
+  searchInTextByLines(StringView text, StringView query, bool caseSensitive,
+                      bool isRegex) override;
+  void releaseObjectGroup(StringView objectGroup) override;
+  bool unwrapObject(std::unique_ptr<StringBuffer>*, StringView objectId,
+                    v8::Local<v8::Value>*, v8::Local<v8::Context>*,
+                    std::unique_ptr<StringBuffer>* objectGroup) override;
+  std::unique_ptr<protocol::Runtime::API::RemoteObject> wrapObject(
+      v8::Local<v8::Context>, v8::Local<v8::Value>, StringView groupName,
+      bool generatePreview) override;
+
+  V8InspectorSession::Inspectable* inspectedObject(unsigned num);
+  static const unsigned kInspectedObjectBufferSize = 5;
+
+  void triggerPreciseCoverageDeltaUpdate(StringView occassion) override;
+
+ private:
+  V8InspectorSessionImpl(V8InspectorImpl*, int contextGroupId, int sessionId,
+                         V8Inspector::Channel*, StringView state);
+  protocol::DictionaryValue* agentState(const String16& name);
+
+  // protocol::FrontendChannel implementation.
+  void SendProtocolResponse(
+      int callId, std::unique_ptr<protocol::Serializable> message) override;
+  void SendProtocolNotification(
+      std::unique_ptr<protocol::Serializable> message) override;
+  void FallThrough(int callId, v8_crdtp::span<uint8_t> method,
+                   v8_crdtp::span<uint8_t> message) override;
+  void FlushProtocolNotifications() override;
+
+  std::unique_ptr<StringBuffer> serializeForFrontend(
+      std::unique_ptr<protocol::Serializable> message);
+  int m_contextGroupId;
+  int m_sessionId;
+  V8InspectorImpl* m_inspector;
+  V8Inspector::Channel* m_channel;
+  bool m_customObjectFormatterEnabled;
+
+  protocol::UberDispatcher m_dispatcher;
+  std::unique_ptr<protocol::DictionaryValue> m_state;
+
+  std::unique_ptr<V8RuntimeAgentImpl> m_runtimeAgent;
+  std::unique_ptr<V8DebuggerAgentImpl> m_debuggerAgent;
+  std::unique_ptr<V8HeapProfilerAgentImpl> m_heapProfilerAgent;
+  std::unique_ptr<V8ProfilerAgentImpl> m_profilerAgent;
+  std::unique_ptr<V8ConsoleAgentImpl> m_consoleAgent;
+  std::unique_ptr<V8SchemaAgentImpl> m_schemaAgent;
+  std::unique_ptr<V8PageAgentImpl> m_pageAgent;
+  std::unique_ptr<V8NetworkAgentImpl> m_networkAgent;
+  std::unique_ptr<V8DOMAgentImpl> m_domAgent;
+  std::unique_ptr<V8CSSAgentImpl> m_cssAgent;
+  std::unique_ptr<V8OverlayAgentImpl> m_overlayAgent;
+  std::unique_ptr<V8LogAgentImpl> m_logAgent;
+  std::vector<std::unique_ptr<V8InspectorSession::Inspectable>>
+      m_inspectedObjects;
+  bool use_binary_protocol_ = false;
+};
+
+}  // namespace v8_inspector
+
+#endif  // V8_INSPECTOR_V8_INSPECTOR_SESSION_IMPL_H_

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

@@ -0,0 +1,34 @@
+#ifndef v8_log_agent_impl_h
+#define v8_log_agent_impl_h
+
+#include "src/inspector/protocol/Log.h"
+
+namespace v8_inspector {
+    
+class V8InspectorSessionImpl;
+    
+using v8_inspector::protocol::DispatchResponse;
+    
+class V8LogAgentImpl : public protocol::Log::Backend {
+public:
+    V8LogAgentImpl(V8InspectorSessionImpl* session, protocol::FrontendChannel* frontend, protocol::DictionaryValue* state);
+    ~V8LogAgentImpl() override;
+    DispatchResponse enable() override;
+    DispatchResponse disable() override;
+    DispatchResponse clear() override;
+    DispatchResponse startViolationsReport(std::unique_ptr<protocol::Array<protocol::Log::ViolationSetting>> in_config) override;
+    DispatchResponse stopViolationsReport() override;
+    
+    static void EntryAdded(const std::string& text, std::string verbosityLevel, std::string url, int lineNumber);
+    
+private:
+    protocol::Log::Frontend m_frontend;
+    protocol::DictionaryValue* m_state;
+    bool m_enabled;
+
+    static V8LogAgentImpl* instance_;
+};
+    
+}
+
+#endif /* v8_log_agent_impl_h */

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

@@ -0,0 +1,71 @@
+#ifndef v8_network_agent_impl_h
+#define v8_network_agent_impl_h
+
+#include <string>
+#include <map>
+#include "utils.h"
+#include "src/inspector/v8-inspector-impl.h"
+#include "src/inspector/protocol/Network.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 V8NetworkAgentImpl : public protocol::Network::Backend {
+public:
+    V8NetworkAgentImpl(V8InspectorSessionImpl*, protocol::FrontendChannel*,
+                       protocol::DictionaryValue* state);
+    ~V8NetworkAgentImpl() override;
+    V8NetworkAgentImpl(const V8NetworkAgentImpl&) = delete;
+    V8NetworkAgentImpl& operator=(const V8NetworkAgentImpl&) = delete;
+
+    DispatchResponse enable(Maybe<int> in_maxTotalBufferSize, Maybe<int> in_maxResourceBufferSize, Maybe<int> in_maxPostDataSize) override;
+    DispatchResponse disable() override;
+
+    DispatchResponse setExtraHTTPHeaders(std::unique_ptr<protocol::Network::Headers> in_headers) override;
+
+    /*
+     * Returns content served for the given request.
+     * The content of each response is stored in `m_responses` when a request completes.
+     * @param in_requestId
+     */
+    void getResponseBody(const String& in_requestId, std::unique_ptr<GetResponseBodyCallback> callback) override;
+
+    DispatchResponse setCacheDisabled(bool in_cacheDisabled) override;
+
+    DispatchResponse canClearBrowserCache(bool* out_result) override;
+    DispatchResponse canClearBrowserCookies(bool* out_result) override;
+    DispatchResponse emulateNetworkConditions(bool in_offline, double in_latency, double in_downloadThroughput, double in_uploadThroughput, Maybe<String> in_connectionType) override;
+    DispatchResponse getCertificate(const String& in_origin, std::unique_ptr<protocol::Array<String>>* out_tableNames) override;
+    void getRequestPostData(const String& in_requestId, std::unique_ptr<GetRequestPostDataCallback> callback) override;
+    DispatchResponse replayXHR(const String& in_requestId) override;
+    DispatchResponse searchInResponseBody(const String& in_requestId, const String& in_query, Maybe<bool> in_caseSensitive, Maybe<bool> in_isRegex, std::unique_ptr<protocol::Array<protocol::Debugger::SearchMatch>>* out_result) override;
+    DispatchResponse setBlockedURLs(std::unique_ptr<protocol::Array<String>> in_urls) override;
+    DispatchResponse setBypassServiceWorker(bool in_bypass) override;
+    DispatchResponse setDataSizeLimitsForTest(int in_maxTotalSize, int in_maxResourceSize) override;
+
+    const bool enabled() {
+        return m_enabled;
+    };
+
+    void dispatch(std::string message);
+private:
+    protocol::Network::Frontend m_frontend;
+    protocol::DictionaryValue* m_state;
+    V8InspectorImpl* m_inspector;
+    V8InspectorSessionImpl* m_session;
+    bool m_enabled;
+
+    void RequestWillBeSent(const v8::Local<v8::Object>& obj);
+    void ResponseReceived(const v8::Local<v8::Object>& obj);
+    void LoadingFinished(const v8::Local<v8::Object>& obj);
+};
+
+}
+
+#endif /* v8_network_agent_impl_h */

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

@@ -0,0 +1,24 @@
+#ifndef NSV8DebuggerAgentImpl_h
+#define NSV8DebuggerAgentImpl_h
+
+#include "src/inspector/v8-debugger-agent-impl.h"
+
+namespace v8_inspector {
+
+class NSV8DebuggerAgentImpl : public V8DebuggerAgentImpl {
+public:
+    NSV8DebuggerAgentImpl(V8InspectorSessionImpl*, protocol::FrontendChannel*, protocol::DictionaryValue *state);
+
+    NSV8DebuggerAgentImpl(const NSV8DebuggerAgentImpl&) = delete;
+    NSV8DebuggerAgentImpl& operator=(const NSV8DebuggerAgentImpl&) = delete;
+
+    Response getPossibleBreakpoints(
+            std::unique_ptr<protocol::Debugger::Location> start,
+            Maybe<protocol::Debugger::Location> end,
+            Maybe<bool> restrictToFunction,
+            std::unique_ptr<protocol::Array<protocol::Debugger::BreakLocation>>* locations) override;
+};
+
+}
+
+#endif /* NSV8DebuggerAgentImpl_h */

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

@@ -0,0 +1,70 @@
+#ifndef v8_overlay_agent_impl_h
+#define v8_overlay_agent_impl_h
+
+#include "src/inspector/protocol/Overlay.h"
+
+namespace v8_inspector {
+
+class V8InspectorSessionImpl;
+
+using v8_inspector::protocol::Maybe;
+using String = v8_inspector::String16;
+using v8_inspector::protocol::DispatchResponse;
+
+
+class V8OverlayAgentImpl : public protocol::Overlay::Backend {
+public:
+    V8OverlayAgentImpl(V8InspectorSessionImpl *, protocol::FrontendChannel *,
+                       protocol::DictionaryValue *state);
+
+    ~V8OverlayAgentImpl() override;
+    V8OverlayAgentImpl(const V8OverlayAgentImpl&) = delete;
+    V8OverlayAgentImpl& operator=(const V8OverlayAgentImpl&) = delete;
+
+    DispatchResponse enable() override;
+    DispatchResponse disable() override;
+    DispatchResponse setShowFPSCounter(bool in_show) override;
+    DispatchResponse setPausedInDebuggerMessage(const Maybe<String> in_message) override;
+    DispatchResponse setShowAdHighlights(bool in_show) override;
+
+    DispatchResponse
+    highlightNode(std::unique_ptr<protocol::Overlay::HighlightConfig> in_highlightConfig,
+                  Maybe<int> in_nodeId, Maybe<int> in_backendNodeId, Maybe<String> in_objectId,
+                  Maybe<String> in_selector) override;
+
+    DispatchResponse
+    highlightFrame(const String &in_frameId, Maybe<protocol::DOM::RGBA> in_contentColor,
+                   Maybe<protocol::DOM::RGBA> in_contentOutlineColor) override;
+
+    DispatchResponse hideHighlight() override;
+
+    DispatchResponse getHighlightObjectForTest(int in_nodeId,
+                                               Maybe<bool> in_includeDistance, Maybe<bool> in_includeStyle, std::unique_ptr<protocol::DictionaryValue>* out_highlight) override;
+
+    DispatchResponse highlightQuad(std::unique_ptr<protocol::Array<double>> in_quad,
+                                   Maybe<protocol::DOM::RGBA> in_color,
+                                   Maybe<protocol::DOM::RGBA> in_outlineColor) override;
+
+    DispatchResponse highlightRect(int in_x, int in_y, int in_width, int in_height,
+                                   Maybe<protocol::DOM::RGBA> in_color,
+                                   Maybe<protocol::DOM::RGBA> in_outlineColor) override;
+
+    DispatchResponse setInspectMode(const String &in_mode,
+                                    Maybe<protocol::Overlay::HighlightConfig> in_highlightConfig) override;
+
+    DispatchResponse setShowDebugBorders(bool in_show) override;
+    DispatchResponse setShowPaintRects(bool in_result) override;
+    DispatchResponse setShowScrollBottleneckRects(bool in_show) override;
+    DispatchResponse setShowHitTestBorders(bool in_show) override;
+    DispatchResponse setShowViewportSizeOnResize(bool in_show) override;
+    DispatchResponse setShowLayoutShiftRegions(bool in_result) override;
+
+private:
+    protocol::Overlay::Frontend m_frontend;
+    protocol::DictionaryValue *m_state;
+    bool m_enabled;
+};
+
+}
+
+#endif /* v8_overlay_agent_impl_h */

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

@@ -0,0 +1,88 @@
+#ifndef v8_page_agent_impl_h
+#define v8_page_agent_impl_h
+
+#include <vector>
+#include <map>
+#include "src/inspector/protocol/Page.h"
+#include "src/inspector/protocol/Protocol.h"
+
+namespace v8_inspector {
+
+class V8InspectorImpl;
+class V8InspectorSessionImpl;
+
+using v8_inspector::protocol::Maybe;
+using String = v8_inspector::String16;
+using protocol::DispatchResponse;
+
+class V8PageAgentImpl : public protocol::Page::Backend {
+public:
+    V8PageAgentImpl(V8InspectorSessionImpl*, protocol::FrontendChannel*, protocol::DictionaryValue* state);
+    ~V8PageAgentImpl() override;
+    V8PageAgentImpl(const V8PageAgentImpl&) = delete;
+    V8PageAgentImpl& operator=(const V8PageAgentImpl&) = delete;
+
+    DispatchResponse enable() override;
+    DispatchResponse disable() override;
+    DispatchResponse addScriptToEvaluateOnLoad(const String& in_scriptSource, String* out_identifier) override;
+    DispatchResponse removeScriptToEvaluateOnLoad(const String& in_identifier) override;
+    DispatchResponse reload(Maybe<bool> in_ignoreCache, Maybe<String> in_scriptToEvaluateOnLoad) override;
+    DispatchResponse getResourceTree(std::unique_ptr<protocol::Page::FrameResourceTree>* out_frameTree) override;
+    void getResourceContent(const String& in_frameId, const String& in_url, std::unique_ptr<GetResourceContentCallback> callback) override;
+    void searchInResource(const String& in_frameId, const String& in_url, const String& in_query, Maybe<bool> in_caseSensitive, Maybe<bool> in_isRegex, std::unique_ptr<SearchInResourceCallback> callback) override;
+    DispatchResponse setDocumentContent(const String& in_frameId, const String& in_html) override;
+    DispatchResponse addScriptToEvaluateOnNewDocument(const String& in_source, Maybe<String> in_worldName, String* out_identifier) override;
+    DispatchResponse createIsolatedWorld(const String& in_frameId, Maybe<String> in_worldName, Maybe<bool> in_grantUniveralAccess, int* out_executionContextId) override;
+    DispatchResponse getFrameTree(std::unique_ptr<protocol::Page::FrameTree>* out_frameTree) override;
+    DispatchResponse getLayoutMetrics(std::unique_ptr<protocol::Page::LayoutViewport>* out_layoutViewport, std::unique_ptr<protocol::Page::VisualViewport>* out_visualViewport, std::unique_ptr<protocol::DOM::Rect>* out_contentSize) override;
+    DispatchResponse removeScriptToEvaluateOnNewDocument(const String& in_identifier) override;
+    DispatchResponse setAdBlockingEnabled(bool in_enabled) override;
+    DispatchResponse setBypassCSP(bool in_enabled) override;
+    DispatchResponse setFontFamilies(std::unique_ptr<protocol::Page::FontFamilies> in_fontFamilies) override;
+    DispatchResponse setFontSizes(std::unique_ptr<protocol::Page::FontSizes> in_fontSizes) override;
+    DispatchResponse setLifecycleEventsEnabled(bool in_enabled) override;
+    DispatchResponse startScreencast(Maybe<String> in_format, Maybe<int> in_quality, Maybe<int> in_maxWidth, Maybe<int> in_maxHeight, Maybe<int> in_everyNthFrame) override;
+    DispatchResponse stopLoading() override;
+    DispatchResponse stopScreencast() override;
+    DispatchResponse setProduceCompilationCache(bool in_enabled) override;
+    DispatchResponse addCompilationCache(const String& in_url, const protocol::Binary& in_data) override;
+    DispatchResponse clearCompilationCache() override;
+    DispatchResponse generateTestReport(const String& in_message, Maybe<String> in_group) override;
+    DispatchResponse waitForDebugger() override;
+    DispatchResponse setInterceptFileChooserDialog(bool in_enabled) override;
+    DispatchResponse getInstallabilityErrors(std::unique_ptr<protocol::Array<String>>* out_errors) override;
+    DispatchResponse getManifestIcons(Maybe<protocol::Binary>* out_primaryIcon) override;
+
+    void restore();
+    void reset();
+    const bool enabled() {
+        return m_enabled;
+    };
+
+private:
+    V8InspectorImpl* m_inspector;
+    v8::Isolate* m_isolate;
+    V8InspectorSessionImpl* m_session;
+    protocol::Page::Frontend m_frontend;
+    protocol::DictionaryValue* m_state;
+    bool m_enabled;
+    const std::string m_frameIdentifier;
+    const std::string m_frameUrl;
+
+    static std::map<std::string, const char*> s_mimeTypeMap;
+
+    struct PageEntry {
+        std::string Name;
+        std::string Type;
+        std::string MimeType;
+    };
+
+    std::string GetResourceType(std::string fullPath);
+    void ReadEntries(std::string baseDir, std::vector<PageEntry>& entries);
+    bool HasTextContent(std::string type);
+    String16 GetResourceContent(const String& url, bool& shouldEncode);
+};
+
+}
+
+#endif /* v8_page_agent_impl_h */

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

@@ -0,0 +1,104 @@
+// Copyright 2015 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_PROFILER_AGENT_IMPL_H_
+#define V8_INSPECTOR_V8_PROFILER_AGENT_IMPL_H_
+
+#include <memory>
+#include <vector>
+
+#include "src/base/macros.h"
+#include "src/inspector/protocol/Forward.h"
+#include "src/inspector/protocol/Profiler.h"
+
+namespace v8 {
+class CpuProfiler;
+class Isolate;
+}  // namespace v8
+
+namespace v8_inspector {
+
+class V8InspectorSessionImpl;
+
+using protocol::Maybe;
+using protocol::Response;
+
+class V8ProfilerAgentImpl : public protocol::Profiler::Backend {
+ public:
+  V8ProfilerAgentImpl(V8InspectorSessionImpl*, protocol::FrontendChannel*,
+                      protocol::DictionaryValue* state);
+  ~V8ProfilerAgentImpl() override;
+  V8ProfilerAgentImpl(const V8ProfilerAgentImpl&) = delete;
+  V8ProfilerAgentImpl& operator=(const V8ProfilerAgentImpl&) = delete;
+
+  bool enabled() const { return m_enabled; }
+  void restore();
+
+  Response enable() override;
+  Response disable() override;
+  Response setSamplingInterval(int) override;
+  Response start() override;
+  Response stop(std::unique_ptr<protocol::Profiler::Profile>*) override;
+
+  Response startPreciseCoverage(Maybe<bool> binary, Maybe<bool> detailed,
+                                Maybe<bool> allow_triggered_updates,
+                                double* out_timestamp) override;
+  Response stopPreciseCoverage() override;
+  Response takePreciseCoverage(
+      std::unique_ptr<protocol::Array<protocol::Profiler::ScriptCoverage>>*
+          out_result,
+      double* out_timestamp) override;
+  Response getBestEffortCoverage(
+      std::unique_ptr<protocol::Array<protocol::Profiler::ScriptCoverage>>*
+          out_result) override;
+
+  Response startTypeProfile() override;
+  Response stopTypeProfile() override;
+  Response takeTypeProfile(
+      std::unique_ptr<protocol::Array<protocol::Profiler::ScriptTypeProfile>>*
+          out_result) override;
+
+  Response enableCounters() override;
+  Response disableCounters() override;
+  Response getCounters(
+      std::unique_ptr<protocol::Array<protocol::Profiler::CounterInfo>>*
+          out_result) override;
+
+  Response enableRuntimeCallStats() override;
+  Response disableRuntimeCallStats() override;
+  Response getRuntimeCallStats(
+      std::unique_ptr<
+          protocol::Array<protocol::Profiler::RuntimeCallCounterInfo>>*
+          out_result) override;
+
+  void consoleProfile(const String16& title);
+  void consoleProfileEnd(const String16& title);
+
+  void triggerPreciseCoverageDeltaUpdate(const String16& occassion);
+
+ private:
+  String16 nextProfileId();
+
+  void startProfiling(const String16& title);
+  std::unique_ptr<protocol::Profiler::Profile> stopProfiling(
+      const String16& title, bool serialize);
+
+  V8InspectorSessionImpl* m_session;
+  v8::Isolate* m_isolate;
+  v8::CpuProfiler* m_profiler = nullptr;
+  protocol::DictionaryValue* m_state;
+  protocol::Profiler::Frontend m_frontend;
+  bool m_enabled = false;
+  bool m_recordingCPUProfile = false;
+  class ProfileDescriptor;
+  std::vector<ProfileDescriptor> m_startedProfiles;
+  String16 m_frontendInitiatedProfileId;
+  int m_startedProfilesCount = 0;
+  std::shared_ptr<V8Inspector::Counters> m_counters;
+  bool m_runtime_call_stats_enabled = false;
+};
+
+}  // namespace v8_inspector
+
+#endif  // V8_INSPECTOR_V8_PROFILER_AGENT_IMPL_H_

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

@@ -0,0 +1,38 @@
+// 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_REGEX_H_
+#define V8_INSPECTOR_V8_REGEX_H_
+
+#include "src/base/macros.h"
+#include "src/inspector/string-16.h"
+
+#include "include/v8.h"
+
+namespace v8_inspector {
+
+class V8InspectorImpl;
+
+enum MultilineMode { MultilineDisabled, MultilineEnabled };
+
+class V8Regex {
+ public:
+  V8Regex(V8InspectorImpl*, const String16&, bool caseSensitive,
+          bool multiline = false);
+  V8Regex(const V8Regex&) = delete;
+  V8Regex& operator=(const V8Regex&) = delete;
+  int match(const String16&, int startFrom = 0,
+            int* matchLength = nullptr) const;
+  bool isValid() const { return !m_regex.IsEmpty(); }
+  const String16& errorMessage() const { return m_errorMessage; }
+
+ private:
+  V8InspectorImpl* m_inspector;
+  v8::Global<v8::RegExp> m_regex;
+  String16 m_errorMessage;
+};
+
+}  // namespace v8_inspector
+
+#endif  // V8_INSPECTOR_V8_REGEX_H_