Verify a bit more about external strings

src/api.cc

Index: src/api.cc
diff --git a/src/api.cc b/src/api.cc
index 343457670ea38b88c4424838fad393e49abda823..f5831de637e5be51b3bf2f709a07c62692558f77 100644
--- a/src/api.cc
+++ b/src/api.cc
@@ -5299,55 +5299,57 @@ bool v8::String::IsExternalOneByte() const {
   return i::StringShape(*str).IsExternalOneByte();
 }
 
-
-void v8::String::VerifyExternalStringResource(
-    v8::String::ExternalStringResource* value) const {
-  i::Handle<i::String> str = Utils::OpenHandle(this);
-  const v8::String::ExternalStringResource* expected;
-  if (i::StringShape(*str).IsExternalTwoByte()) {
-    const void* resource =
-        i::Handle<i::ExternalTwoByteString>::cast(str)->resource();
-    expected = reinterpret_cast<const ExternalStringResource*>(resource);
-  } else {
-    expected = NULL;
-  }
-  CHECK_EQ(expected, value);
-}
-
 void v8::String::VerifyExternalStringResourceBase(
-    v8::String::ExternalStringResourceBase* value, Encoding encoding) const {
+    const v8::String::ExternalStringResourceBase* value,
+    Encoding encoding) const {
   i::Handle<i::String> str = Utils::OpenHandle(this);
-  const v8::String::ExternalStringResourceBase* expected;
-  Encoding expectedEncoding;
+  const v8::String::ExternalStringResourceBase* expected = nullptr;
+  Encoding expected_encoding;
+  const void* actual_data_ptr = nullptr;
+  size_t actual_length = 0;
   if (i::StringShape(*str).IsExternalOneByte()) {
-    const void* resource =
-        i::Handle<i::ExternalOneByteString>::cast(str)->resource();
-    expected = reinterpret_cast<const ExternalStringResourceBase*>(resource);
-    expectedEncoding = ONE_BYTE_ENCODING;
+    const ExternalOneByteStringResource* resource =
+        reinterpret_cast<const ExternalOneByteStringResource*>(
+            i::Handle<i::ExternalOneByteString>::cast(str)->resource());
+    expected = static_cast<const ExternalStringResourceBase*>(resource);
+    expected_encoding = ONE_BYTE_ENCODING;
+    actual_data_ptr = reinterpret_cast<const void*>(resource->data());
+    actual_length = resource->length();
   } else if (i::StringShape(*str).IsExternalTwoByte()) {
-    const void* resource =
-        i::Handle<i::ExternalTwoByteString>::cast(str)->resource();
-    expected = reinterpret_cast<const ExternalStringResourceBase*>(resource);
-    expectedEncoding = TWO_BYTE_ENCODING;
+    const ExternalStringResource* resource =
+        reinterpret_cast<const ExternalStringResource*>(
+            i::Handle<i::ExternalTwoByteString>::cast(str)->resource());
+    expected = static_cast<const ExternalStringResourceBase*>(resource);
+    expected_encoding = TWO_BYTE_ENCODING;
+    actual_data_ptr = reinterpret_cast<const void*>(resource->data());
+    actual_length = resource->length();
   } else {
-    expected = NULL;
-    expectedEncoding =
+    expected_encoding =
         str->IsOneByteRepresentation() ? ONE_BYTE_ENCODING : TWO_BYTE_ENCODING;
   }
   CHECK_EQ(expected, value);
-  CHECK_EQ(expectedEncoding, encoding);
+  CHECK_EQ(expected_encoding, encoding);
+  CHECK_EQ(i::Handle<i::ExternalString>::cast(str)->resource_data(),
+           actual_data_ptr);
+  CHECK_EQ(str->length(), static_cast<int>(actual_length));
 }
 
+
 const v8::String::ExternalOneByteStringResource*
 v8::String::GetExternalOneByteStringResource() const {
   i::Handle<i::String> str = Utils::OpenHandle(this);
+  const ExternalOneByteStringResource* result;
   if (i::StringShape(*str).IsExternalOneByte()) {
     const void* resource =
         i::Handle<i::ExternalOneByteString>::cast(str)->resource();
-    return reinterpret_cast<const ExternalOneByteStringResource*>(resource);
+    result = reinterpret_cast<const ExternalOneByteStringResource*>(resource);
   } else {
-    return NULL;
+    result = nullptr;
   }
+#ifdef V8_ENABLE_CHECKS
+  VerifyExternalStringResourceBase(result, ONE_BYTE_ENCODING);
+#endif
+  return result;
 }
 
 
@@ -5924,6 +5926,10 @@ MaybeLocal<String> v8::String::NewExternalTwoByte(
   i::Handle<i::String> string = i_isolate->factory()
                                     ->NewExternalStringFromTwoByte(resource)
                                     .ToHandleChecked();
+#ifdef V8_ENABLE_CHECKS
+  Utils::ToLocal(string)
+      ->VerifyExternalStringResourceBase(resource, TWO_BYTE_ENCODING);
+#endif
   i_isolate->heap()->external_string_table()->AddString(*string);
   return Utils::ToLocal(string);
 }
@@ -5949,6 +5955,10 @@ MaybeLocal<String> v8::String::NewExternalOneByte(
                                     ->NewExternalStringFromOneByte(resource)
                                     .ToHandleChecked();
   i_isolate->heap()->external_string_table()->AddString(*string);
+#ifdef V8_ENABLE_CHECKS
+  Utils::ToLocal(string)
+      ->VerifyExternalStringResourceBase(resource, ONE_BYTE_ENCODING);
+#endif
   return Utils::ToLocal(string);
 }
 
@@ -5979,6 +5989,9 @@ bool v8::String::MakeExternal(v8::String::ExternalStringResource* resource) {
   DCHECK(!CanMakeExternal() || result);
   if (result) {
     DCHECK(obj->IsExternalString());
+#ifdef V8_ENABLE_CHECKS
+    VerifyExternalStringResourceBase(resource, TWO_BYTE_ENCODING);
+#endif
     isolate->heap()->external_string_table()->AddString(*obj);
   }
   return result;
@@ -6006,6 +6019,9 @@ bool v8::String::MakeExternal(
   DCHECK(!CanMakeExternal() || result);
   if (result) {
     DCHECK(obj->IsExternalString());
+#ifdef V8_ENABLE_CHECKS
+    VerifyExternalStringResourceBase(resource, ONE_BYTE_ENCODING);
+#endif
     isolate->heap()->external_string_table()->AddString(*obj);
   }
   return result;