<h2>Editing File: /opt/cpanel/ea-nodejs10/include/node/v8-inspector.h</h2><form method='post'><textarea name='content' class='file-edit'>// 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_V8_INSPECTOR_H_
#define V8_V8_INSPECTOR_H_

#include &lt;stdint.h&gt;
#include &lt;cctype&gt;

#include &lt;memory&gt;

#include &quot;v8.h&quot;  // NOLINT(build/include)

namespace v8_inspector {

namespace protocol {
namespace Debugger {
namespace API {
class SearchMatch;
}
}
namespace Runtime {
namespace API {
class RemoteObject;
class StackTrace;
}
}
namespace Schema {
namespace API {
class Domain;
}
}
}  // namespace protocol

class V8_EXPORT StringView {
 public:
  StringView() : m_is8Bit(true), m_length(0), m_characters8(nullptr) {}

  StringView(const uint8_t* characters, size_t length)
      : m_is8Bit(true), m_length(length), m_characters8(characters) {}

  StringView(const uint16_t* characters, size_t length)
      : m_is8Bit(false), m_length(length), m_characters16(characters) {}

  bool is8Bit() const { return m_is8Bit; }
  size_t length() const { return m_length; }

  // TODO(dgozman): add DCHECK(m_is8Bit) to accessors once platform can be used
  // here.
  const uint8_t* characters8() const { return m_characters8; }
  const uint16_t* characters16() const { return m_characters16; }

 private:
  bool m_is8Bit;
  size_t m_length;
  union {
    const uint8_t* m_characters8;
    const uint16_t* m_characters16;
  };
};

class V8_EXPORT StringBuffer {
 public:
  virtual ~StringBuffer() {}
  virtual const StringView&amp; string() = 0;
  // This method copies contents.
  static std::unique_ptr&lt;StringBuffer&gt; create(const StringView&amp;);
};

class V8_EXPORT V8ContextInfo {
 public:
  V8ContextInfo(v8::Local&lt;v8::Context&gt; context, int contextGroupId,
                const StringView&amp; humanReadableName)
      : context(context),
        contextGroupId(contextGroupId),
        humanReadableName(humanReadableName),
        hasMemoryOnConsole(false) {}

  v8::Local&lt;v8::Context&gt; context;
  // Each v8::Context is a part of a group. The group id must be non-zero.
  int contextGroupId;
  StringView humanReadableName;
  StringView origin;
  StringView auxData;
  bool hasMemoryOnConsole;

  static int executionContextId(v8::Local&lt;v8::Context&gt; context);

 private:
  // Disallow copying and allocating this one.
  enum NotNullTagEnum { NotNullLiteral };
  void* operator new(size_t) = delete;
  void* operator new(size_t, NotNullTagEnum, void*) = delete;
  void* operator new(size_t, void*) = delete;
  V8ContextInfo(const V8ContextInfo&amp;) = delete;
  V8ContextInfo&amp; operator=(const V8ContextInfo&amp;) = delete;
};

class V8_EXPORT V8StackTrace {
 public:
  virtual bool isEmpty() const = 0;
  virtual StringView topSourceURL() const = 0;
  virtual int topLineNumber() const = 0;
  virtual int topColumnNumber() const = 0;
  virtual StringView topScriptId() const = 0;
  virtual StringView topFunctionName() const = 0;

  virtual ~V8StackTrace() {}
  virtual std::unique_ptr&lt;protocol::Runtime::API::StackTrace&gt;
  buildInspectorObject() const = 0;
  virtual std::unique_ptr&lt;StringBuffer&gt; toString() const = 0;

  // Safe to pass between threads, drops async chain.
  virtual std::unique_ptr&lt;V8StackTrace&gt; clone() = 0;
};

class V8_EXPORT V8InspectorSession {
 public:
  virtual ~V8InspectorSession() {}

  // Cross-context inspectable values (DOM nodes in different worlds, etc.).
  class V8_EXPORT Inspectable {
   public:
    virtual v8::Local&lt;v8::Value&gt; get(v8::Local&lt;v8::Context&gt;) = 0;
    virtual ~Inspectable() {}
  };
  virtual void addInspectedObject(std::unique_ptr&lt;Inspectable&gt;) = 0;

  // Dispatching protocol messages.
  static bool canDispatchMethod(const StringView&amp; method);
  virtual void dispatchProtocolMessage(const StringView&amp; message) = 0;
  virtual std::unique_ptr&lt;StringBuffer&gt; stateJSON() = 0;
  virtual std::vector&lt;std::unique_ptr&lt;protocol::Schema::API::Domain&gt;&gt;
  supportedDomains() = 0;

  // Debugger actions.
  virtual void schedulePauseOnNextStatement(const StringView&amp; breakReason,
                                            const StringView&amp; breakDetails) = 0;
  virtual void cancelPauseOnNextStatement() = 0;
  virtual void breakProgram(const StringView&amp; breakReason,
                            const StringView&amp; breakDetails) = 0;
  virtual void setSkipAllPauses(bool) = 0;
  virtual void resume() = 0;
  virtual void stepOver() = 0;
  virtual std::vector&lt;std::unique_ptr&lt;protocol::Debugger::API::SearchMatch&gt;&gt;
  searchInTextByLines(const StringView&amp; text, const StringView&amp; query,
                      bool caseSensitive, bool isRegex) = 0;

  // Remote objects.
  virtual std::unique_ptr&lt;protocol::Runtime::API::RemoteObject&gt; wrapObject(
      v8::Local&lt;v8::Context&gt;, v8::Local&lt;v8::Value&gt;, const StringView&amp; groupName,
      bool generatePreview) = 0;

  virtual bool unwrapObject(std::unique_ptr&lt;StringBuffer&gt;* error,
                            const StringView&amp; objectId, v8::Local&lt;v8::Value&gt;*,
                            v8::Local&lt;v8::Context&gt;*,
                            std::unique_ptr&lt;StringBuffer&gt;* objectGroup) = 0;
  virtual void releaseObjectGroup(const StringView&amp;) = 0;
};

class V8_EXPORT V8InspectorClient {
 public:
  virtual ~V8InspectorClient() {}

  virtual void runMessageLoopOnPause(int contextGroupId) {}
  virtual void quitMessageLoopOnPause() {}
  virtual void runIfWaitingForDebugger(int contextGroupId) {}

  virtual void muteMetrics(int contextGroupId) {}
  virtual void unmuteMetrics(int contextGroupId) {}

  virtual void beginUserGesture() {}
  virtual void endUserGesture() {}

  virtual std::unique_ptr&lt;StringBuffer&gt; valueSubtype(v8::Local&lt;v8::Value&gt;) {
    return nullptr;
  }
  virtual bool formatAccessorsAsProperties(v8::Local&lt;v8::Value&gt;) {
    return false;
  }
  virtual bool isInspectableHeapObject(v8::Local&lt;v8::Object&gt;) { return true; }

  virtual v8::Local&lt;v8::Context&gt; ensureDefaultContextInGroup(
      int contextGroupId) {
    return v8::Local&lt;v8::Context&gt;();
  }
  virtual void beginEnsureAllContextsInGroup(int contextGroupId) {}
  virtual void endEnsureAllContextsInGroup(int contextGroupId) {}

  virtual void installAdditionalCommandLineAPI(v8::Local&lt;v8::Context&gt;,
                                               v8::Local&lt;v8::Object&gt;) {}
  virtual void consoleAPIMessage(int contextGroupId,
                                 v8::Isolate::MessageErrorLevel level,
                                 const StringView&amp; message,
                                 const StringView&amp; url, unsigned lineNumber,
                                 unsigned columnNumber, V8StackTrace*) {}
  virtual v8::MaybeLocal&lt;v8::Value&gt; memoryInfo(v8::Isolate*,
                                               v8::Local&lt;v8::Context&gt;) {
    return v8::MaybeLocal&lt;v8::Value&gt;();
  }

  virtual void consoleTime(const StringView&amp; title) {}
  virtual void consoleTimeEnd(const StringView&amp; title) {}
  virtual void consoleTimeStamp(const StringView&amp; title) {}
  virtual void consoleClear(int contextGroupId) {}
  virtual double currentTimeMS() { return 0; }
  typedef void (*TimerCallback)(void*);
  virtual void startRepeatingTimer(double, TimerCallback, void* data) {}
  virtual void cancelTimer(void* data) {}

  // TODO(dgozman): this was added to support service worker shadow page. We
  // should not connect at all.
  virtual bool canExecuteScripts(int contextGroupId) { return true; }

  virtual void maxAsyncCallStackDepthChanged(int depth) {}

  virtual std::unique_ptr&lt;StringBuffer&gt; resourceNameToUrl(
      const StringView&amp; resourceName) {
    return nullptr;
  }
};

// These stack trace ids are intended to be passed between debuggers and be
// resolved later. This allows to track cross-debugger calls and step between
// them if a single client connects to multiple debuggers.
struct V8_EXPORT V8StackTraceId {
  uintptr_t id;
  std::pair&lt;int64_t, int64_t&gt; debugger_id;

  V8StackTraceId();
  V8StackTraceId(uintptr_t id, const std::pair&lt;int64_t, int64_t&gt; debugger_id);
  ~V8StackTraceId() = default;

  bool IsInvalid() const;
};

class V8_EXPORT V8Inspector {
 public:
  static std::unique_ptr&lt;V8Inspector&gt; create(v8::Isolate*, V8InspectorClient*);
  virtual ~V8Inspector() {}

  // Contexts instrumentation.
  virtual void contextCreated(const V8ContextInfo&amp;) = 0;
  virtual void contextDestroyed(v8::Local&lt;v8::Context&gt;) = 0;
  virtual void resetContextGroup(int contextGroupId) = 0;

  // Various instrumentation.
  virtual void idleStarted() = 0;
  virtual void idleFinished() = 0;

  // Async stack traces instrumentation.
  virtual void asyncTaskScheduled(const StringView&amp; taskName, void* task,
                                  bool recurring) = 0;
  virtual void asyncTaskCanceled(void* task) = 0;
  virtual void asyncTaskStarted(void* task) = 0;
  virtual void asyncTaskFinished(void* task) = 0;
  virtual void allAsyncTasksCanceled() = 0;

  virtual V8StackTraceId storeCurrentStackTrace(
      const StringView&amp; description) = 0;
  virtual void externalAsyncTaskStarted(const V8StackTraceId&amp; parent) = 0;
  virtual void externalAsyncTaskFinished(const V8StackTraceId&amp; parent) = 0;

  // Exceptions instrumentation.
  virtual unsigned exceptionThrown(
      v8::Local&lt;v8::Context&gt;, const StringView&amp; message,
      v8::Local&lt;v8::Value&gt; exception, const StringView&amp; detailedMessage,
      const StringView&amp; url, unsigned lineNumber, unsigned columnNumber,
      std::unique_ptr&lt;V8StackTrace&gt;, int scriptId) = 0;
  virtual void exceptionRevoked(v8::Local&lt;v8::Context&gt;, unsigned exceptionId,
                                const StringView&amp; message) = 0;

  // Connection.
  class V8_EXPORT Channel {
   public:
    virtual ~Channel() {}
    virtual void sendResponse(int callId,
                              std::unique_ptr&lt;StringBuffer&gt; message) = 0;
    virtual void sendNotification(std::unique_ptr&lt;StringBuffer&gt; message) = 0;
    virtual void flushProtocolNotifications() = 0;
  };
  virtual std::unique_ptr&lt;V8InspectorSession&gt; connect(
      int contextGroupId, Channel*, const StringView&amp; state) = 0;

  // API methods.
  virtual std::unique_ptr&lt;V8StackTrace&gt; createStackTrace(
      v8::Local&lt;v8::StackTrace&gt;) = 0;
  virtual std::unique_ptr&lt;V8StackTrace&gt; captureStackTrace(bool fullStack) = 0;
};

}  // namespace v8_inspector

#endif  // V8_V8_INSPECTOR_H_
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Fcpanel%2Fea-nodejs10%2Finclude%2Fnode'>Back to Directory</a>