src: use non-deprecated WriteUtf8V2() method

Author: anonrig

src/crypto/crypto_util.cc

@@ -402,10 +402,10 @@ ByteSource ByteSource::FromString(Environment* env, Local<String> str,
   size_t size = str->Utf8LengthV2(env->isolate());
   size_t alloc_size = ntc ? size + 1 : size;
   auto out = DataPointer::Alloc(alloc_size);
-  int opts = String::NO_OPTIONS;
-  if (!ntc) opts |= String::NO_NULL_TERMINATION;
-  str->WriteUtf8(
-      env->isolate(), static_cast<char*>(out.get()), alloc_size, nullptr, opts);
+  int flags = String::WriteFlags::kNone;
+  if (ntc) flags |= String::WriteFlags::kNullTerminate;
+  str->WriteUtf8V2(
+      env->isolate(), static_cast<char*>(out.get()), alloc_size, flags);
   return ByteSource::Allocated(out.release());
 }
 

src/encoding_binding.cc

@@ -101,13 +101,12 @@ void BindingData::EncodeInto(const FunctionCallbackInfo<Value>& args) {
   char* write_result = static_cast<char*>(buf->Data()) + dest->ByteOffset();
   size_t dest_length = dest->ByteLength();
 
-  int nchars;
-  int written = source->WriteUtf8(
-      isolate,
-      write_result,
-      dest_length,
-      &nchars,
-      String::NO_NULL_TERMINATION | String::REPLACE_INVALID_UTF8);
+  size_t nchars;
+  size_t written = source->WriteUtf8V2(isolate,
+                                       write_result,
+                                       dest_length,
+                                       String::WriteFlags::kReplaceInvalidUtf8,
+                                       &nchars);
 
   binding_data->encode_into_results_buffer_[0] = nchars;
   binding_data->encode_into_results_buffer_[1] = written;
@@ -131,11 +130,11 @@ void BindingData::EncodeUtf8String(const FunctionCallbackInfo<Value>& args) {
 
     CHECK(bs);
 
-    str->WriteUtf8(isolate,
-                   static_cast<char*>(bs->Data()),
-                   -1,  // We are certain that `data` is sufficiently large
-                   nullptr,
-                   String::NO_NULL_TERMINATION | String::REPLACE_INVALID_UTF8);
+    // We are certain that `data` is sufficiently large
+    str->WriteUtf8V2(isolate,
+                     static_cast<char*>(bs->Data()),
+                     bs->MaxByteLength(),
+                     String::WriteFlags::kReplaceInvalidUtf8);
 
     ab = ArrayBuffer::New(isolate, std::move(bs));
   }

src/js_native_api_v8.cc

@@ -2484,12 +2484,12 @@ napi_status NAPI_CDECL napi_get_value_string_utf8(
     CHECK_ARG(env, result);
     *result = val.As<v8::String>()->Utf8LengthV2(env->isolate);
   } else if (bufsize != 0) {
-    int copied = val.As<v8::String>()->WriteUtf8(
-        env->isolate,
-        buf,
-        bufsize - 1,
-        nullptr,
-        v8::String::REPLACE_INVALID_UTF8 | v8::String::NO_NULL_TERMINATION);
+    auto str = val.As<v8::String>();
+    size_t copied =
+        str->WriteUtf8V2(env->isolate,
+                         buf,
+                         bufsize - 1,
+                         v8::String::WriteFlags::kReplaceInvalidUtf8);
 
     buf[copied] = '\0';
     if (result != nullptr) {

src/string_bytes.cc

@@ -271,7 +271,8 @@ size_t StringBytes::Write(Isolate* isolate,
 
     case BUFFER:
     case UTF8:
-      nbytes = str->WriteUtf8(isolate, buf, buflen, nullptr, flags);
+      nbytes = str->WriteUtf8V2(
+          isolate, buf, buflen, String::WriteFlags::kReplaceInvalidUtf8);
       break;
 
     case UCS2: {

src/util.cc

@@ -125,12 +125,8 @@ static void MakeUtf8String(Isolate* isolate,
   size_t storage = (3 * value_length) + 1;
   target->AllocateSufficientStorage(storage);
 
-  // TODO(@anonrig): Use simdutf to speed up non-one-byte strings once it's
-  // implemented
-  const int flags =
-      String::NO_NULL_TERMINATION | String::REPLACE_INVALID_UTF8;
-  const int length =
-      string->WriteUtf8(isolate, target->out(), storage, nullptr, flags);
+  size_t length = string->WriteUtf8V2(
+      isolate, target->out(), storage, String::WriteFlags::kReplaceInvalidUtf8);
   target->SetLengthAndZeroTerminate(length);
 }