@encharm/cws 4.1.0 → 4.2.0

package/src/headers/10/handle_wrap.h

@@ -1,114 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-#ifndef SRC_HANDLE_WRAP_H_
-#define SRC_HANDLE_WRAP_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "async_wrap.h"
-#include "util.h"
-#include "uv.h"
-#include "v8.h"
-
-namespace node {
-
-class Environment;
-
-// Rules:
-//
-// - Do not throw from handle methods. Set errno.
-//
-// - MakeCallback may only be made directly off the event loop.
-//   That is there can be no JavaScript stack frames underneath it.
-//   (Is there any way to assert that?)
-//
-// - No use of v8::WeakReferenceCallback. The close callback signifies that
-//   we're done with a handle - external resources can be freed.
-//
-// - Reusable?
-//
-// - The uv_close_cb is used to free the c++ object. The close callback
-//   is not made into javascript land.
-//
-// - uv_ref, uv_unref counts are managed at this layer to avoid needless
-//   js/c++ boundary crossing. At the javascript layer that should all be
-//   taken care of.
-
-class HandleWrap : public AsyncWrap {
- public:
-  static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Ref(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Unref(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void HasRef(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static inline bool IsAlive(const HandleWrap* wrap) {
-    return wrap != nullptr && wrap->state_ != kClosed;
-  }
-
-  static inline bool HasRef(const HandleWrap* wrap) {
-    return IsAlive(wrap) && uv_has_ref(wrap->GetHandle());
-  }
-
-  inline uv_handle_t* GetHandle() const { return handle_; }
-
-  virtual void Close(
-      v8::Local<v8::Value> close_callback = v8::Local<v8::Value>());
-
-  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
-      Environment* env);
-
- protected:
-  HandleWrap(Environment* env,
-             v8::Local<v8::Object> object,
-             uv_handle_t* handle,
-             AsyncWrap::ProviderType provider);
-  virtual void OnClose() {}
-
-  void MarkAsInitialized();
-  void MarkAsUninitialized();
-
-  inline bool IsHandleClosing() const {
-    return state_ == kClosing || state_ == kClosed;
-  }
-
- private:
-  friend class Environment;
-  friend void GetActiveHandles(const v8::FunctionCallbackInfo<v8::Value>&);
-  static void OnClose(uv_handle_t* handle);
-
-  // handle_wrap_queue_ needs to be at a fixed offset from the start of the
-  // class because it is used by src/node_postmortem_metadata.cc to calculate
-  // offsets and generate debug symbols for HandleWrap, which assumes that the
-  // position of members in memory are predictable. For more information please
-  // refer to `doc/guides/node-postmortem-support.md`
-  friend int GenDebugSymbols();
-  ListNode<HandleWrap> handle_wrap_queue_;
-  enum { kInitialized, kClosing, kClosed } state_;
-  uv_handle_t* const handle_;
-};
-
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_HANDLE_WRAP_H_

package/src/headers/10/inspector_agent.h

@@ -1,137 +0,0 @@
-#ifndef SRC_INSPECTOR_AGENT_H_
-#define SRC_INSPECTOR_AGENT_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <memory>
-
-#include <stddef.h>
-
-#if !HAVE_INSPECTOR
-#error("This header can only be used when inspector is enabled")
-#endif
-
-#include "node_options.h"
-#include "node_persistent.h"
-#include "v8.h"
-
-namespace v8_inspector {
-class StringView;
-}  // namespace v8_inspector
-
-namespace node {
-// Forward declaration to break recursive dependency chain with src/env.h.
-class Environment;
-struct ContextInfo;
-
-namespace inspector {
-class InspectorIo;
-class ParentInspectorHandle;
-class NodeInspectorClient;
-class WorkerManager;
-
-class InspectorSession {
- public:
-  virtual ~InspectorSession() {}
-  virtual void Dispatch(const v8_inspector::StringView& message) = 0;
-};
-
-class InspectorSessionDelegate {
- public:
-  virtual ~InspectorSessionDelegate() = default;
-  virtual void SendMessageToFrontend(const v8_inspector::StringView& message)
-                                     = 0;
-};
-
-class Agent {
- public:
-  explicit Agent(node::Environment* env);
-  ~Agent();
-
-  // Create client_, may create io_ if option enabled
-  bool Start(const std::string& path,
-             std::shared_ptr<DebugOptions> options,
-             bool is_worker);
-  // Stop and destroy io_
-  void Stop();
-
-  bool IsListening() { return io_ != nullptr; }
-  // Returns true if the Node inspector is actually in use. It will be true
-  // if either the user explicitly opted into inspector (e.g. with the
-  // --inspect command line flag) or if inspector JS API had been used.
-  bool IsActive();
-
-  // Option is set to wait for session connection
-  bool WillWaitForConnect();
-  // Blocks till frontend connects and sends "runIfWaitingForDebugger"
-  void WaitForConnect();
-  // Blocks till all the sessions with "WaitForDisconnectOnShutdown" disconnect
-  void WaitForDisconnect();
-  void FatalException(v8::Local<v8::Value> error,
-                      v8::Local<v8::Message> message);
-
-  // Async stack traces instrumentation.
-  void AsyncTaskScheduled(const v8_inspector::StringView& taskName, void* task,
-                          bool recurring);
-  void AsyncTaskCanceled(void* task);
-  void AsyncTaskStarted(void* task);
-  void AsyncTaskFinished(void* task);
-  void AllAsyncTasksCanceled();
-
-  void RegisterAsyncHook(v8::Isolate* isolate,
-    v8::Local<v8::Function> enable_function,
-    v8::Local<v8::Function> disable_function);
-  void EnableAsyncHook();
-  void DisableAsyncHook();
-
-  void AddWorkerInspector(int thread_id, const std::string& url, Agent* agent);
-
-  // Called to create inspector sessions that can be used from the main thread.
-  // The inspector responds by using the delegate to send messages back.
-  std::unique_ptr<InspectorSession> Connect(
-      std::unique_ptr<InspectorSessionDelegate> delegate,
-      bool prevent_shutdown);
-
-  void PauseOnNextJavascriptStatement(const std::string& reason);
-
-  InspectorIo* io() {
-    return io_.get();
-  }
-
-  // Can only be called from the main thread.
-  bool StartIoThread();
-
-  // Calls StartIoThread() from off the main thread.
-  void RequestIoThreadStart();
-
-  std::shared_ptr<DebugOptions> options() { return debug_options_; }
-  void ContextCreated(v8::Local<v8::Context> context, const ContextInfo& info);
-
-  // Interface for interacting with inspectors in worker threads
-  std::shared_ptr<WorkerManager> GetWorkerManager();
-
- private:
-  void ToggleAsyncHook(v8::Isolate* isolate,
-                       const node::Persistent<v8::Function>& fn);
-
-  node::Environment* parent_env_;
-  // Encapsulates majority of the Inspector functionality
-  std::shared_ptr<NodeInspectorClient> client_;
-  // Interface for transports, e.g. WebSocket server
-  std::unique_ptr<InspectorIo> io_;
-  std::unique_ptr<ParentInspectorHandle> parent_handle_;
-  std::string path_;
-  std::shared_ptr<DebugOptions> debug_options_;
-
-  bool pending_enable_async_hook_ = false;
-  bool pending_disable_async_hook_ = false;
-  node::Persistent<v8::Function> enable_async_hook_function_;
-  node::Persistent<v8::Function> disable_async_hook_function_;
-};
-
-}  // namespace inspector
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_INSPECTOR_AGENT_H_

package/src/headers/10/inspector_io.h

@@ -1,97 +0,0 @@
-#ifndef SRC_INSPECTOR_IO_H_
-#define SRC_INSPECTOR_IO_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "inspector_socket_server.h"
-#include "node_mutex.h"
-#include "uv.h"
-
-#include <memory>
-#include <stddef.h>
-
-#if !HAVE_INSPECTOR
-#error("This header can only be used when inspector is enabled")
-#endif
-
-
-namespace v8_inspector {
-class StringBuffer;
-class StringView;
-}  // namespace v8_inspector
-
-namespace node {
-// Forward declaration to break recursive dependency chain with src/env.h.
-class Environment;
-namespace inspector {
-
-std::string FormatWsAddress(const std::string& host, int port,
-                            const std::string& target_id,
-                            bool include_protocol);
-
-class InspectorIoDelegate;
-class MainThreadHandle;
-class RequestQueue;
-
-// kKill closes connections and stops the server, kStop only stops the server
-enum class TransportAction {
-  kKill,
-  kSendMessage,
-  kStop
-};
-
-class InspectorIo {
- public:
-  // Start the inspector agent thread, waiting for it to initialize
-  // bool Start();
-  // Returns empty pointer if thread was not started
-  static std::unique_ptr<InspectorIo> Start(
-      std::shared_ptr<MainThreadHandle> main_thread, const std::string& path,
-      std::shared_ptr<DebugOptions> options);
-
-  // Will block till the transport thread shuts down
-  ~InspectorIo();
-
-  void StopAcceptingNewConnections();
-  const std::string& host() const { return options_->host(); }
-  int port() const { return port_; }
-  std::vector<std::string> GetTargetIds() const;
-
- private:
-  InspectorIo(std::shared_ptr<MainThreadHandle> handle,
-              const std::string& path,
-              std::shared_ptr<DebugOptions> options);
-
-  // Wrapper for agent->ThreadMain()
-  static void ThreadMain(void* agent);
-
-  // Runs a uv_loop_t
-  void ThreadMain();
-
-  // This is a thread-safe object that will post async tasks. It lives as long
-  // as an Inspector object lives (almost as long as an Isolate).
-  std::shared_ptr<MainThreadHandle> main_thread_;
-  // Used to post on a frontend interface thread, lives while the server is
-  // running
-  std::shared_ptr<RequestQueue> request_queue_;
-  std::shared_ptr<DebugOptions> options_;
-
-  // The IO thread runs its own uv_loop to implement the TCP server off
-  // the main thread.
-  uv_thread_t thread_;
-
-  // For setting up interthread communications
-  Mutex thread_start_lock_;
-  ConditionVariable thread_start_condition_;
-  std::string script_name_;
-  int port_ = -1;
-  // May be accessed from any thread
-  const std::string id_;
-};
-
-}  // namespace inspector
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_INSPECTOR_IO_H_

package/src/headers/10/inspector_socket.h

@@ -1,59 +0,0 @@
-#ifndef SRC_INSPECTOR_SOCKET_H_
-#define SRC_INSPECTOR_SOCKET_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "util-inl.h"
-#include "uv.h"
-
-#include <string>
-#include <vector>
-
-namespace node {
-namespace inspector {
-
-class ProtocolHandler;
-
-// HTTP Wrapper around a uv_tcp_t
-class InspectorSocket {
- public:
-  class Delegate {
-   public:
-    virtual void OnHttpGet(const std::string& host,
-                           const std::string& path) = 0;
-    virtual void OnSocketUpgrade(const std::string& host,
-                                 const std::string& path,
-                                 const std::string& accept_key) = 0;
-    virtual void OnWsFrame(const std::vector<char>& frame) = 0;
-    virtual ~Delegate() {}
-  };
-
-  using DelegatePointer = std::unique_ptr<Delegate>;
-  using Pointer = std::unique_ptr<InspectorSocket>;
-
-  static Pointer Accept(uv_stream_t* server, DelegatePointer delegate);
-
-  ~InspectorSocket();
-
-  void AcceptUpgrade(const std::string& accept_key);
-  void CancelHandshake();
-  void Write(const char* data, size_t len);
-  void SwitchProtocol(ProtocolHandler* handler);
-  std::string GetHost();
-
- private:
-  static void Shutdown(ProtocolHandler*);
-  InspectorSocket() = default;
-
-  DeleteFnPtr<ProtocolHandler, Shutdown> protocol_handler_;
-
-  DISALLOW_COPY_AND_ASSIGN(InspectorSocket);
-};
-
-
-}  // namespace inspector
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_INSPECTOR_SOCKET_H_

package/src/headers/10/inspector_socket_server.h

@@ -1,104 +0,0 @@
-#ifndef SRC_INSPECTOR_SOCKET_SERVER_H_
-#define SRC_INSPECTOR_SOCKET_SERVER_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "inspector_agent.h"
-#include "inspector_socket.h"
-#include "uv.h"
-
-#include <map>
-#include <string>
-#include <vector>
-
-#if !HAVE_INSPECTOR
-#error("This header can only be used when inspector is enabled")
-#endif
-
-namespace node {
-namespace inspector {
-
-class InspectorSocketServer;
-class SocketSession;
-class ServerSocket;
-
-class SocketServerDelegate {
- public:
-  virtual void AssignServer(InspectorSocketServer* server) = 0;
-  virtual void StartSession(int session_id, const std::string& target_id) = 0;
-  virtual void EndSession(int session_id) = 0;
-  virtual void MessageReceived(int session_id, const std::string& message) = 0;
-  virtual std::vector<std::string> GetTargetIds() = 0;
-  virtual std::string GetTargetTitle(const std::string& id) = 0;
-  virtual std::string GetTargetUrl(const std::string& id) = 0;
-  virtual ~SocketServerDelegate() {}
-};
-
-// HTTP Server, writes messages requested as TransportActions, and responds
-// to HTTP requests and WS upgrades.
-
-class InspectorSocketServer {
- public:
-  InspectorSocketServer(std::unique_ptr<SocketServerDelegate> delegate,
-                        uv_loop_t* loop,
-                        const std::string& host,
-                        int port,
-                        FILE* out = stderr);
-  ~InspectorSocketServer();
-
-  // Start listening on host/port
-  bool Start();
-
-  // Called by the TransportAction sent with InspectorIo::Write():
-  //   kKill and kStop
-  void Stop();
-  //   kSendMessage
-  void Send(int session_id, const std::string& message);
-  //   kKill
-  void TerminateConnections();
-  int Port() const;
-
-  // Session connection lifecycle
-  void Accept(int server_port, uv_stream_t* server_socket);
-  bool HandleGetRequest(int session_id, const std::string& host,
-                        const std::string& path);
-  void SessionStarted(int session_id, const std::string& target_id,
-                      const std::string& ws_id);
-  void SessionTerminated(int session_id);
-  void MessageReceived(int session_id, const std::string& message) {
-    delegate_->MessageReceived(session_id, message);
-  }
-  SocketSession* Session(int session_id);
-  bool done() const {
-    return server_sockets_.empty() && connected_sessions_.empty();
-  }
-
-  static void CloseServerSocket(ServerSocket*);
-  using ServerSocketPtr = DeleteFnPtr<ServerSocket, CloseServerSocket>;
-
- private:
-  void SendListResponse(InspectorSocket* socket, const std::string& host,
-                        SocketSession* session);
-  std::string GetFrontendURL(bool is_compat,
-                             const std::string &formatted_address);
-  bool TargetExists(const std::string& id);
-
-  enum class ServerState {kNew, kRunning, kStopped};
-  uv_loop_t* loop_;
-  std::unique_ptr<SocketServerDelegate> delegate_;
-  const std::string host_;
-  int port_;
-  std::vector<ServerSocketPtr> server_sockets_;
-  std::map<int, std::pair<std::string, std::unique_ptr<SocketSession>>>
-      connected_sessions_;
-  int next_session_id_;
-  FILE* out_;
-  ServerState state_;
-};
-
-}  // namespace inspector
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_INSPECTOR_SOCKET_SERVER_H_

package/src/headers/10/js_stream.h

@@ -1,57 +0,0 @@
-#ifndef SRC_JS_STREAM_H_
-#define SRC_JS_STREAM_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "async_wrap.h"
-#include "env.h"
-#include "stream_base.h"
-#include "v8.h"
-
-namespace node {
-
-class JSStream : public AsyncWrap, public StreamBase {
- public:
-  static void Initialize(v8::Local<v8::Object> target,
-                         v8::Local<v8::Value> unused,
-                         v8::Local<v8::Context> context);
-
-  bool IsAlive() override;
-  bool IsClosing() override;
-  int ReadStart() override;
-  int ReadStop() override;
-
-  int DoShutdown(ShutdownWrap* req_wrap) override;
-  int DoWrite(WriteWrap* w,
-              uv_buf_t* bufs,
-              size_t count,
-              uv_stream_t* send_handle) override;
-
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(JSStream)
-  SET_SELF_SIZE(JSStream)
-
- protected:
-  JSStream(Environment* env, v8::Local<v8::Object> obj);
-
-  AsyncWrap* GetAsyncWrap() override;
-
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void ReadBuffer(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void EmitEOF(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static void OnAllocImpl(size_t size, uv_buf_t* buf, void* ctx);
-  static void OnReadImpl(ssize_t nread,
-                         const uv_buf_t* buf,
-                         uv_handle_type pending,
-                         void* ctx);
-
-  template <class Wrap>
-  static void Finish(const v8::FunctionCallbackInfo<v8::Value>& args);
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_JS_STREAM_H_