add isolate parameter to ThrowException

src/extensions/externalize-string-extension.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 57 matching lines @@
   } else {
     ASSERT(strcmp(*v8::String::Utf8Value(str), "isAsciiString") == 0);
     return v8::FunctionTemplate::New(ExternalizeStringExtension::IsAscii);
   }
 }
 
 
 void ExternalizeStringExtension::Externalize(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() < 1 || !args[0]->IsString()) {
-    v8::ThrowException(v8::String::New(
-        "First parameter to externalizeString() must be a string."));
+    v8::ThrowException(
+        args.GetIsolate(),
+        v8::String::New(
+            "First parameter to externalizeString() must be a string."));
     return;
   }
   bool force_two_byte = false;
   if (args.Length() >= 2) {
     if (args[1]->IsBoolean()) {
       force_two_byte = args[1]->BooleanValue();
     } else {
-      v8::ThrowException(v8::String::New(
-        "Second parameter to externalizeString() must be a boolean."));
+      v8::ThrowException(
+          args.GetIsolate(),
+          v8::String::New(
+              "Second parameter to externalizeString() must be a boolean."));
       return;
     }
   }
   bool result = false;
   Handle<String> string = Utils::OpenHandle(*args[0].As<v8::String>());
   if (string->IsExternalString()) {
-    v8::ThrowException(v8::String::New(
-        "externalizeString() can't externalize twice."));
+    v8::ThrowException(
+        args.GetIsolate(),
+        v8::String::New(
+            "externalizeString() can't externalize twice."));
     return;
   }
   if (string->IsOneByteRepresentation() && !force_two_byte) {
     uint8_t* data = new uint8_t[string->length()];
     String::WriteToFlat(*string, data, 0, string->length());
     SimpleAsciiStringResource* resource = new SimpleAsciiStringResource(
         reinterpret_cast<char*>(data), string->length());
     result = string->MakeExternal(resource);
     if (result && !string->IsInternalizedString()) {
       i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
@@ skipping 15 matching lines @@
   if (!result) {
     v8::ThrowException(v8::String::New("externalizeString() failed."));
     return;
   }
 }
 
 
 void ExternalizeStringExtension::IsAscii(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() != 1 || !args[0]->IsString()) {
-    v8::ThrowException(v8::String::New(
-        "isAsciiString() requires a single string argument."));
+    v8::ThrowException(
+        args.GetIsolate(),
+        v8::String::New(
+            "isAsciiString() requires a single string argument."));
     return;
   }
   bool is_one_byte =
       Utils::OpenHandle(*args[0].As<v8::String>())->IsOneByteRepresentation();
   args.GetReturnValue().Set(is_one_byte);
 }
 
 
 void ExternalizeStringExtension::Register() {
   static ExternalizeStringExtension externalize_extension;
   static v8::DeclareExtension declaration(&externalize_extension);
 }
 
 } }  // namespace v8::internal