src/inspector/node_string.cc

#include "node_string.h"
#include "crdtp/json.h"
#include "node/inspector/protocol/Protocol.h"
#include "simdutf.h"
#include "util-inl.h"

namespace crdtp {

bool ProtocolTypeTraits<std::string>::Deserialize(DeserializerState* state,
                                                  std::string* value) {
  if (state->tokenizer()->TokenTag() == cbor::CBORTokenTag::STRING8) {
    span<uint8_t> cbor_span = state->tokenizer()->GetString8();
    value->assign(reinterpret_cast<const char*>(cbor_span.data()),
                  cbor_span.size());
    return true;
  }
  CHECK(state->tokenizer()->TokenTag() == cbor::CBORTokenTag::STRING16);
  span<uint8_t> utf16le = state->tokenizer()->GetString16WireRep();

  value->assign(node::inspector::protocol::StringUtil::fromUTF16LE(
      reinterpret_cast<const uint16_t*>(utf16le.data()),
      utf16le.size() / sizeof(uint16_t)));
  return true;
}

void ProtocolTypeTraits<std::string>::Serialize(const std::string& value,
                                                std::vector<uint8_t>* bytes) {
  cbor::EncodeString8(SpanFrom(value), bytes);
}

bool ProtocolTypeTraits<node::inspector::protocol::Binary>::Deserialize(
    DeserializerState* state, node::inspector::protocol::Binary* value) {
  CHECK(state->tokenizer()->TokenTag() == cbor::CBORTokenTag::BINARY);
  span<uint8_t> cbor_span = state->tokenizer()->GetBinary();
  *value = node::inspector::protocol::Binary::fromSpan(cbor_span);
  return true;
}

void ProtocolTypeTraits<node::inspector::protocol::Binary>::Serialize(
    const node::inspector::protocol::Binary& value,
    std::vector<uint8_t>* bytes) {
  cbor::EncodeString8(SpanFrom(value.toBase64()), bytes);
}

}  // namespace crdtp

namespace node {
namespace inspector {
namespace protocol {

String StringUtil::StringViewToUtf8(v8_inspector::StringView view) {
  if (view.length() == 0)
    return "";
  if (view.is8Bit()) {
    return std::string(reinterpret_cast<const char*>(view.characters8()),
                       view.length());
  }
  return fromUTF16(view.characters16(), view.length());
}

String StringUtil::fromUTF16(const uint16_t* data, size_t length) {
  auto casted_data = reinterpret_cast<const char16_t*>(data);
  size_t expected_utf8_length =
      simdutf::utf8_length_from_utf16(casted_data, length);
  MaybeStackBuffer<char> buffer(expected_utf8_length);
  // simdutf::convert_utf16_to_utf8 returns zero in case of error.
  size_t utf8_length =
      simdutf::convert_utf16_to_utf8(casted_data, length, buffer.out());
  // We have that utf8_length == expected_utf8_length if and only
  // if the input was a valid UTF-16 string. Otherwise, utf8_length
  // must be zero.
  CHECK(utf8_length == 0 || utf8_length == expected_utf8_length);
  // An invalid UTF-16 input will generate the empty string:
  return String(buffer.out(), utf8_length);
}

String StringUtil::fromUTF8(const uint8_t* data, size_t length) {
  return std::string(reinterpret_cast<const char*>(data), length);
}

String StringUtil::fromUTF16LE(const uint16_t* data, size_t length) {
  auto casted_data = reinterpret_cast<const char16_t*>(data);
  size_t expected_utf8_length =
      simdutf::utf8_length_from_utf16le(casted_data, length);
  MaybeStackBuffer<char> buffer(expected_utf8_length);
  // simdutf::convert_utf16le_to_utf8 returns zero in case of error.
  size_t utf8_length =
      simdutf::convert_utf16le_to_utf8(casted_data, length, buffer.out());
  // We have that utf8_length == expected_utf8_length if and only
  // if the input was a valid UTF-16 string. Otherwise, utf8_length
  // must be zero.
  CHECK(utf8_length == 0 || utf8_length == expected_utf8_length);
  // An invalid UTF-16 input will generate the empty string:
  return String(buffer.out(), utf8_length);
}

const uint8_t* StringUtil::CharactersUTF8(const std::string_view s) {
  return reinterpret_cast<const uint8_t*>(s.data());
}

size_t StringUtil::CharacterCount(const std::string_view s) {
  // Return the length of underlying representation storage.
  // E.g. for std::basic_string_view<char>, return its byte length.
  // If we adopt a variant underlying store string type, like
  // `v8_inspector::StringView`, for UTF16, return the length of the
  // underlying uint16_t store.
  return s.length();
}

String Binary::toBase64() const {
  size_t expected_base64_length =
      simdutf::base64_length_from_binary(bytes_->size());
  MaybeStackBuffer<char> buffer(expected_base64_length);

  size_t len =
      simdutf::binary_to_base64(reinterpret_cast<const char*>(bytes_->data()),
                                bytes_->size(),
                                buffer.out());
  CHECK_EQ(len, expected_base64_length);
  return buffer.ToString();
}

// static
Binary Binary::concat(const std::vector<Binary>& binaries) {
  size_t total_size = 0;
  for (const auto& binary : binaries) {
    total_size += binary.size();
  }
  auto bytes = std::make_shared<std::vector<uint8_t>>(total_size);
  uint8_t* data_ptr = bytes->data();
  for (const auto& binary : binaries) {
    memcpy(data_ptr, binary.data(), binary.size());
    data_ptr += binary.size();
  }
  return Binary(bytes);
}

// static
Binary Binary::fromBase64(const String& base64, bool* success) {
  Binary binary{};
  size_t base64_len = simdutf::maximal_binary_length_from_base64(
      base64.data(), base64.length());
  binary.bytes_->resize(base64_len);

  simdutf::result result;
  result =
      simdutf::base64_to_binary(base64.data(),
                                base64.length(),
                                reinterpret_cast<char*>(binary.bytes_->data()));
  CHECK_EQ(result.error, simdutf::error_code::SUCCESS);
  return binary;
}

// static
Binary Binary::fromUint8Array(v8::Local<v8::Uint8Array> data) {
  auto bytes = std::make_shared<std::vector<uint8_t>>(data->ByteLength());
  size_t size = data->CopyContents(bytes->data(), data->ByteLength());
  CHECK_EQ(size, data->ByteLength());
  return Binary(bytes);
}

}  // namespace protocol
}  // namespace inspector
}  // namespace node