[snapshot] encode resource before serializing.

src/snapshot/deserializer.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/snapshot/deserializer.h"
 
 #include "src/api.h"
 #include "src/assembler-inl.h"
 #include "src/bootstrapper.h"
 #include "src/deoptimizer.h"
@@ skipping 338 matching lines @@
     // We flush all code pages after deserializing the startup snapshot. In that
     // case, we only need to remember code objects in the large object space.
     // When deserializing user code, remember each individual code object.
     if (deserializing_user_code() || space == LO_SPACE) {
       new_code_objects_.Add(Code::cast(obj));
     }
   } else if (obj->IsAccessorInfo()) {
     if (isolate_->external_reference_redirector()) {
       accessor_infos_.Add(AccessorInfo::cast(obj));
     }
+  } else if (obj->IsExternalOneByteString()) {
+    DCHECK(obj->map() == isolate_->heap()->native_source_string_map());
+    ExternalOneByteString* string = ExternalOneByteString::cast(obj);
+    DCHECK(string->is_short());
+    string->set_resource(
+        NativesExternalStringResource::DecodeForDeserialization(
+            string->resource()));
+    isolate_->heap()->RegisterExternalString(string);
   }
   // Check alignment.
   DCHECK_EQ(0, Heap::GetFillToAlign(obj->address(), obj->RequiredAlignment()));
   return obj;
 }
 
 void Deserializer::CommitPostProcessedObjects(Isolate* isolate) {
   StringTable::EnsureCapacityForDeserialization(
       isolate, new_internalized_strings_.length());
   for (Handle<String> string : new_internalized_strings_) {
@@ skipping 126 matching lines @@
     // Assert that the current reserved chunk is still big enough.
     const Heap::Reservation& reservation = reservations_[space_index];
     int chunk_index = current_chunk_[space_index];
     CHECK_LE(high_water_[space_index], reservation[chunk_index].end);
 #endif
     if (space_index == CODE_SPACE) SkipList::Update(address, size);
     return address;
   }
 }
 
-Object** Deserializer::CopyInNativesSource(Vector<const char> source_vector,
-                                           Object** current) {
-  DCHECK(!isolate_->heap()->deserialization_complete());
-  NativesExternalStringResource* resource = new NativesExternalStringResource(
-      source_vector.start(), source_vector.length());
-  Object* resource_obj = reinterpret_cast<Object*>(resource);
-  UnalignedCopy(current++, &resource_obj);
-  return current;
-}
-
 bool Deserializer::ReadData(Object** current, Object** limit, int source_space,
                             Address current_object_address) {
   Isolate* const isolate = isolate_;
   // Write barrier support costs around 1% in startup time.  In fact there
   // are no new space objects in current boot snapshots, so it's not needed,
   // but that may change.
   bool write_barrier_needed =
       (current_object_address != NULL && source_space != NEW_SPACE &&
        source_space != CODE_SPACE);
   while (current < limit) {
@@ skipping 282 matching lines @@
         current = limit;
         return false;
       }
 
       case kSynchronize:
         // If we get here then that indicates that you have a mismatch between
         // the number of GC roots when serializing and deserializing.
         CHECK(false);
         break;
 
-      case kNativesStringResource:
-        current = CopyInNativesSource(Natives::GetScriptSource(source_.Get()),
-                                      current);
-        break;
-
-      case kExtraNativesStringResource:
-        current = CopyInNativesSource(
-            ExtraNatives::GetScriptSource(source_.Get()), current);
-        break;
-
       // Deserialize raw data of variable length.
       case kVariableRawData: {
         int size_in_bytes = source_.GetInt();
         byte* raw_data_out = reinterpret_cast<byte*>(current);
         source_.CopyRaw(raw_data_out, size_in_bytes);
         break;
       }
 
       case kVariableRepeat: {
         int repeats = source_.GetInt();
@@ skipping 81 matching lines @@
 
       default:
         CHECK(false);
     }
   }
   CHECK_EQ(limit, current);
   return true;
 }
 }  // namespace internal
 }  // namespace v8