[cleanup] Replace deprecated v8 Write/Length methods

since they infer the Isolate from the address of the String they're
called on. This will cease to work reliably in future V8 releases, so
this change replaces all uses in chromium with ones that pass in the
Isolate explicitly.

v8: :Write, v8::WriteUtf8 and v8::Utf8Length are marked V8_DEPRECATE_SOON
Change-Id: I13780586c91de98375adec0ad414d65476ed5170
Reviewed-on: https://chromium-review.googlesource.com/1149879Reviewed-by: Peter Beverloo <peter@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Matt Menke <mmenke@chromium.org>
Reviewed-by: Rachel Blum <groby@chromium.org>
Commit-Queue: Dan Elphick <delphick@chromium.org>
Cr-Commit-Position: refs/heads/master@{#578579}

components/translate/content/renderer/translate_helper.cc

@@ -222,7 +222,8 @@ std::string TranslateHelper::ExecuteScriptAndGetStringResult(
   if (!main_frame)
     return std::string();
 
-  v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::HandleScope handle_scope(isolate);
   WebScriptSource source = WebScriptSource(WebString::FromASCII(script));
   v8::Local<v8::Value> result =
       main_frame->ExecuteScriptInIsolatedWorldAndReturnValue(world_id_, source);
@@ -232,9 +233,9 @@ std::string TranslateHelper::ExecuteScriptAndGetStringResult(
   }
 
   v8::Local<v8::String> v8_str = result.As<v8::String>();
-  int length = v8_str->Utf8Length() + 1;
+  int length = v8_str->Utf8Length(isolate) + 1;
   std::unique_ptr<char[]> str(new char[length]);
-  v8_str->WriteUtf8(str.get(), length);
+  v8_str->WriteUtf8(isolate, str.get(), length);
   return std::string(str.get());
 }
 

content/shell/test_runner/test_common.cc

@@ -78,10 +78,11 @@ const char* WebNavigationPolicyToString(
   }
 }
 
-blink::WebString V8StringToWebString(v8::Local<v8::String> v8_str) {
-  int length = v8_str->Utf8Length() + 1;
+blink::WebString V8StringToWebString(v8::Isolate* isolate,
+                                     v8::Local<v8::String> v8_str) {
+  int length = v8_str->Utf8Length(isolate) + 1;
   std::unique_ptr<char[]> chars(new char[length]);
-  v8_str->WriteUtf8(chars.get(), length);
+  v8_str->WriteUtf8(isolate, chars.get(), length);
   return blink::WebString::FromUTF8(chars.get());
 }
 

content/shell/test_runner/test_common.h

@@ -31,7 +31,8 @@ std::string URLDescription(const GURL& url);
 const char* WebNavigationPolicyToString(
     const blink::WebNavigationPolicy& policy);
 
-blink::WebString V8StringToWebString(v8::Local<v8::String> v8_str);
+blink::WebString V8StringToWebString(v8::Isolate* isolate,
+                                     v8::Local<v8::String> v8_str);
 
 }  // namespace test_runner
 

content/shell/test_runner/test_runner.cc

@@ -2171,7 +2171,7 @@ void TestRunner::OverridePreference(const std::string& key,
   } else if (key == "WebKitDefaultTextEncodingName") {
     v8::Isolate* isolate = blink::MainThreadIsolate();
     prefs->default_text_encoding_name =
-        V8StringToWebString(value->ToString(isolate));
+        V8StringToWebString(isolate, value->ToString(isolate));
   } else if (key == "WebKitJavaScriptEnabled") {
     prefs->java_script_enabled = value->BooleanValue();
   } else if (key == "WebKitSupportsMultipleWindows") {

content/shell/test_runner/test_runner_for_specific_view.cc

@@ -592,8 +592,8 @@ void TestRunnerForSpecificView::SetIsolatedWorldSecurityOrigin(
 
   WebSecurityOrigin web_origin;
   if (origin->IsString()) {
-    web_origin = WebSecurityOrigin::CreateFromString(
-        V8StringToWebString(origin.As<v8::String>()));
+    web_origin = WebSecurityOrigin::CreateFromString(V8StringToWebString(
+        blink::MainThreadIsolate(), origin.As<v8::String>()));
   }
   web_view()->FocusedFrame()->SetIsolatedWorldSecurityOrigin(world_id,
                                                              web_origin);

net/proxy_resolution/proxy_resolver_v8.cc

@@ -137,22 +137,23 @@ class V8ExternalASCIILiteral
 const size_t kMaxStringBytesForCopy = 256;
 
 // Converts a V8 String to a UTF8 std::string.
-std::string V8StringToUTF8(v8::Local<v8::String> s) {
+std::string V8StringToUTF8(v8::Isolate* isolate, v8::Local<v8::String> s) {
   int len = s->Length();
   std::string result;
   if (len > 0)
-    s->WriteUtf8(base::WriteInto(&result, len + 1));
+    s->WriteUtf8(isolate, base::WriteInto(&result, len + 1));
   return result;
 }
 
 // Converts a V8 String to a UTF16 base::string16.
-base::string16 V8StringToUTF16(v8::Local<v8::String> s) {
+base::string16 V8StringToUTF16(v8::Isolate* isolate, v8::Local<v8::String> s) {
   int len = s->Length();
   base::string16 result;
   // Note that the reinterpret cast is because on Windows string16 is an alias
   // to wstring, and hence has character type wchar_t not uint16_t.
   if (len > 0) {
-    s->Write(reinterpret_cast<uint16_t*>(base::WriteInto(&result, len + 1)), 0,
+    s->Write(isolate,
+             reinterpret_cast<uint16_t*>(base::WriteInto(&result, len + 1)), 0,
              len);
   }
   return result;
@@ -205,7 +206,7 @@ bool V8ObjectToUTF16String(v8::Local<v8::Value> object,
   v8::Local<v8::String> str_object;
   if (!object->ToString(isolate->GetCurrentContext()).ToLocal(&str_object))
     return false;
-  *utf16_result = V8StringToUTF16(str_object);
+  *utf16_result = V8StringToUTF16(isolate, str_object);
   return true;
 }
 
@@ -218,7 +219,7 @@ bool GetHostnameArgument(const v8::FunctionCallbackInfo<v8::Value>& args,
     return false;
 
   const base::string16 hostname_utf16 =
-      V8StringToUTF16(v8::Local<v8::String>::Cast(args[0]));
+      V8StringToUTF16(args.GetIsolate(), v8::Local<v8::String>::Cast(args[0]));
 
   // If the hostname is already in ASCII, simply return it as is.
   if (base::IsStringASCII(hostname_utf16)) {
@@ -476,7 +477,8 @@ class ProxyResolverV8::Context {
       return ERR_PAC_SCRIPT_FAILED;
     }
 
-    base::string16 ret_str = V8StringToUTF16(v8::Local<v8::String>::Cast(ret));
+    base::string16 ret_str =
+        V8StringToUTF16(isolate_, v8::Local<v8::String>::Cast(ret));
 
     if (!base::IsStringASCII(ret_str)) {
       // TODO(eroman): Rather than failing when a wide string is returned, we
@@ -783,7 +785,7 @@ class ProxyResolverV8::Context {
     }
 
     std::string ip_address_list =
-        V8StringToUTF8(v8::Local<v8::String>::Cast(args[0]));
+        V8StringToUTF8(args.GetIsolate(), v8::Local<v8::String>::Cast(args[0]));
     if (!base::IsStringASCII(ip_address_list)) {
       args.GetReturnValue().SetNull();
       return;
@@ -809,13 +811,13 @@ class ProxyResolverV8::Context {
     }
 
     std::string ip_address =
-        V8StringToUTF8(v8::Local<v8::String>::Cast(args[0]));
+        V8StringToUTF8(args.GetIsolate(), v8::Local<v8::String>::Cast(args[0]));
     if (!base::IsStringASCII(ip_address)) {
       args.GetReturnValue().Set(false);
       return;
     }
     std::string ip_prefix =
-        V8StringToUTF8(v8::Local<v8::String>::Cast(args[1]));
+        V8StringToUTF8(args.GetIsolate(), v8::Local<v8::String>::Cast(args[1]));
     if (!base::IsStringASCII(ip_prefix)) {
       args.GetReturnValue().Set(false);
       return;
@@ -835,7 +837,7 @@ class ProxyResolverV8::Context {
     }
 
     std::string hostname_utf8 =
-        V8StringToUTF8(v8::Local<v8::String>::Cast(args[0]));
+        V8StringToUTF8(args.GetIsolate(), v8::Local<v8::String>::Cast(args[0]));
     args.GetReturnValue().Set(IsPlainHostName(hostname_utf8));
   }
 

third_party/blink/common/message_port/string_message_codec_unittest.cc

@@ -36,7 +36,8 @@ base::string16 DecodeWithV8(const std::vector<uint8_t>& encoded) {
     v8::Local<v8::String> str = value->ToString(context).ToLocalChecked();
 
     result.resize(str->Length());
-    str->Write(reinterpret_cast<uint16_t*>(&result[0]), 0, result.size());
+    str->Write(isolate, reinterpret_cast<uint16_t*>(&result[0]), 0,
+               result.size());
   }
   isolate->Dispose();
   delete params.array_buffer_allocator;

third_party/blink/renderer/platform/bindings/string_resource.cc

@@ -12,7 +12,7 @@ template <class StringClass>
 struct StringTraits {
   static const StringClass& FromStringResource(StringResourceBase*);
   template <typename V8StringTrait>
-  static StringClass FromV8String(v8::Local<v8::String>, int);
+  static StringClass FromV8String(v8::Isolate*, v8::Local<v8::String>, int);
 };
 
 template <>
@@ -21,7 +21,7 @@ struct StringTraits<String> {
     return resource->GetWTFString();
   }
   template <typename V8StringTrait>
-  static String FromV8String(v8::Local<v8::String>, int);
+  static String FromV8String(v8::Isolate*, v8::Local<v8::String>, int);
 };
 
 template <>
@@ -30,39 +30,43 @@ struct StringTraits<AtomicString> {
     return resource->GetAtomicString();
   }
   template <typename V8StringTrait>
-  static AtomicString FromV8String(v8::Local<v8::String>, int);
+  static AtomicString FromV8String(v8::Isolate*, v8::Local<v8::String>, int);
 };
 
 struct V8StringTwoBytesTrait {
   typedef UChar CharType;
-  ALWAYS_INLINE static void Write(v8::Local<v8::String> v8_string,
+  ALWAYS_INLINE static void Write(v8::Isolate* isolate,
+                                  v8::Local<v8::String> v8_string,
                                   CharType* buffer,
                                   int length) {
-    v8_string->Write(reinterpret_cast<uint16_t*>(buffer), 0, length);
+    v8_string->Write(isolate, reinterpret_cast<uint16_t*>(buffer), 0, length);
   }
 };
 
 struct V8StringOneByteTrait {
   typedef LChar CharType;
-  ALWAYS_INLINE static void Write(v8::Local<v8::String> v8_string,
+  ALWAYS_INLINE static void Write(v8::Isolate* isolate,
+                                  v8::Local<v8::String> v8_string,
                                   CharType* buffer,
                                   int length) {
-    v8_string->WriteOneByte(buffer, 0, length);
+    v8_string->WriteOneByte(isolate, buffer, 0, length);
   }
 };
 
 template <typename V8StringTrait>
-String StringTraits<String>::FromV8String(v8::Local<v8::String> v8_string,
+String StringTraits<String>::FromV8String(v8::Isolate* isolate,
+                                          v8::Local<v8::String> v8_string,
                                           int length) {
   DCHECK(v8_string->Length() == length);
   typename V8StringTrait::CharType* buffer;
   String result = String::CreateUninitialized(length, buffer);
-  V8StringTrait::Write(v8_string, buffer, length);
+  V8StringTrait::Write(isolate, v8_string, buffer, length);
   return result;
 }
 
 template <typename V8StringTrait>
 AtomicString StringTraits<AtomicString>::FromV8String(
+    v8::Isolate* isolate,
     v8::Local<v8::String> v8_string,
     int length) {
   DCHECK(v8_string->Length() == length);
@@ -70,12 +74,12 @@ AtomicString StringTraits<AtomicString>::FromV8String(
       32 / sizeof(typename V8StringTrait::CharType);
   if (length <= kInlineBufferSize) {
     typename V8StringTrait::CharType inline_buffer[kInlineBufferSize];
-    V8StringTrait::Write(v8_string, inline_buffer, length);
+    V8StringTrait::Write(isolate, v8_string, inline_buffer, length);
     return AtomicString(inline_buffer, static_cast<unsigned>(length));
   }
   typename V8StringTrait::CharType* buffer;
   String string = String::CreateUninitialized(length, buffer);
-  V8StringTrait::Write(v8_string, buffer, length);
+  V8StringTrait::Write(isolate, v8_string, buffer, length);
   return AtomicString(string);
 }
 
@@ -101,11 +105,13 @@ StringType ToBlinkString(v8::Local<v8::String> v8_string,
   if (UNLIKELY(!length))
     return StringType("");
 
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
   bool one_byte = v8_string->ContainsOnlyOneByte();
-  StringType result(one_byte ? StringTraits<StringType>::template FromV8String<
-                                   V8StringOneByteTrait>(v8_string, length)
-                             : StringTraits<StringType>::template FromV8String<
-                                   V8StringTwoBytesTrait>(v8_string, length));
+  StringType result(
+      one_byte ? StringTraits<StringType>::template FromV8String<
+                     V8StringOneByteTrait>(isolate, v8_string, length)
+               : StringTraits<StringType>::template FromV8String<
+                     V8StringTwoBytesTrait>(isolate, v8_string, length));
 
   if (external != kExternalize || !v8_string->CanMakeExternal())
     return result;