@encharm/cws 4.1.0 → 4.2.0

package/src/headers/13/req_wrap-inl.h

@@ -1,170 +0,0 @@
-#ifndef SRC_REQ_WRAP_INL_H_
-#define SRC_REQ_WRAP_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "req_wrap.h"
-#include "async_wrap-inl.h"
-#include "uv.h"
-
-namespace node {
-
-ReqWrapBase::ReqWrapBase(Environment* env) {
-  CHECK(env->has_run_bootstrapping_code());
-  env->req_wrap_queue()->PushBack(this);
-}
-
-template <typename T>
-ReqWrap<T>::ReqWrap(Environment* env,
-                    v8::Local<v8::Object> object,
-                    AsyncWrap::ProviderType provider)
-    : AsyncWrap(env, object, provider),
-      ReqWrapBase(env) {
-  Reset();
-}
-
-template <typename T>
-ReqWrap<T>::~ReqWrap() {
-  CHECK_EQ(false, persistent().IsEmpty());
-}
-
-template <typename T>
-void ReqWrap<T>::Dispatched() {
-  req_.data = this;
-}
-
-template <typename T>
-void ReqWrap<T>::Reset() {
-  original_callback_ = nullptr;
-  req_.data = nullptr;
-}
-
-template <typename T>
-ReqWrap<T>* ReqWrap<T>::from_req(T* req) {
-  return ContainerOf(&ReqWrap<T>::req_, req);
-}
-
-template <typename T>
-void ReqWrap<T>::Cancel() {
-  if (req_.data == this)  // Only cancel if already dispatched.
-    uv_cancel(reinterpret_cast<uv_req_t*>(&req_));
-}
-
-template <typename T>
-AsyncWrap* ReqWrap<T>::GetAsyncWrap() {
-  return this;
-}
-
-// Below is dark template magic designed to invoke libuv functions that
-// initialize uv_req_t instances in a unified fashion, to allow easier
-// tracking of active/inactive requests.
-
-// Invoke a generic libuv function that initializes uv_req_t instances.
-// This is, unfortunately, necessary since they come in three different
-// variants that can not all be invoked in the same way:
-// - int uv_foo(uv_loop_t* loop, uv_req_t* request, ...);
-// - int uv_foo(uv_req_t* request, ...);
-// - void uv_foo(uv_req_t* request, ...);
-template <typename ReqT, typename T>
-struct CallLibuvFunction;
-
-// Detect `int uv_foo(uv_loop_t* loop, uv_req_t* request, ...);`.
-template <typename ReqT, typename... Args>
-struct CallLibuvFunction<ReqT, int(*)(uv_loop_t*, ReqT*, Args...)> {
-  using T = int(*)(uv_loop_t*, ReqT*, Args...);
-  template <typename... PassedArgs>
-  static int Call(T fn, uv_loop_t* loop, ReqT* req, PassedArgs... args) {
-    return fn(loop, req, args...);
-  }
-};
-
-// Detect `int uv_foo(uv_req_t* request, ...);`.
-template <typename ReqT, typename... Args>
-struct CallLibuvFunction<ReqT, int(*)(ReqT*, Args...)> {
-  using T = int(*)(ReqT*, Args...);
-  template <typename... PassedArgs>
-  static int Call(T fn, uv_loop_t* loop, ReqT* req, PassedArgs... args) {
-    return fn(req, args...);
-  }
-};
-
-// Detect `void uv_foo(uv_req_t* request, ...);`.
-template <typename ReqT, typename... Args>
-struct CallLibuvFunction<ReqT, void(*)(ReqT*, Args...)> {
-  using T = void(*)(ReqT*, Args...);
-  template <typename... PassedArgs>
-  static int Call(T fn, uv_loop_t* loop, ReqT* req, PassedArgs... args) {
-    fn(req, args...);
-    return 0;
-  }
-};
-
-// This is slightly darker magic: This template is 'applied' to each parameter
-// passed to the libuv function. If the parameter type (aka `T`) is a
-// function type, it is assumed that this it is the request callback, and a
-// wrapper that calls the original callback is created.
-// If not, the parameter is passed through verbatim.
-template <typename ReqT, typename T>
-struct MakeLibuvRequestCallback {
-  static T For(ReqWrap<ReqT>* req_wrap, T v) {
-    static_assert(!is_callable<T>::value,
-                  "MakeLibuvRequestCallback missed a callback");
-    return v;
-  }
-};
-
-// Match the `void callback(uv_req_t*, ...);` signature that all libuv
-// callbacks use.
-template <typename ReqT, typename... Args>
-struct MakeLibuvRequestCallback<ReqT, void(*)(ReqT*, Args...)> {
-  using F = void(*)(ReqT* req, Args... args);
-
-  static void Wrapper(ReqT* req, Args... args) {
-    ReqWrap<ReqT>* req_wrap = ReqWrap<ReqT>::from_req(req);
-    req_wrap->env()->DecreaseWaitingRequestCounter();
-    F original_callback = reinterpret_cast<F>(req_wrap->original_callback_);
-    original_callback(req, args...);
-  }
-
-  static F For(ReqWrap<ReqT>* req_wrap, F v) {
-    CHECK_NULL(req_wrap->original_callback_);
-    req_wrap->original_callback_ =
-        reinterpret_cast<typename ReqWrap<ReqT>::callback_t>(v);
-    return Wrapper;
-  }
-};
-
-template <typename T>
-template <typename LibuvFunction, typename... Args>
-int ReqWrap<T>::Dispatch(LibuvFunction fn, Args... args) {
-  Dispatched();
-
-  // This expands as:
-  //
-  // int err = fn(env()->event_loop(), req(), arg1, arg2, Wrapper, arg3, ...)
-  //              ^                                       ^        ^
-  //              |                                       |        |
-  //              \-- Omitted if `fn` has no              |        |
-  //                  first `uv_loop_t*` argument         |        |
-  //                                                      |        |
-  //        A function callback whose first argument      |        |
-  //        matches the libuv request type is replaced ---/        |
-  //        by the `Wrapper` method defined above                  |
-  //                                                               |
-  //               Other (non-function) arguments are passed  -----/
-  //               through verbatim
-  int err = CallLibuvFunction<T, LibuvFunction>::Call(
-      fn,
-      env()->event_loop(),
-      req(),
-      MakeLibuvRequestCallback<T, Args>::For(this, args)...);
-  if (err >= 0)
-    env()->IncreaseWaitingRequestCounter();
-  return err;
-}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_REQ_WRAP_INL_H_

package/src/headers/13/req_wrap.h

@@ -1,77 +0,0 @@
-#ifndef SRC_REQ_WRAP_H_
-#define SRC_REQ_WRAP_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "async_wrap.h"
-#include "util.h"
-#include "v8.h"
-
-namespace node {
-
-class Environment;
-
-class ReqWrapBase {
- public:
-  explicit inline ReqWrapBase(Environment* env);
-
-  virtual ~ReqWrapBase() = default;
-
-  virtual void Cancel() = 0;
-  virtual AsyncWrap* GetAsyncWrap() = 0;
-
- private:
-  friend int GenDebugSymbols();
-  friend class Environment;
-
-  ListNode<ReqWrapBase> req_wrap_queue_;
-};
-
-template <typename T>
-class ReqWrap : public AsyncWrap, public ReqWrapBase {
- public:
-  inline ReqWrap(Environment* env,
-                 v8::Local<v8::Object> object,
-                 AsyncWrap::ProviderType provider);
-  inline ~ReqWrap() override;
-  // Call this after the req has been dispatched, if that did not already
-  // happen by using Dispatch().
-  inline void Dispatched();
-  // Call this after a request has finished, if re-using this object is planned.
-  inline void Reset();
-  T* req() { return &req_; }
-  inline void Cancel() final;
-  inline AsyncWrap* GetAsyncWrap() override;
-
-  static ReqWrap* from_req(T* req);
-
-  template <typename LibuvFunction, typename... Args>
-  inline int Dispatch(LibuvFunction fn, Args... args);
-
- private:
-  friend int GenDebugSymbols();
-
-  // Adding `friend struct MakeLibuvRequestCallback` is not enough anymore
-  // for some reason. Consider this private.
- public:
-  typedef void (*callback_t)();
-  callback_t original_callback_ = nullptr;
-
- protected:
-  // req_wrap_queue_ needs to be at a fixed offset from the start of the class
-  // because it is used by ContainerOf to calculate the address of the embedding
-  // ReqWrap. ContainerOf compiles down to simple, fixed pointer arithmetic. It
-  // is also used by src/node_postmortem_metadata.cc to calculate offsets and
-  // generate debug symbols for ReqWrap, which assumes that the position of
-  // members in memory are predictable. sizeof(req_) depends on the type of T,
-  // so req_wrap_queue_ would no longer be at a fixed offset if it came after
-  // req_. For more information please refer to
-  // `doc/guides/node-postmortem-support.md`
-  T req_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_REQ_WRAP_H_

package/src/headers/13/spawn_sync.h

@@ -1,242 +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_SPAWN_SYNC_H_
-#define SRC_SPAWN_SYNC_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node_buffer.h"
-#include "uv.h"
-#include "v8.h"
-
-namespace node {
-
-
-
-class SyncProcessOutputBuffer;
-class SyncProcessStdioPipe;
-class SyncProcessRunner;
-
-
-class SyncProcessOutputBuffer {
-  static const unsigned int kBufferSize = 65536;
-
- public:
-  inline SyncProcessOutputBuffer() = default;
-
-  inline void OnAlloc(size_t suggested_size, uv_buf_t* buf) const;
-  inline void OnRead(const uv_buf_t* buf, size_t nread);
-
-  inline size_t Copy(char* dest) const;
-
-  inline unsigned int available() const;
-  inline unsigned int used() const;
-
-  inline SyncProcessOutputBuffer* next() const;
-  inline void set_next(SyncProcessOutputBuffer* next);
-
- private:
-  // Use unsigned int because that's what `uv_buf_init` takes.
-  mutable char data_[kBufferSize];
-  unsigned int used_ = 0;
-
-  SyncProcessOutputBuffer* next_ = nullptr;
-};
-
-
-class SyncProcessStdioPipe {
-  enum Lifecycle {
-    kUninitialized = 0,
-    kInitialized,
-    kStarted,
-    kClosing,
-    kClosed
-  };
-
- public:
-  SyncProcessStdioPipe(SyncProcessRunner* process_handler,
-                       bool readable,
-                       bool writable,
-                       uv_buf_t input_buffer);
-  ~SyncProcessStdioPipe();
-
-  int Initialize(uv_loop_t* loop);
-  int Start();
-  void Close();
-
-  v8::Local<v8::Object> GetOutputAsBuffer(Environment* env) const;
-
-  inline bool readable() const;
-  inline bool writable() const;
-  inline uv_stdio_flags uv_flags() const;
-
-  inline uv_pipe_t* uv_pipe() const;
-  inline uv_stream_t* uv_stream() const;
-  inline uv_handle_t* uv_handle() const;
-
- private:
-  inline size_t OutputLength() const;
-  inline void CopyOutput(char* dest) const;
-
-  inline void OnAlloc(size_t suggested_size, uv_buf_t* buf);
-  inline void OnRead(const uv_buf_t* buf, ssize_t nread);
-  inline void OnWriteDone(int result);
-  inline void OnShutdownDone(int result);
-  inline void OnClose();
-
-  inline void SetError(int error);
-
-  static void AllocCallback(uv_handle_t* handle,
-                            size_t suggested_size,
-                            uv_buf_t* buf);
-  static void ReadCallback(uv_stream_t* stream,
-                           ssize_t nread,
-                           const uv_buf_t* buf);
-  static void WriteCallback(uv_write_t* req, int result);
-  static void ShutdownCallback(uv_shutdown_t* req, int result);
-  static void CloseCallback(uv_handle_t* handle);
-
-  SyncProcessRunner* process_handler_;
-
-  bool readable_;
-  bool writable_;
-  uv_buf_t input_buffer_;
-
-  SyncProcessOutputBuffer* first_output_buffer_;
-  SyncProcessOutputBuffer* last_output_buffer_;
-
-  mutable uv_pipe_t uv_pipe_;
-  uv_write_t write_req_;
-  uv_shutdown_t shutdown_req_;
-
-  Lifecycle lifecycle_;
-};
-
-
-class SyncProcessRunner {
-  enum Lifecycle {
-    kUninitialized = 0,
-    kInitialized,
-    kHandlesClosed
-  };
-
- public:
-  static void Initialize(v8::Local<v8::Object> target,
-                         v8::Local<v8::Value> unused,
-                         v8::Local<v8::Context> context,
-                         void* priv);
-  static void Spawn(const v8::FunctionCallbackInfo<v8::Value>& args);
-
- private:
-  friend class SyncProcessStdioPipe;
-
-  explicit SyncProcessRunner(Environment* env_);
-  ~SyncProcessRunner();
-
-  inline Environment* env() const;
-
-  v8::MaybeLocal<v8::Object> Run(v8::Local<v8::Value> options);
-  v8::Maybe<bool> TryInitializeAndRunLoop(v8::Local<v8::Value> options);
-  void CloseHandlesAndDeleteLoop();
-
-  void CloseStdioPipes();
-  void CloseKillTimer();
-
-  void Kill();
-  void IncrementBufferSizeAndCheckOverflow(ssize_t length);
-
-  void OnExit(int64_t exit_status, int term_signal);
-  void OnKillTimerTimeout();
-
-  int GetError();
-  void SetError(int error);
-  void SetPipeError(int pipe_error);
-
-  v8::Local<v8::Object> BuildResultObject();
-  v8::Local<v8::Array> BuildOutputArray();
-
-  v8::Maybe<int> ParseOptions(v8::Local<v8::Value> js_value);
-  int ParseStdioOptions(v8::Local<v8::Value> js_value);
-  int ParseStdioOption(int child_fd, v8::Local<v8::Object> js_stdio_option);
-
-  inline int AddStdioIgnore(uint32_t child_fd);
-  inline int AddStdioPipe(uint32_t child_fd,
-                          bool readable,
-                          bool writable,
-                          uv_buf_t input_buffer);
-  inline int AddStdioInheritFD(uint32_t child_fd, int inherit_fd);
-
-  static bool IsSet(v8::Local<v8::Value> value);
-  v8::Maybe<int> CopyJsString(v8::Local<v8::Value> js_value,
-                              const char** target);
-  v8::Maybe<int> CopyJsStringArray(v8::Local<v8::Value> js_value,
-                                   char** target);
-
-  static void ExitCallback(uv_process_t* handle,
-                           int64_t exit_status,
-                           int term_signal);
-  static void KillTimerCallback(uv_timer_t* handle);
-  static void KillTimerCloseCallback(uv_handle_t* handle);
-
-  double max_buffer_;
-  uint64_t timeout_;
-  int kill_signal_;
-
-  uv_loop_t* uv_loop_;
-
-  uint32_t stdio_count_;
-  uv_stdio_container_t* uv_stdio_containers_;
-  std::vector<std::unique_ptr<SyncProcessStdioPipe>> stdio_pipes_;
-  bool stdio_pipes_initialized_;
-
-  uv_process_options_t uv_process_options_;
-  const char* file_buffer_;
-  char* args_buffer_;
-  char* env_buffer_;
-  const char* cwd_buffer_;
-
-  uv_process_t uv_process_;
-  bool killed_;
-
-  size_t buffered_output_size_;
-  int64_t exit_status_;
-  int term_signal_;
-
-  uv_timer_t uv_timer_;
-  bool kill_timer_initialized_;
-
-  // Errors that happen in one of the pipe handlers are stored in the
-  // `pipe_error` field. They are treated as "low-priority", only to be
-  // reported if no more serious errors happened.
-  int error_;
-  int pipe_error_;
-
-  Lifecycle lifecycle_;
-
-  Environment* env_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_SPAWN_SYNC_H_

package/src/headers/13/stream_wrap.h

@@ -1,130 +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_STREAM_WRAP_H_
-#define SRC_STREAM_WRAP_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "stream_base.h"
-#include "handle_wrap.h"
-#include "v8.h"
-
-namespace node {
-
-class Environment;
-
-class LibuvStreamWrap : public HandleWrap, public StreamBase {
- public:
-  static void Initialize(v8::Local<v8::Object> target,
-                         v8::Local<v8::Value> unused,
-                         v8::Local<v8::Context> context,
-                         void* priv);
-
-  int GetFD() override;
-  bool IsAlive() override;
-  bool IsClosing() override;
-  bool IsIPCPipe() override;
-
-  // JavaScript functions
-  int ReadStart() override;
-  int ReadStop() override;
-
-  // Resource implementation
-  int DoShutdown(ShutdownWrap* req_wrap) override;
-  int DoTryWrite(uv_buf_t** bufs, size_t* count) override;
-  int DoWrite(WriteWrap* w,
-              uv_buf_t* bufs,
-              size_t count,
-              uv_stream_t* send_handle) override;
-
-  inline uv_stream_t* stream() const {
-    return stream_;
-  }
-
-  inline bool is_named_pipe() const {
-    return stream()->type == UV_NAMED_PIPE;
-  }
-
-  inline bool is_named_pipe_ipc() const {
-    return is_named_pipe() &&
-           reinterpret_cast<const uv_pipe_t*>(stream())->ipc != 0;
-  }
-
-  inline bool is_tcp() const {
-    return stream()->type == UV_TCP;
-  }
-
-  ShutdownWrap* CreateShutdownWrap(v8::Local<v8::Object> object) override;
-  WriteWrap* CreateWriteWrap(v8::Local<v8::Object> object) override;
-
-  static LibuvStreamWrap* From(Environment* env, v8::Local<v8::Object> object);
-
- protected:
-  LibuvStreamWrap(Environment* env,
-                  v8::Local<v8::Object> object,
-                  uv_stream_t* stream,
-                  AsyncWrap::ProviderType provider);
-
-  AsyncWrap* GetAsyncWrap() override;
-
-  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
-      Environment* env);
-
- protected:
-  inline void set_fd(int fd) {
-#ifdef _WIN32
-    fd_ = fd;
-#endif
-  }
-
-
- private:
-  static void GetWriteQueueSize(
-      const v8::FunctionCallbackInfo<v8::Value>& info);
-  static void SetBlocking(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  // Callbacks for libuv
-  void OnUvAlloc(size_t suggested_size, uv_buf_t* buf);
-  void OnUvRead(ssize_t nread, const uv_buf_t* buf);
-
-  static void AfterUvWrite(uv_write_t* req, int status);
-  static void AfterUvShutdown(uv_shutdown_t* req, int status);
-
-  uv_stream_t* const stream_;
-
-#ifdef _WIN32
-  // We don't always have an FD that we could look up on the stream_
-  // object itself on Windows. However, for some cases, we open handles
-  // using FDs; In that case, we can store and provide the value.
-  // This became necessary because it allows to detect situations
-  // where multiple handles refer to the same stdio FDs (in particular,
-  // a possible IPC channel and a regular process.std??? stream).
-  int fd_ = -1;
-#endif
-};
-
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_STREAM_WRAP_H_

package/src/headers/13/string_decoder-inl.h

@@ -1,37 +0,0 @@
-#ifndef SRC_STRING_DECODER_INL_H_
-#define SRC_STRING_DECODER_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "string_decoder.h"
-
-namespace node {
-
-void StringDecoder::SetEncoding(enum encoding encoding) {
-  state_[kBufferedBytes] = 0;
-  state_[kMissingBytes] = 0;
-  state_[kEncodingField] = encoding;
-}
-
-enum encoding StringDecoder::Encoding() const {
-  return static_cast<enum encoding>(state_[kEncodingField]);
-}
-
-unsigned StringDecoder::BufferedBytes() const {
-  return state_[kBufferedBytes];
-}
-
-unsigned StringDecoder::MissingBytes() const {
-  return state_[kMissingBytes];
-}
-
-char* StringDecoder::IncompleteCharacterBuffer() {
-  return reinterpret_cast<char*>(state_ + kIncompleteCharactersStart);
-}
-
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif   // SRC_STRING_DECODER_INL_H_

package/src/headers/13/string_decoder.h

@@ -1,50 +0,0 @@
-#ifndef SRC_STRING_DECODER_H_
-#define SRC_STRING_DECODER_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node.h"
-
-namespace node {
-
-class StringDecoder {
- public:
-  StringDecoder() { state_[kEncodingField] = BUFFER; }
-  inline void SetEncoding(enum encoding encoding);
-  inline enum encoding Encoding() const;
-
-  inline char* IncompleteCharacterBuffer();
-  inline unsigned MissingBytes() const;
-  inline unsigned BufferedBytes() const;
-
-  // Decode a string from the specified encoding.
-  // The value pointed to by `nread` will be modified to reflect that
-  // less data may have been read because it ended on an incomplete character
-  // and more data may have been read because a previously incomplete character
-  // was finished.
-  v8::MaybeLocal<v8::String> DecodeData(v8::Isolate* isolate,
-                                        const char* data,
-                                        size_t* nread);
-  // Flush an incomplete character. For character encodings like UTF8 this
-  // means printing replacement characters, buf for e.g. Base64 the returned
-  // string contains more data.
-  v8::MaybeLocal<v8::String> FlushData(v8::Isolate* isolate);
-
-  enum Fields {
-    kIncompleteCharactersStart = 0,
-    kIncompleteCharactersEnd = 4,
-    kMissingBytes = 4,
-    kBufferedBytes = 5,
-    kEncodingField = 6,
-    kNumFields = 7
-  };
-
- private:
-  uint8_t state_[kNumFields] = {};
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif   // SRC_STRING_DECODER_H_