Revert of Internalize strings in-place

src/factory.cc

Index: src/factory.cc
diff --git a/src/factory.cc b/src/factory.cc
index 877b3f7c685750688f890c2c16b0e11a44193bc1..9245e4156fbadc47c7b2b2654110069316df4e54 100644
--- a/src/factory.cc
+++ b/src/factory.cc
@@ -278,7 +278,6 @@ Handle<String> Factory::InternalizeStringWithKey(StringTableKey* key) {
 MaybeHandle<String> Factory::NewStringFromOneByte(Vector<const uint8_t> string,
                                                   PretenureFlag pretenure) {
   int length = string.length();
-  if (length == 0) return empty_string();
   if (length == 1) return LookupSingleCharacterStringFromCode(string[0]);
   Handle<SeqOneByteString> result;
   ASSIGN_RETURN_ON_EXCEPTION(
@@ -372,7 +371,6 @@ MaybeHandle<String> Factory::NewStringFromUtf8SubString(
 MaybeHandle<String> Factory::NewStringFromTwoByte(const uc16* string,
                                                   int length,
                                                   PretenureFlag pretenure) {
-  if (length == 0) return empty_string();
   if (String::IsOneByte(string, length)) {
     if (length == 1) return LookupSingleCharacterStringFromCode(string[0]);
     Handle<SeqOneByteString> result;
@@ -457,63 +455,39 @@ Handle<String> Factory::NewInternalizedStringImpl(
       String);
 }
 
-namespace {
+MaybeHandle<Map> Factory::InternalizedStringMapForString(
+    Handle<String> string) {
+  // If the string is in new space it cannot be used as internalized.
+  if (isolate()->heap()->InNewSpace(*string)) return MaybeHandle<Map>();
 
-MaybeHandle<Map> GetInternalizedStringMap(Factory* f, Handle<String> string) {
+  // Find the corresponding internalized string map for strings.
   switch (string->map()->instance_type()) {
     case STRING_TYPE:
-      return f->internalized_string_map();
+      return internalized_string_map();
     case ONE_BYTE_STRING_TYPE:
-      return f->one_byte_internalized_string_map();
+      return one_byte_internalized_string_map();
     case EXTERNAL_STRING_TYPE:
-      return f->external_internalized_string_map();
+      return external_internalized_string_map();
     case EXTERNAL_ONE_BYTE_STRING_TYPE:
-      return f->external_one_byte_internalized_string_map();
+      return external_one_byte_internalized_string_map();
     case EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE:
-      return f->external_internalized_string_with_one_byte_data_map();
+      return external_internalized_string_with_one_byte_data_map();
     case SHORT_EXTERNAL_STRING_TYPE:
-      return f->short_external_internalized_string_map();
+      return short_external_internalized_string_map();
     case SHORT_EXTERNAL_ONE_BYTE_STRING_TYPE:
-      return f->short_external_one_byte_internalized_string_map();
+      return short_external_one_byte_internalized_string_map();
     case SHORT_EXTERNAL_STRING_WITH_ONE_BYTE_DATA_TYPE:
-      return f->short_external_internalized_string_with_one_byte_data_map();
+      return short_external_internalized_string_with_one_byte_data_map();
     default: return MaybeHandle<Map>();  // No match found.
   }
 }
 
-}  // namespace
-
-MaybeHandle<Map> Factory::InternalizedStringMapForString(
-    Handle<String> string) {
-  // If the string is in new space it cannot be used as internalized.
-  if (isolate()->heap()->InNewSpace(*string)) return MaybeHandle<Map>();
-
-  return GetInternalizedStringMap(this, string);
-}
-
-template <class StringClass>
-Handle<StringClass> Factory::InternalizeExternalString(Handle<String> string) {
-  Handle<StringClass> cast_string = Handle<StringClass>::cast(string);
-  Handle<Map> map = GetInternalizedStringMap(this, string).ToHandleChecked();
-  Handle<StringClass> external_string = New<StringClass>(map, OLD_SPACE);
-  external_string->set_length(cast_string->length());
-  external_string->set_hash_field(cast_string->hash_field());
-  external_string->set_resource(nullptr);
-  isolate()->heap()->RegisterExternalString(*external_string);
-  return external_string;
-}
-
-template Handle<ExternalOneByteString>
-    Factory::InternalizeExternalString<ExternalOneByteString>(Handle<String>);
-template Handle<ExternalTwoByteString>
-    Factory::InternalizeExternalString<ExternalTwoByteString>(Handle<String>);
 
 MaybeHandle<SeqOneByteString> Factory::NewRawOneByteString(
     int length, PretenureFlag pretenure) {
   if (length > String::kMaxLength || length < 0) {
     THROW_NEW_ERROR(isolate(), NewInvalidStringLengthError(), SeqOneByteString);
   }
-  DCHECK(length > 0);  // Use Factory::empty_string() instead.
   CALL_HEAP_FUNCTION(
       isolate(),
       isolate()->heap()->AllocateRawOneByteString(length, pretenure),
@@ -526,7 +500,6 @@ MaybeHandle<SeqTwoByteString> Factory::NewRawTwoByteString(
   if (length > String::kMaxLength || length < 0) {
     THROW_NEW_ERROR(isolate(), NewInvalidStringLengthError(), SeqTwoByteString);
   }
-  DCHECK(length > 0);  // Use Factory::empty_string() instead.
   CALL_HEAP_FUNCTION(
       isolate(),
       isolate()->heap()->AllocateRawTwoByteString(length, pretenure),
@@ -615,12 +588,6 @@ Handle<String> ConcatStringContent(Handle<StringType> result,
 
 MaybeHandle<String> Factory::NewConsString(Handle<String> left,
                                            Handle<String> right) {
-  if (left->IsThinString()) {
-    left = handle(Handle<ThinString>::cast(left)->actual(), isolate());
-  }
-  if (right->IsThinString()) {
-    right = handle(Handle<ThinString>::cast(right)->actual(), isolate());
-  }
   int left_length = left->length();
   if (left_length == 0) return right;
   int right_length = right->length();