Remove usage of to-be-deprecated APIs from v8 core

src/extensions/externalize-string-extension.cc

 // Copyright 2010 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.
 
 #include "src/extensions/externalize-string-extension.h"
 
 namespace v8 {
 namespace internal {
 
 template <typename Char, typename Base>
@@ skipping 36 matching lines @@
     DCHECK(strcmp(*v8::String::Utf8Value(str), "isOneByteString") == 0);
     return v8::FunctionTemplate::New(isolate,
                                      ExternalizeStringExtension::IsOneByte);
   }
 }
 
 
 void ExternalizeStringExtension::Externalize(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() < 1 || !args[0]->IsString()) {
-    args.GetIsolate()->ThrowException(v8::String::NewFromUtf8(
-        args.GetIsolate(),
-        "First parameter to externalizeString() must be a string."));
+    args.GetIsolate()->ThrowException(
+        v8::String::NewFromUtf8(
+            args.GetIsolate(),
+            "First parameter to externalizeString() must be a string.",
+            NewStringType::kNormal).ToLocalChecked());
     return;
   }
   bool force_two_byte = false;
   if (args.Length() >= 2) {
     if (args[1]->IsBoolean()) {
-      force_two_byte = args[1]->BooleanValue();
+      force_two_byte =
+          args[1]
+              ->BooleanValue(args.GetIsolate()->GetCurrentContext())
+              .FromJust();
     } else {
-      args.GetIsolate()->ThrowException(v8::String::NewFromUtf8(
-        args.GetIsolate(),
-        "Second parameter to externalizeString() must be a boolean."));
+      args.GetIsolate()->ThrowException(
+          v8::String::NewFromUtf8(
+              args.GetIsolate(),
+              "Second parameter to externalizeString() must be a boolean.",
+              NewStringType::kNormal).ToLocalChecked());
       return;
     }
   }
   bool result = false;
   Handle<String> string = Utils::OpenHandle(*args[0].As<v8::String>());
   if (string->IsExternalString()) {
-    args.GetIsolate()->ThrowException(v8::String::NewFromUtf8(
-        args.GetIsolate(),
-        "externalizeString() can't externalize twice."));
+    args.GetIsolate()->ThrowException(
+        v8::String::NewFromUtf8(args.GetIsolate(),
+                                "externalizeString() can't externalize twice.",
+                                NewStringType::kNormal).ToLocalChecked());
     return;
   }
   if (string->IsOneByteRepresentation() && !force_two_byte) {
     uint8_t* data = new uint8_t[string->length()];
     String::WriteToFlat(*string, data, 0, string->length());
     SimpleOneByteStringResource* resource = new SimpleOneByteStringResource(
         reinterpret_cast<char*>(data), string->length());
     result = string->MakeExternal(resource);
     if (result) {
       i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
       isolate->heap()->external_string_table()->AddString(*string);
     }
     if (!result) delete resource;
   } else {
     uc16* data = new uc16[string->length()];
     String::WriteToFlat(*string, data, 0, string->length());
     SimpleTwoByteStringResource* resource = new SimpleTwoByteStringResource(
         data, string->length());
     result = string->MakeExternal(resource);
     if (result) {
       i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
       isolate->heap()->external_string_table()->AddString(*string);
     }
     if (!result) delete resource;
   }
   if (!result) {
-    args.GetIsolate()->ThrowException(v8::String::NewFromUtf8(
-        args.GetIsolate(), "externalizeString() failed."));
+    args.GetIsolate()->ThrowException(
+        v8::String::NewFromUtf8(args.GetIsolate(),
+                                "externalizeString() failed.",
+                                NewStringType::kNormal).ToLocalChecked());
     return;
   }
 }
 
 
 void ExternalizeStringExtension::IsOneByte(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() != 1 || !args[0]->IsString()) {
-    args.GetIsolate()->ThrowException(v8::String::NewFromUtf8(
-        args.GetIsolate(),
-        "isOneByteString() requires a single string argument."));
+    args.GetIsolate()->ThrowException(
+        v8::String::NewFromUtf8(
+            args.GetIsolate(),
+            "isOneByteString() requires a single string argument.",
+            NewStringType::kNormal).ToLocalChecked());
     return;
   }
   bool is_one_byte =
       Utils::OpenHandle(*args[0].As<v8::String>())->IsOneByteRepresentation();
   args.GetReturnValue().Set(is_one_byte);
 }
 
 }  // namespace internal
 }  // namespace v8