[api] Add v8::Isolate::ThrowError helper

Add a ThrowError helper to encourage throwing full Error objects
instead of just v8::Strings.

Bug: v8:11195
Change-Id: I15d75b1d39b817de3b9026a836b57a70d7c16a28
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2811738
Commit-Queue: Camillo Bruni <cbruni@chromium.org>
Reviewed-by: Dan Elphick <delphick@chromium.org>
Reviewed-by: Yang Guo <yangguo@chromium.org>
Reviewed-by: Marja Hölttä <marja@chromium.org>
Cr-Commit-Position: refs/heads/master@{#73958}

include/v8.h

@@ -8872,6 +8872,17 @@ class V8_EXPORT Isolate {
    */
   Local<Context> GetIncumbentContext();
 
+  /**
+   * Schedules a v8::Exception::Error with the given message.
+   * See ThrowException for more details. Templatized to provide compile-time
+   * errors in case of too long strings (see v8::String::NewFromUtf8Literal).
+   */
+  template <int N>
+  Local<Value> ThrowError(const char (&message)[N]) {
+    return ThrowError(String::NewFromUtf8Literal(this, message));
+  }
+  Local<Value> ThrowError(Local<String> message);
+
   /**
    * Schedules an exception to be thrown when returning to JavaScript.  When an
    * exception has been scheduled it is illegal to invoke any JavaScript

samples/shell.cc

@@ -147,20 +147,17 @@ void Print(const v8::FunctionCallbackInfo<v8::Value>& args) {
 // the argument into a JavaScript string.
 void Read(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() != 1) {
-    args.GetIsolate()->ThrowException(
+    args.GetIsolate()->ThrowError("Bad parameters");
-        v8::String::NewFromUtf8Literal(args.GetIsolate(), "Bad parameters"));
     return;
   }
   v8::String::Utf8Value file(args.GetIsolate(), args[0]);
   if (*file == NULL) {
-    args.GetIsolate()->ThrowException(v8::String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError("Error loading file");
-        args.GetIsolate(), "Error loading file"));
     return;
   }
   v8::Local<v8::String> source;
   if (!ReadFile(args.GetIsolate(), *file).ToLocal(&source)) {
-    args.GetIsolate()->ThrowException(v8::String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError("Error loading file");
-        args.GetIsolate(), "Error loading file"));
     return;
   }
 
@@ -175,19 +172,16 @@ void Load(const v8::FunctionCallbackInfo<v8::Value>& args) {
     v8::HandleScope handle_scope(args.GetIsolate());
     v8::String::Utf8Value file(args.GetIsolate(), args[i]);
     if (*file == NULL) {
-      args.GetIsolate()->ThrowException(v8::String::NewFromUtf8Literal(
+      args.GetIsolate()->ThrowError("Error loading file");
-          args.GetIsolate(), "Error loading file"));
       return;
     }
     v8::Local<v8::String> source;
     if (!ReadFile(args.GetIsolate(), *file).ToLocal(&source)) {
-      args.GetIsolate()->ThrowException(v8::String::NewFromUtf8Literal(
+      args.GetIsolate()->ThrowError("Error loading file");
-          args.GetIsolate(), "Error loading file"));
       return;
     }
     if (!ExecuteString(args.GetIsolate(), source, args[i], false, false)) {
-      args.GetIsolate()->ThrowException(v8::String::NewFromUtf8Literal(
+      args.GetIsolate()->ThrowError("Error executing file");
-          args.GetIsolate(), "Error executing file"));
       return;
     }
   }

src/api/api.cc

@@ -8012,6 +8012,10 @@ v8::Local<v8::Context> Isolate::GetIncumbentContext() {
   return Utils::ToLocal(context);
 }
 
+v8::Local<Value> Isolate::ThrowError(v8::Local<v8::String> message) {
+  return ThrowException(v8::Exception::Error(message));
+}
+
 v8::Local<Value> Isolate::ThrowException(v8::Local<v8::Value> value) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
   ENTER_V8_DO_NOT_USE(isolate);

src/d8/async-hooks-wrapper.cc

@@ -47,8 +47,7 @@ static AsyncHooksWrap* UnwrapHook(
   AsyncHooks* hooks = PerIsolateData::Get(isolate)->GetAsyncHooks();
 
   if (!hooks->async_hook_ctor.Get(isolate)->HasInstance(hook)) {
-    isolate->ThrowException(String::NewFromUtf8Literal(
+    isolate->ThrowError("Invalid 'this' passed instead of AsyncHooks instance");
-        isolate, "Invalid 'this' passed instead of AsyncHooks instance"));
     return nullptr;
   }
 
@@ -87,8 +86,7 @@ Local<Object> AsyncHooks::CreateHook(
   Local<Context> currentContext = isolate->GetCurrentContext();
 
   if (args.Length() != 1 || !args[0]->IsObject()) {
-    isolate->ThrowException(String::NewFromUtf8Literal(
+    isolate->ThrowError("Invalid arguments passed to createHook");
-        isolate, "Invalid arguments passed to createHook"));
     return Local<Object>();
   }
 

src/d8/d8-console.cc

@@ -43,8 +43,7 @@ void D8Console::Assert(const debug::ConsoleCallArguments& args,
   // false-ish.
   if (args.Length() > 0 && args[0]->BooleanValue(isolate_)) return;
   WriteToFile("console.assert", stdout, isolate_, args);
-  isolate_->ThrowException(v8::Exception::Error(
+  isolate_->ThrowError("console.assert failed");
-      v8::String::NewFromUtf8Literal(isolate_, "console.assert failed")));
 }
 
 void D8Console::Log(const debug::ConsoleCallArguments& args,

src/d8/d8-posix.cc

@@ -159,8 +159,8 @@ class ExecArgs {
   bool Init(Isolate* isolate, Local<Value> arg0, Local<Array> command_args) {
     String::Utf8Value prog(isolate, arg0);
     if (*prog == nullptr) {
-      isolate->ThrowException(String::NewFromUtf8Literal(
+      isolate->ThrowError(
-          isolate, "os.system(): String conversion of program name failed"));
+          "os.system(): String conversion of program name failed");
       return false;
     }
     int len = prog.length() + 3;
@@ -176,8 +176,8 @@ class ExecArgs {
       String::Utf8Value utf8_arg(isolate, arg);
       if (*utf8_arg == nullptr) {
         exec_args_[i] = nullptr;  // Consistent state for destructor.
-        isolate->ThrowException(String::NewFromUtf8Literal(
+        isolate->ThrowError(
-            isolate, "os.system(): String conversion of argument failed."));
+            "os.system(): String conversion of argument failed.");
         return false;
       }
       int len = utf8_arg.length() + 1;
@@ -214,8 +214,7 @@ static bool GetTimeouts(const v8::FunctionCallbackInfo<v8::Value>& args,
                            ->Int32Value(args.GetIsolate()->GetCurrentContext())
                            .FromJust();
     } else {
-      args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+      args.GetIsolate()->ThrowError("system: Argument 4 must be a number");
-          args.GetIsolate(), "system: Argument 4 must be a number"));
       return false;
     }
   }
@@ -225,14 +224,19 @@ static bool GetTimeouts(const v8::FunctionCallbackInfo<v8::Value>& args,
                           ->Int32Value(args.GetIsolate()->GetCurrentContext())
                           .FromJust();
     } else {
-      args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+      args.GetIsolate()->ThrowError("system: Argument 3 must be a number");
-          args.GetIsolate(), "system: Argument 3 must be a number"));
       return false;
     }
   }
   return true;
 }
 
+namespace {
+v8::Local<v8::String> v8_strerror(v8::Isolate* isolate, int err) {
+  return v8::String::NewFromUtf8(isolate, strerror(err)).ToLocalChecked();
+}
+}  // namespace
+
 static const int kReadFD = 0;
 static const int kWriteFD = 1;
 
@@ -267,8 +271,7 @@ static bool ChildLaunchedOK(Isolate* isolate, int* exec_error_fds) {
     bytes_read = read(exec_error_fds[kReadFD], &err, sizeof(err));
   } while (bytes_read == -1 && errno == EINTR);
   if (bytes_read != 0) {
-    isolate->ThrowException(
+    isolate->ThrowError(v8_strerror(isolate, err));
-        String::NewFromUtf8(isolate, strerror(err)).ToLocalChecked());
     return false;
   }
   return true;
@@ -286,8 +289,7 @@ static Local<Value> GetStdout(Isolate* isolate, int child_fd,
   char buffer[kStdoutReadBufferSize];
 
   if (fcntl(child_fd, F_SETFL, O_NONBLOCK) != 0) {
-    return isolate->ThrowException(
+    return isolate->ThrowError(v8_strerror(isolate, errno));
-        String::NewFromUtf8(isolate, strerror(errno)).ToLocalChecked());
   }
 
   int bytes_read;
@@ -298,8 +300,7 @@ static Local<Value> GetStdout(Isolate* isolate, int child_fd,
       if (errno == EAGAIN) {
         if (!WaitOnFD(child_fd, read_timeout, total_timeout, start_time) ||
             (TimeIsOut(start_time, total_timeout))) {
-          return isolate->ThrowException(String::NewFromUtf8Literal(
+          return isolate->ThrowError("Timed out waiting for output");
-              isolate, "Timed out waiting for output"));
         }
         continue;
       } else if (errno == EINTR) {
@@ -357,8 +358,7 @@ static bool WaitForChild(Isolate* isolate, int pid,
     if (useconds < 1000000) useconds <<= 1;
     if ((read_timeout != -1 && useconds / 1000 > read_timeout) ||
         (TimeIsOut(start_time, total_timeout))) {
-      isolate->ThrowException(String::NewFromUtf8Literal(
+      isolate->ThrowError("Timed out waiting for process to terminate");
-          isolate, "Timed out waiting for process to terminate"));
       kill(pid, SIGINT);
       return false;
     }
@@ -367,16 +367,14 @@ static bool WaitForChild(Isolate* isolate, int pid,
     char message[999];
     snprintf(message, sizeof(message), "Child killed by signal %d",
              child_info.si_status);
-    isolate->ThrowException(
+    isolate->ThrowError(message);
-        String::NewFromUtf8(isolate, message).ToLocalChecked());
     return false;
   }
   if (child_info.si_code == CLD_EXITED && child_info.si_status != 0) {
     char message[999];
     snprintf(message, sizeof(message), "Child exited with status %d",
              child_info.si_status);
-    isolate->ThrowException(
+    isolate->ThrowError(message);
-        String::NewFromUtf8(isolate, message).ToLocalChecked());
     return false;
   }
 
@@ -389,8 +387,7 @@ static bool WaitForChild(Isolate* isolate, int pid,
     char message[999];
     snprintf(message, sizeof(message), "Child killed by signal %d",
              WTERMSIG(child_status));
-    isolate->ThrowException(
+    isolate->ThrowError(message);
-        String::NewFromUtf8(isolate, message).ToLocalChecked());
     return false;
   }
   if (WEXITSTATUS(child_status) != 0) {
@@ -398,8 +395,7 @@ static bool WaitForChild(Isolate* isolate, int pid,
     int exit_status = WEXITSTATUS(child_status);
     snprintf(message, sizeof(message), "Child exited with status %d",
              exit_status);
-    isolate->ThrowException(
+    isolate->ThrowError(message);
-        String::NewFromUtf8(isolate, message).ToLocalChecked());
     return false;
   }
 
@@ -419,8 +415,7 @@ void Shell::System(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Local<Array> command_args;
   if (args.Length() > 1) {
     if (!args[1]->IsArray()) {
-      args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+      args.GetIsolate()->ThrowError("system: Argument 2 must be an array");
-          args.GetIsolate(), "system: Argument 2 must be an array"));
       return;
     }
     command_args = args[1].As<Array>();
@@ -428,13 +423,11 @@ void Shell::System(const v8::FunctionCallbackInfo<v8::Value>& args) {
     command_args = Array::New(args.GetIsolate(), 0);
   }
   if (command_args->Length() > ExecArgs::kMaxArgs) {
-    args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError("Too many arguments to system()");
-        args.GetIsolate(), "Too many arguments to system()"));
     return;
   }
   if (args.Length() < 1) {
-    args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError("Too few arguments to system()");
-        args.GetIsolate(), "Too few arguments to system()"));
     return;
   }
 
@@ -449,13 +442,11 @@ void Shell::System(const v8::FunctionCallbackInfo<v8::Value>& args) {
   int stdout_fds[2];
 
   if (pipe(exec_error_fds) != 0) {
-    args.GetIsolate()->ThrowException(
+    args.GetIsolate()->ThrowError("pipe syscall failed.");
-        String::NewFromUtf8Literal(args.GetIsolate(), "pipe syscall failed."));
     return;
   }
   if (pipe(stdout_fds) != 0) {
-    args.GetIsolate()->ThrowException(
+    args.GetIsolate()->ThrowError("pipe syscall failed.");
-        String::NewFromUtf8Literal(args.GetIsolate(), "pipe syscall failed."));
     return;
   }
 
@@ -493,29 +484,24 @@ void Shell::System(const v8::FunctionCallbackInfo<v8::Value>& args) {
 
 void Shell::ChangeDirectory(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() != 1) {
-    args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError("chdir() takes one argument");
-        args.GetIsolate(), "chdir() takes one argument"));
     return;
   }
   String::Utf8Value directory(args.GetIsolate(), args[0]);
   if (*directory == nullptr) {
-    args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError(
-        args.GetIsolate(),
+        "os.chdir(): String conversion of argument failed.");
-        "os.chdir(): String conversion of argument failed."));
     return;
   }
   if (chdir(*directory) != 0) {
-    args.GetIsolate()->ThrowException(
+    args.GetIsolate()->ThrowError(v8_strerror(args.GetIsolate(), errno));
-        String::NewFromUtf8(args.GetIsolate(), strerror(errno))
-            .ToLocalChecked());
     return;
   }
 }
 
 void Shell::SetUMask(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() != 1) {
-    args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError("umask() takes one argument");
-        args.GetIsolate(), "umask() takes one argument"));
     return;
   }
   if (args[0]->IsNumber()) {
@@ -524,8 +510,7 @@ void Shell::SetUMask(const v8::FunctionCallbackInfo<v8::Value>& args) {
     args.GetReturnValue().Set(previous);
     return;
   } else {
-    args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError("umask() argument must be numeric");
-        args.GetIsolate(), "umask() argument must be numeric"));
     return;
   }
 }
@@ -534,13 +519,11 @@ static bool CheckItsADirectory(Isolate* isolate, char* directory) {
   struct stat stat_buf;
   int stat_result = stat(directory, &stat_buf);
   if (stat_result != 0) {
-    isolate->ThrowException(
+    isolate->ThrowError(v8_strerror(isolate, errno));
-        String::NewFromUtf8(isolate, strerror(errno)).ToLocalChecked());
     return false;
   }
   if ((stat_buf.st_mode & S_IFDIR) != 0) return true;
-  isolate->ThrowException(
+  isolate->ThrowError(v8_strerror(isolate, EEXIST));
-      String::NewFromUtf8(isolate, strerror(EEXIST)).ToLocalChecked());
   return false;
 }
 
@@ -554,8 +537,7 @@ static bool mkdirp(Isolate* isolate, char* directory, mode_t mask) {
   } else if (errno == ENOENT) {  // Intermediate path element is missing.
     char* last_slash = strrchr(directory, '/');
     if (last_slash == nullptr) {
-      isolate->ThrowException(
+      isolate->ThrowError(v8_strerror(isolate, errno));
-          String::NewFromUtf8(isolate, strerror(errno)).ToLocalChecked());
       return false;
     }
     *last_slash = 0;
@@ -566,12 +548,10 @@ static bool mkdirp(Isolate* isolate, char* directory, mode_t mask) {
     if (errno == EEXIST) {
       return CheckItsADirectory(isolate, directory);
     }
-    isolate->ThrowException(
+    isolate->ThrowError(v8_strerror(isolate, errno));
-        String::NewFromUtf8(isolate, strerror(errno)).ToLocalChecked());
     return false;
   } else {
-    isolate->ThrowException(
+    isolate->ThrowError(v8_strerror(isolate, errno));
-        String::NewFromUtf8(isolate, strerror(errno)).ToLocalChecked());
     return false;
   }
 }
@@ -584,20 +564,17 @@ void Shell::MakeDirectory(const v8::FunctionCallbackInfo<v8::Value>& args) {
                  ->Int32Value(args.GetIsolate()->GetCurrentContext())
                  .FromJust();
     } else {
-      args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+      args.GetIsolate()->ThrowError("mkdirp() second argument must be numeric");
-          args.GetIsolate(), "mkdirp() second argument must be numeric"));
       return;
     }
   } else if (args.Length() != 1) {
-    args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError("mkdirp() takes one or two arguments");
-        args.GetIsolate(), "mkdirp() takes one or two arguments"));
     return;
   }
   String::Utf8Value directory(args.GetIsolate(), args[0]);
   if (*directory == nullptr) {
-    args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError(
-        args.GetIsolate(),
+        "os.mkdirp(): String conversion of argument failed.");
-        "os.mkdirp(): String conversion of argument failed."));
     return;
   }
   mkdirp(args.GetIsolate(), *directory, mask);
@@ -605,15 +582,13 @@ void Shell::MakeDirectory(const v8::FunctionCallbackInfo<v8::Value>& args) {
 
 void Shell::RemoveDirectory(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() != 1) {
-    args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError("rmdir() takes one or two arguments");
-        args.GetIsolate(), "rmdir() takes one or two arguments"));
     return;
   }
   String::Utf8Value directory(args.GetIsolate(), args[0]);
   if (*directory == nullptr) {
-    args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError(
-        args.GetIsolate(),
+        "os.rmdir(): String conversion of argument failed.");
-        "os.rmdir(): String conversion of argument failed."));
     return;
   }
   rmdir(*directory);
@@ -621,22 +596,19 @@ void Shell::RemoveDirectory(const v8::FunctionCallbackInfo<v8::Value>& args) {
 
 void Shell::SetEnvironment(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() != 2) {
-    args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError("setenv() takes two arguments");
-        args.GetIsolate(), "setenv() takes two arguments"));
     return;
   }
   String::Utf8Value var(args.GetIsolate(), args[0]);
   String::Utf8Value value(args.GetIsolate(), args[1]);
   if (*var == nullptr) {
-    args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError(
-        args.GetIsolate(),
+        "os.setenv(): String conversion of variable name failed.");
-        "os.setenv(): String conversion of variable name failed."));
     return;
   }
   if (*value == nullptr) {
-    args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError(
-        args.GetIsolate(),
+        "os.setenv(): String conversion of variable contents failed.");
-        "os.setenv(): String conversion of variable contents failed."));
     return;
   }
   setenv(*var, *value, 1);
@@ -644,15 +616,13 @@ void Shell::SetEnvironment(const v8::FunctionCallbackInfo<v8::Value>& args) {
 
 void Shell::UnsetEnvironment(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() != 1) {
-    args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError("unsetenv() takes one argument");
-        args.GetIsolate(), "unsetenv() takes one argument"));
     return;
   }
   String::Utf8Value var(args.GetIsolate(), args[0]);
   if (*var == nullptr) {
-    args.GetIsolate()->ThrowException(String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError(
-        args.GetIsolate(),
+        "os.setenv(): String conversion of variable name failed.");
-        "os.setenv(): String conversion of variable name failed."));
     return;
   }
   unsetenv(*var);

src/d8/d8-test.cc

@@ -170,10 +170,8 @@ thread_local FastCApiObject kFastCApiObject;
 // TODO(mslekova): Rename the fast_c_api helper to FastCAPI.
 void CreateObject(const FunctionCallbackInfo<Value>& info) {
   if (!info.IsConstructCall()) {
-    info.GetIsolate()->ThrowException(
+    info.GetIsolate()->ThrowError(
-        v8::Exception::Error(String::NewFromUtf8Literal(
+        "FastCAPI helper must be constructed with new.");
-            info.GetIsolate(),
-            "FastCAPI helper must be constructed with new.")));
     return;
   }
   Local<Object> api_object = info.Holder();

src/d8/d8.cc

@@ -333,11 +333,6 @@ class MultiMappedAllocator : public ArrayBufferAllocatorBase {
 v8::Platform* g_default_platform;
 std::unique_ptr<v8::Platform> g_platform;
 
-static Local<Value> Throw(Isolate* isolate, const char* message) {
-  return isolate->ThrowException(v8::Exception::Error(
-      String::NewFromUtf8(isolate, message).ToLocalChecked()));
-}
-
 static MaybeLocal<Value> TryGetValue(v8::Isolate* isolate,
                                      Local<Context> context,
                                      Local<v8::Object> object,
@@ -355,13 +350,13 @@ static Local<Value> GetValue(v8::Isolate* isolate, Local<Context> context,
 std::shared_ptr<Worker> GetWorkerFromInternalField(Isolate* isolate,
                                                    Local<Object> object) {
   if (object->InternalFieldCount() != 1) {
-    Throw(isolate, "this is not a Worker");
+    isolate->ThrowError("this is not a Worker");
     return nullptr;
   }
 
   i::Handle<i::Object> handle = Utils::OpenHandle(*object->GetInternalField(0));
   if (handle->IsSmi()) {
-    Throw(isolate, "Worker is defunct because main thread is terminating");
+    isolate->ThrowError("Worker is defunct because main thread is terminating");
     return nullptr;
   }
   auto managed = i::Handle<i::Managed<Worker>>::cast(handle);
@@ -728,7 +723,7 @@ bool Shell::ExecuteString(Isolate* isolate, Local<String> source,
     if (options.web_snapshot_config) {
       std::vector<std::string> exports;
       if (!ReadLines(options.web_snapshot_config, exports)) {
-        Throw(isolate, "Web snapshots: unable to read config");
+        isolate->ThrowError("Web snapshots: unable to read config");
         CHECK(try_catch.HasCaught());
         ReportException(isolate, &try_catch);
         return false;
@@ -965,7 +960,8 @@ MaybeLocal<Module> Shell::FetchModuleTree(Local<Module> referrer,
       CHECK(specifier_it != d->module_to_specifier_map.end());
       msg += "\n    imported by " + specifier_it->second;
     }
-    Throw(isolate, msg.c_str());
+    isolate->ThrowError(
+        v8::String::NewFromUtf8(isolate, msg.c_str()).ToLocalChecked());
     return MaybeLocal<Module>();
   }
   ScriptOrigin origin(
@@ -1024,7 +1020,7 @@ MaybeLocal<Module> Shell::FetchModuleTree(Local<Module> referrer,
             context, import_assertions, true);
 
     if (request_module_type == ModuleType::kInvalid) {
-      Throw(isolate, "Invalid module type was asserted");
+      isolate->ThrowError("Invalid module type was asserted");
       return MaybeLocal<Module>();
     }
 
@@ -1211,7 +1207,7 @@ void Shell::DoHostImportModuleDynamically(void* import_data) {
   try_catch.SetVerbose(true);
 
   if (module_type == ModuleType::kInvalid) {
-    Throw(isolate, "Invalid module type was asserted");
+    isolate->ThrowError("Invalid module type was asserted");
     CHECK(try_catch.HasCaught());
     resolver->Reject(realm, try_catch.Exception()).ToChecked();
     return;
@@ -1358,7 +1354,7 @@ bool Shell::ExecuteWebSnapshot(Isolate* isolate, const char* file_name) {
   std::unique_ptr<uint8_t[]> snapshot_data(
       reinterpret_cast<uint8_t*>(ReadChars(absolute_path.c_str(), &length)));
   if (length == 0) {
-    Throw(isolate, "Error reading the web snapshot");
+    isolate->ThrowError("Error reading the web snapshot");
     DCHECK(try_catch.HasCaught());
     ReportException(isolate, &try_catch);
     return false;
@@ -1500,14 +1496,14 @@ int PerIsolateData::RealmFind(Local<Context> context) {
 int PerIsolateData::RealmIndexOrThrow(
     const v8::FunctionCallbackInfo<v8::Value>& args, int arg_offset) {
   if (args.Length() < arg_offset || !args[arg_offset]->IsNumber()) {
-    Throw(args.GetIsolate(), "Invalid argument");
+    args.GetIsolate()->ThrowError("Invalid argument");
     return -1;
   }
   int index = args[arg_offset]
                   ->Int32Value(args.GetIsolate()->GetCurrentContext())
                   .FromMaybe(-1);
   if (index < 0 || index >= realm_count_ || realms_[index].IsEmpty()) {
-    Throw(args.GetIsolate(), "Invalid realm index");
+    args.GetIsolate()->ThrowError("Invalid realm index");
     return -1;
   }
   return index;
@@ -1565,7 +1561,7 @@ void Shell::RealmOwner(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Isolate* isolate = args.GetIsolate();
   PerIsolateData* data = PerIsolateData::Get(isolate);
   if (args.Length() < 1 || !args[0]->IsObject()) {
-    Throw(args.GetIsolate(), "Invalid argument");
+    args.GetIsolate()->ThrowError("Invalid argument");
     return;
   }
   Local<Object> object =
@@ -1577,7 +1573,7 @@ void Shell::RealmOwner(const v8::FunctionCallbackInfo<v8::Value>& args) {
   }
   Local<Context> creation_context;
   if (!object->GetCreationContext().ToLocal(&creation_context)) {
-    Throw(args.GetIsolate(), "object doesn't have creation context");
+    args.GetIsolate()->ThrowError("object doesn't have creation context");
     return;
   }
   int index = data->RealmFind(creation_context);
@@ -1661,7 +1657,7 @@ void Shell::RealmNavigate(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (index == -1) return;
   if (index == 0 || index == data->realm_current_ ||
       index == data->realm_switch_) {
-    Throw(args.GetIsolate(), "Invalid realm index");
+    args.GetIsolate()->ThrowError("Invalid realm index");
     return;
   }
 
@@ -1690,7 +1686,7 @@ void Shell::RealmDetachGlobal(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (index == -1) return;
   if (index == 0 || index == data->realm_current_ ||
       index == data->realm_switch_) {
-    Throw(args.GetIsolate(), "Invalid realm index");
+    args.GetIsolate()->ThrowError("Invalid realm index");
     return;
   }
 
@@ -1707,7 +1703,7 @@ void Shell::RealmDispose(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (index == -1) return;
   if (index == 0 || index == data->realm_current_ ||
       index == data->realm_switch_) {
-    Throw(args.GetIsolate(), "Invalid realm index");
+    args.GetIsolate()->ThrowError("Invalid realm index");
     return;
   }
   DisposeRealm(args, index);
@@ -1729,7 +1725,7 @@ void Shell::RealmEval(const v8::FunctionCallbackInfo<v8::Value>& args) {
   int index = data->RealmIndexOrThrow(args, 0);
   if (index == -1) return;
   if (args.Length() < 2 || !args[1]->IsString()) {
-    Throw(args.GetIsolate(), "Invalid argument");
+    args.GetIsolate()->ThrowError("Invalid argument");
     return;
   }
   ScriptOrigin origin(isolate,
@@ -1780,18 +1776,18 @@ void Shell::LogGetAndStop(const v8::FunctionCallbackInfo<v8::Value>& args) {
 
   std::string file_name = i_isolate->logger()->file_name();
   if (!i::Log::IsLoggingToTemporaryFile(file_name)) {
-    Throw(isolate, "Only capturing from temporary files is supported.");
+    isolate->ThrowError("Only capturing from temporary files is supported.");
     return;
   }
   if (!i_isolate->logger()->is_logging()) {
-    Throw(isolate, "Logging not enabled.");
+    isolate->ThrowError("Logging not enabled.");
     return;
   }
 
   std::string raw_log;
   FILE* log_file = i_isolate->logger()->TearDownAndGetLogFile();
   if (!log_file) {
-    Throw(isolate, "Log file does not exist.");
+    isolate->ThrowError("Log file does not exist.");
     return;
   }
 
@@ -1800,7 +1796,7 @@ void Shell::LogGetAndStop(const v8::FunctionCallbackInfo<v8::Value>& args) {
   base::Fclose(log_file);
 
   if (!exists) {
-    Throw(isolate, "Unable to read log file.");
+    isolate->ThrowError("Unable to read log file.");
     return;
   }
   Local<String> result =
@@ -1816,13 +1812,13 @@ void Shell::TestVerifySourcePositions(
   Isolate* isolate = args.GetIsolate();
   // Check if the argument is a valid function.
   if (args.Length() != 1) {
-    Throw(isolate, "Expected function as single argument.");
+    isolate->ThrowError("Expected function as single argument.");
     return;
   }
   auto arg_handle = Utils::OpenHandle(*args[0]);
   if (!arg_handle->IsHeapObject() || !i::Handle<i::HeapObject>::cast(arg_handle)
                                           ->IsJSFunctionOrBoundFunction()) {
-    Throw(isolate, "Expected function as single argument.");
+    isolate->ThrowError("Expected function as single argument.");
     return;
   }
 
@@ -1839,7 +1835,7 @@ void Shell::TestVerifySourcePositions(
 
   i::Handle<i::JSFunction> function = i::Handle<i::JSFunction>::cast(callable);
   if (!function->shared().HasBytecodeArray()) {
-    Throw(isolate, "Function has no BytecodeArray attached.");
+    isolate->ThrowError("Function has no BytecodeArray attached.");
     return;
   }
   i::Handle<i::BytecodeArray> bytecodes =
@@ -1865,7 +1861,7 @@ void Shell::TestVerifySourcePositions(
     if (has_baseline) {
       if (offset_iterator->current_bytecode_offset() !=
           bytecode_iterator.current_offset()) {
-        Throw(isolate, "Baseline bytecode offset mismatch.");
+        isolate->ThrowError("Baseline bytecode offset mismatch.");
         return;
       }
       // Check that we map every address to this bytecode correctly.
@@ -1877,7 +1873,8 @@ void Shell::TestVerifySourcePositions(
         pc_lookup.AdvanceToPCOffset(pc);
         if (pc_lookup.current_bytecode_offset() !=
             bytecode_iterator.current_offset()) {
-          Throw(isolate, "Baseline bytecode offset mismatch for PC lookup.");
+          isolate->ThrowError(
+              "Baseline bytecode offset mismatch for PC lookup.");
           return;
         }
       }
@@ -1885,14 +1882,14 @@ void Shell::TestVerifySourcePositions(
     bytecode_iterator.Advance();
     if (has_baseline && !bytecode_iterator.done()) {
       if (offset_iterator->done()) {
-        Throw(isolate, "Missing bytecode(s) in baseline offset mapping.");
+        isolate->ThrowError("Missing bytecode(s) in baseline offset mapping.");
         return;
       }
       offset_iterator->Advance();
     }
   }
   if (has_baseline && !offset_iterator->done()) {
-    Throw(isolate, "Excess offsets in baseline offset mapping.");
+    isolate->ThrowError("Excess offsets in baseline offset mapping.");
     return;
   }
 }
@@ -1978,7 +1975,7 @@ void Shell::Write(const v8::FunctionCallbackInfo<v8::Value>& args) {
 void Shell::Read(const v8::FunctionCallbackInfo<v8::Value>& args) {
   String::Utf8Value file(args.GetIsolate(), args[0]);
   if (*file == nullptr) {
-    Throw(args.GetIsolate(), "Error loading file");
+    args.GetIsolate()->ThrowError("Error loading file");
     return;
   }
   if (args.Length() == 2) {
@@ -1990,7 +1987,7 @@ void Shell::Read(const v8::FunctionCallbackInfo<v8::Value>& args) {
   }
   Local<String> source = ReadFile(args.GetIsolate(), *file);
   if (source.IsEmpty()) {
-    Throw(args.GetIsolate(), "Error loading file");
+    args.GetIsolate()->ThrowError("Error loading file");
     return;
   }
   args.GetReturnValue().Set(source);
@@ -2038,12 +2035,12 @@ void Shell::Load(const v8::FunctionCallbackInfo<v8::Value>& args) {
     HandleScope handle_scope(args.GetIsolate());
     String::Utf8Value file(args.GetIsolate(), args[i]);
     if (*file == nullptr) {
-      Throw(args.GetIsolate(), "Error loading file");
+      args.GetIsolate()->ThrowError("Error loading file");
       return;
     }
     Local<String> source = ReadFile(args.GetIsolate(), *file);
     if (source.IsEmpty()) {
-      Throw(args.GetIsolate(), "Error loading file");
+      args.GetIsolate()->ThrowError("Error loading file");
       return;
     }
     if (!ExecuteString(
@@ -2052,7 +2049,7 @@ void Shell::Load(const v8::FunctionCallbackInfo<v8::Value>& args) {
             kNoPrintResult,
             options.quiet_load ? kNoReportExceptions : kReportExceptions,
             kNoProcessMessageQueue)) {
-      Throw(args.GetIsolate(), "Error executing file");
+      args.GetIsolate()->ThrowError("Error executing file");
       return;
     }
   }
@@ -2115,7 +2112,7 @@ bool FunctionAndArgumentsToString(Local<Function> function,
       function->FunctionProtoToString(context);
   Local<String> function_string;
   if (!maybe_function_string.ToLocal(&function_string)) {
-    Throw(isolate, "Failed to convert function to string");
+    isolate->ThrowError("Failed to convert function to string");
     return false;
   }
   *source = String::NewFromUtf8Literal(isolate, "(");
@@ -2124,7 +2121,7 @@ bool FunctionAndArgumentsToString(Local<Function> function,
   *source = String::Concat(isolate, *source, middle);
   if (!arguments.IsEmpty() && !arguments->IsUndefined()) {
     if (!arguments->IsArray()) {
-      Throw(isolate, "'arguments' must be an array");
+      isolate->ThrowError("'arguments' must be an array");
       return false;
     }
     Local<String> comma = String::NewFromUtf8Literal(isolate, ",");
@@ -2136,12 +2133,12 @@ bool FunctionAndArgumentsToString(Local<Function> function,
       MaybeLocal<Value> maybe_argument = array->Get(context, i);
       Local<Value> argument;
       if (!maybe_argument.ToLocal(&argument)) {
-        Throw(isolate, "Failed to get argument");
+        isolate->ThrowError("Failed to get argument");
         return false;
       }
       Local<String> argument_string;
       if (!JSON::Stringify(context, argument).ToLocal(&argument_string)) {
-        Throw(isolate, "Failed to convert argument to string");
+        isolate->ThrowError("Failed to convert argument to string");
         return false;
       }
       *source = String::Concat(isolate, *source, argument_string);
@@ -2156,7 +2153,7 @@ void Shell::WorkerNew(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Isolate* isolate = args.GetIsolate();
   HandleScope handle_scope(isolate);
   if (args.Length() < 1 || (!args[0]->IsString() && !args[0]->IsFunction())) {
-    Throw(isolate, "1st argument must be a string or a function");
+    isolate->ThrowError("1st argument must be a string or a function");
     return;
   }
 
@@ -2170,7 +2167,7 @@ void Shell::WorkerNew(const v8::FunctionCallbackInfo<v8::Value>& args) {
     Local<Value> arguments;
     ReadWorkerTypeAndArguments(args, &worker_type, &arguments);
     if (worker_type != WorkerType::kFunction) {
-      Throw(isolate, "Invalid or missing worker type");
+      isolate->ThrowError("Invalid or missing worker type");
       return;
     }
 
@@ -2189,7 +2186,7 @@ void Shell::WorkerNew(const v8::FunctionCallbackInfo<v8::Value>& args) {
       load_from_file = false;
     } else if (worker_type != WorkerType::kNone &&
                worker_type != WorkerType::kClassic) {
-      Throw(isolate, "Invalid worker type");
+      isolate->ThrowError("Invalid worker type");
       return;
     }
 
@@ -2197,7 +2194,7 @@ void Shell::WorkerNew(const v8::FunctionCallbackInfo<v8::Value>& args) {
       String::Utf8Value filename(isolate, args[0]);
       source = ReadFile(isolate, *filename);
       if (source.IsEmpty()) {
-        Throw(args.GetIsolate(), "Error loading worker script");
+        args.GetIsolate()->ThrowError("Error loading worker script");
         return;
       }
     } else {
@@ -2206,7 +2203,7 @@ void Shell::WorkerNew(const v8::FunctionCallbackInfo<v8::Value>& args) {
   }
 
   if (!args.IsConstructCall()) {
-    Throw(isolate, "Worker must be constructed with new");
+    isolate->ThrowError("Worker must be constructed with new");
     return;
   }
 
@@ -2223,7 +2220,7 @@ void Shell::WorkerNew(const v8::FunctionCallbackInfo<v8::Value>& args) {
 
     String::Utf8Value script(isolate, source);
     if (!*script) {
-      Throw(isolate, "Can't get worker script");
+      isolate->ThrowError("Can't get worker script");
       return;
     }
 
@@ -2237,7 +2234,7 @@ void Shell::WorkerNew(const v8::FunctionCallbackInfo<v8::Value>& args) {
         i_isolate, kWorkerSizeEstimate, worker);
     args.Holder()->SetInternalField(0, Utils::ToLocal(managed));
     if (!Worker::StartWorkerThread(std::move(worker))) {
-      Throw(isolate, "Can't start thread");
+      isolate->ThrowError("Can't start thread");
       return;
     }
   }
@@ -2248,7 +2245,7 @@ void Shell::WorkerPostMessage(const v8::FunctionCallbackInfo<v8::Value>& args) {
   HandleScope handle_scope(isolate);
 
   if (args.Length() < 1) {
-    Throw(isolate, "Invalid argument");
+    isolate->ThrowError("Invalid argument");
     return;
   }
 
@@ -3187,13 +3184,13 @@ void Shell::ReadBuffer(const v8::FunctionCallbackInfo<v8::Value>& args) {
   String::Utf8Value filename(isolate, args[0]);
   int length;
   if (*filename == nullptr) {
-    Throw(isolate, "Error loading file");
+    isolate->ThrowError("Error loading file");
     return;
   }
 
   uint8_t* data = reinterpret_cast<uint8_t*>(ReadChars(*filename, &length));
   if (data == nullptr) {
-    Throw(isolate, "Error reading file");
+    isolate->ThrowError("Error reading file");
     return;
   }
   std::unique_ptr<v8::BackingStore> backing_store =
@@ -3860,7 +3857,7 @@ void Worker::PostMessageOut(const v8::FunctionCallbackInfo<v8::Value>& args) {
   HandleScope handle_scope(isolate);
 
   if (args.Length() < 1) {
-    Throw(isolate, "Invalid argument");
+    isolate->ThrowError("Invalid argument");
     return;
   }
 
@@ -4432,7 +4429,8 @@ class Serializer : public ValueSerializer::Delegate {
         Local<Value> element;
         if (transfer_array->Get(context, i).ToLocal(&element)) {
           if (!element->IsArrayBuffer()) {
-            Throw(isolate_, "Transfer array elements must be an ArrayBuffer");
+            isolate_->ThrowError(
+                "Transfer array elements must be an ArrayBuffer");
             return Nothing<bool>();
           }
 
@@ -4440,8 +4438,8 @@ class Serializer : public ValueSerializer::Delegate {
 
           if (std::find(array_buffers_.begin(), array_buffers_.end(),
                         array_buffer) != array_buffers_.end()) {
-            Throw(isolate_,
+            isolate_->ThrowError(
-                  "ArrayBuffer occurs in the transfer array more than once");
+                "ArrayBuffer occurs in the transfer array more than once");
             return Nothing<bool>();
           }
 
@@ -4456,7 +4454,7 @@ class Serializer : public ValueSerializer::Delegate {
     } else if (transfer->IsUndefined()) {
       return Just(true);
     } else {
-      Throw(isolate_, "Transfer list must be an Array or undefined");
+      isolate_->ThrowError("Transfer list must be an Array or undefined");
       return Nothing<bool>();
     }
   }
@@ -4466,7 +4464,7 @@ class Serializer : public ValueSerializer::Delegate {
       Local<ArrayBuffer> array_buffer =
           Local<ArrayBuffer>::New(isolate_, global_array_buffer);
       if (!array_buffer->IsDetachable()) {
-        Throw(isolate_, "ArrayBuffer could not be transferred");
+        isolate_->ThrowError("ArrayBuffer could not be transferred");
         return Nothing<bool>();
       }
 

src/extensions/cputracemark-extension.cc

@@ -16,9 +16,8 @@ CpuTraceMarkExtension::GetNativeFunctionTemplate(v8::Isolate* isolate,
 void CpuTraceMarkExtension::Mark(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() < 1 || !args[0]->IsUint32()) {
-    args.GetIsolate()->ThrowException(v8::String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError(
-        args.GetIsolate(),
+        "First parameter to cputracemark() must be a unsigned int32.");
-        "First parameter to cputracemark() must be a unsigned int32."));
     return;
   }
 

src/extensions/externalize-string-extension.cc

@@ -59,9 +59,8 @@ ExternalizeStringExtension::GetNativeFunctionTemplate(
 void ExternalizeStringExtension::Externalize(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() < 1 || !args[0]->IsString()) {
-    args.GetIsolate()->ThrowException(v8::String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError(
-        args.GetIsolate(),
+        "First parameter to externalizeString() must be a string.");
-        "First parameter to externalizeString() must be a string."));
     return;
   }
   bool force_two_byte = false;
@@ -69,17 +68,15 @@ void ExternalizeStringExtension::Externalize(
     if (args[1]->IsBoolean()) {
       force_two_byte = args[1]->BooleanValue(args.GetIsolate());
     } else {
-      args.GetIsolate()->ThrowException(v8::String::NewFromUtf8Literal(
+      args.GetIsolate()->ThrowError(
-          args.GetIsolate(),
+          "Second parameter to externalizeString() must be a boolean.");
-          "Second parameter to externalizeString() must be a boolean."));
       return;
     }
   }
   bool result = false;
   Handle<String> string = Utils::OpenHandle(*args[0].As<v8::String>());
   if (!string->SupportsExternalization()) {
-    args.GetIsolate()->ThrowException(v8::String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError("string does not support externalization.");
-        args.GetIsolate(), "string does not support externalization."));
     return;
   }
   if (string->IsOneByteRepresentation() && !force_two_byte) {
@@ -98,8 +95,7 @@ void ExternalizeStringExtension::Externalize(
     if (!result) delete resource;
   }
   if (!result) {
-    args.GetIsolate()->ThrowException(v8::String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError("externalizeString() failed.");
-        args.GetIsolate(), "externalizeString() failed."));
     return;
   }
 }
@@ -108,9 +104,8 @@ void ExternalizeStringExtension::Externalize(
 void ExternalizeStringExtension::IsOneByte(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() != 1 || !args[0]->IsString()) {
-    args.GetIsolate()->ThrowException(v8::String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError(
-        args.GetIsolate(),
+        "isOneByteString() requires a single string argument.");
-        "isOneByteString() requires a single string argument."));
     return;
   }
   bool is_one_byte =

src/extensions/vtunedomain-support-extension.cc

@@ -109,10 +109,9 @@ void VTuneDomainSupportExtension::Mark(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() != 3 || !args[0]->IsString() || !args[1]->IsString() ||
       !args[2]->IsString()) {
-    args.GetIsolate()->ThrowException(v8::String::NewFromUtf8Literal(
+    args.GetIsolate()->ThrowError(
-        args.GetIsolate(),
         "Parameter number should be exactly three, first domain name"
-        "second task name, third start/end"));
+        "second task name, third start/end");
     return;
   }
 
@@ -130,9 +129,7 @@ void VTuneDomainSupportExtension::Mark(
 
   int r = 0;
   if ((r = libvtune::invoke(params.str().c_str())) != 0) {
-    args.GetIsolate()->ThrowException(
+    args.GetIsolate()->ThrowError(std::to_string(r).c_str());
-        v8::String::NewFromUtf8(args.GetIsolate(), std::to_string(r).c_str())
-            .ToLocalChecked());
   }
 }
 

src/inspector/v8-runtime-agent-impl.cc

@@ -743,8 +743,8 @@ void V8RuntimeAgentImpl::bindingCallback(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
   v8::Isolate* isolate = info.GetIsolate();
   if (info.Length() != 1 || !info[0]->IsString()) {
-    info.GetIsolate()->ThrowException(toV8String(
+    info.GetIsolate()->ThrowError(
-        isolate, "Invalid arguments: should be exactly one string."));
+        "Invalid arguments: should be exactly one string.");
     return;
   }
   V8InspectorImpl* inspector =

src/web-snapshot/web-snapshot.cc

@@ -34,8 +34,8 @@ void WebSnapshotSerializerDeserializer::Throw(const char* message) {
   error_message_ = message;
   if (!isolate_->has_pending_exception()) {
     v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate_);
-    v8_isolate->ThrowException(v8::Exception::Error(
+    v8_isolate->ThrowError(
-        v8::String::NewFromUtf8(v8_isolate, message).ToLocalChecked()));
+        v8::String::NewFromUtf8(v8_isolate, message).ToLocalChecked());
   }
 }
 

test/cctest/test-cpu-profiler.cc

@@ -3957,7 +3957,7 @@ struct FastApiReceiver {
   static void SlowCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
     v8::Object* receiver_obj = v8::Object::Cast(*info.Holder());
     if (!IsValidUnwrapObject(receiver_obj)) {
-      info.GetIsolate()->ThrowException(v8_str("Called with a non-object."));
+      info.GetIsolate()->ThrowError("Called with a non-object.");
       return;
     }
     FastApiReceiver* receiver =

test/fuzzer/inspector-fuzzer.cc

@@ -439,14 +439,14 @@ class InspectorExtension : public IsolateData::SetupGlobalTask {
   static void AccessorGetter(v8::Local<v8::String> property,
                              const v8::PropertyCallbackInfo<v8::Value>& info) {
     v8::Isolate* isolate = info.GetIsolate();
-    isolate->ThrowException(ToV8String(isolate, "Getter is called"));
+    isolate->ThrowError("Getter is called");
   }
 
   static void AccessorSetter(v8::Local<v8::String> property,
                              v8::Local<v8::Value> value,
                              const v8::PropertyCallbackInfo<void>& info) {
     v8::Isolate* isolate = info.GetIsolate();
-    isolate->ThrowException(ToV8String(isolate, "Setter is called"));
+    isolate->ThrowError("Setter is called");
   }
 
   static void StoreCurrentStackTrace(

test/inspector/inspector-test.cc

@@ -171,7 +171,7 @@ class UtilsExtension : public IsolateData::SetupGlobalTask {
     std::string filename(*str, str.length());
     *chars = v8::internal::ReadFile(filename.c_str(), &exists);
     if (!exists) {
-      isolate->ThrowException(ToV8String(isolate, "Error reading file"));
+      isolate->ThrowError("Error reading file");
       return false;
     }
     return true;
@@ -632,14 +632,14 @@ class InspectorExtension : public IsolateData::SetupGlobalTask {
   static void AccessorGetter(v8::Local<v8::String> property,
                              const v8::PropertyCallbackInfo<v8::Value>& info) {
     v8::Isolate* isolate = info.GetIsolate();
-    isolate->ThrowException(ToV8String(isolate, "Getter is called"));
+    isolate->ThrowError("Getter is called");
   }
 
   static void AccessorSetter(v8::Local<v8::String> property,
                              v8::Local<v8::Value> value,
                              const v8::PropertyCallbackInfo<void>& info) {
     v8::Isolate* isolate = info.GetIsolate();
-    isolate->ThrowException(ToV8String(isolate, "Setter is called"));
+    isolate->ThrowError("Setter is called");
   }
 
   static void StoreCurrentStackTrace(