[snapshot] encode resource before serializing.

src/bootstrapper.cc

 // Copyright 2014 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/bootstrapper.h"
 
 #include "src/accessors.h"
 #include "src/api-natives.h"
 #include "src/base/ieee754.h"
 #include "src/code-stubs.h"
@@ skipping 17 matching lines @@
 #endif  // V8_I18N_SUPPORT
 
 namespace v8 {
 namespace internal {
 
 Bootstrapper::Bootstrapper(Isolate* isolate)
     : isolate_(isolate),
       nesting_(0),
       extensions_cache_(Script::TYPE_EXTENSION) {}
 
-template <class Source>
-Handle<String> Bootstrapper::SourceLookup(int index) {
-  DCHECK(0 <= index && index < Source::GetBuiltinsCount());
-  Heap* heap = isolate_->heap();
-  if (Source::GetSourceCache(heap)->get(index)->IsUndefined(isolate_)) {
-    // We can use external strings for the natives.
-    Vector<const char> source = Source::GetScriptSource(index);
-    NativesExternalStringResource* resource =
-        new NativesExternalStringResource(source.start(), source.length());
-    Handle<ExternalOneByteString> source_code =
-        isolate_->factory()->NewNativeSourceString(resource);
-    // Mark this external string with a special map.
-    DCHECK(source_code->is_short());
-    Source::GetSourceCache(heap)->set(index, *source_code);
-  }
-  Handle<Object> cached_source(Source::GetSourceCache(heap)->get(index),
-                               isolate_);
-  return Handle<String>::cast(cached_source);
+Handle<String> Bootstrapper::GetNativeSource(NativeType type, int index) {
+  NativesExternalStringResource* resource =
+      new NativesExternalStringResource(type, index);
+  Handle<ExternalOneByteString> source_code =
+      isolate_->factory()->NewNativeSourceString(resource);
+  isolate_->heap()->RegisterExternalString(*source_code);
+  DCHECK(source_code->is_short());
+  return source_code;
 }
 
-
-template Handle<String> Bootstrapper::SourceLookup<Natives>(int index);
-template Handle<String> Bootstrapper::SourceLookup<ExperimentalExtraNatives>(
-    int index);
-template Handle<String> Bootstrapper::SourceLookup<ExtraNatives>(int index);
-
-
 void Bootstrapper::Initialize(bool create_heap_objects) {
   extensions_cache_.Initialize(isolate_, create_heap_objects);
 }
 
 
 static const char* GCFunctionName() {
   bool flag_given = FLAG_expose_gc_as != NULL && strlen(FLAG_expose_gc_as) != 0;
   return flag_given ? FLAG_expose_gc_as : "gc";
 }
 
@@ skipping 29 matching lines @@
   delete externalize_string_extension_;
   externalize_string_extension_ = NULL;
   delete statistics_extension_;
   statistics_extension_ = NULL;
   delete trigger_failure_extension_;
   trigger_failure_extension_ = NULL;
   delete ignition_statistics_extension_;
   ignition_statistics_extension_ = NULL;
 }
 
-
-void DeleteNativeSources(Object* maybe_array) {
-  if (maybe_array->IsFixedArray()) {
-    FixedArray* array = FixedArray::cast(maybe_array);
-    Isolate* isolate = array->GetIsolate();
-    for (int i = 0; i < array->length(); i++) {
-      Object* natives_source = array->get(i);
-      if (!natives_source->IsUndefined(isolate)) {
-        const NativesExternalStringResource* resource =
-            reinterpret_cast<const NativesExternalStringResource*>(
-                ExternalOneByteString::cast(natives_source)->resource());
-        delete resource;
-      }
-    }
-  }
-}
-
-
 void Bootstrapper::TearDown() {
-  DeleteNativeSources(Natives::GetSourceCache(isolate_->heap()));
-  DeleteNativeSources(ExtraNatives::GetSourceCache(isolate_->heap()));
-  DeleteNativeSources(
-      ExperimentalExtraNatives::GetSourceCache(isolate_->heap()));
-
   extensions_cache_.Initialize(isolate_, false);  // Yes, symmetrical
 }
 
 
 class Genesis BASE_EMBEDDED {
  public:
   Genesis(Isolate* isolate, MaybeHandle<JSGlobalProxy> maybe_global_proxy,
           v8::Local<v8::ObjectTemplate> global_proxy_template,
           size_t context_snapshot_index,
           v8::DeserializeEmbedderFieldsCallback embedder_fields_deserializer,
@@ skipping 3070 matching lines @@
   HARMONY_STAGED(FEATURE_INITIALIZE_GLOBAL)
   HARMONY_SHIPPING(FEATURE_INITIALIZE_GLOBAL)
 #undef FEATURE_INITIALIZE_GLOBAL
 
   InitializeGlobal_experimental_fast_array_builtins();
 }
 
 bool Bootstrapper::CompileBuiltin(Isolate* isolate, int index) {
   Vector<const char> name = Natives::GetScriptName(index);
   Handle<String> source_code =
-      isolate->bootstrapper()->SourceLookup<Natives>(index);
+      isolate->bootstrapper()->GetNativeSource(CORE, index);
 
   // We pass in extras_utils so that builtin code can set it up for later use
   // by actual extras code, compiled with CompileExtraBuiltin.
   Handle<Object> global = isolate->global_object();
   Handle<Object> utils = isolate->natives_utils_object();
   Handle<Object> extras_utils = isolate->extras_utils_object();
   Handle<Object> args[] = {global, utils, extras_utils};
 
   return Bootstrapper::CompileNative(isolate, name, source_code,
                                      arraysize(args), args, NATIVES_CODE);
 }
 
 
 bool Bootstrapper::CompileExtraBuiltin(Isolate* isolate, int index) {
   HandleScope scope(isolate);
   Vector<const char> name = ExtraNatives::GetScriptName(index);
   Handle<String> source_code =
-      isolate->bootstrapper()->SourceLookup<ExtraNatives>(index);
+      isolate->bootstrapper()->GetNativeSource(EXTRAS, index);
   Handle<Object> global = isolate->global_object();
   Handle<Object> binding = isolate->extras_binding_object();
   Handle<Object> extras_utils = isolate->extras_utils_object();
   Handle<Object> args[] = {global, binding, extras_utils};
   return Bootstrapper::CompileNative(isolate, name, source_code,
                                      arraysize(args), args, EXTENSION_CODE);
 }
 
 
 bool Bootstrapper::CompileExperimentalExtraBuiltin(Isolate* isolate,
                                                    int index) {
   HandleScope scope(isolate);
   Vector<const char> name = ExperimentalExtraNatives::GetScriptName(index);
   Handle<String> source_code =
-      isolate->bootstrapper()->SourceLookup<ExperimentalExtraNatives>(index);
+      isolate->bootstrapper()->GetNativeSource(EXPERIMENTAL_EXTRAS, index);
   Handle<Object> global = isolate->global_object();
   Handle<Object> binding = isolate->extras_binding_object();
   Handle<Object> extras_utils = isolate->extras_utils_object();
   Handle<Object> args[] = {global, binding, extras_utils};
   return Bootstrapper::CompileNative(isolate, name, source_code,
                                      arraysize(args), args, EXTENSION_CODE);
 }
 
 bool Bootstrapper::CompileNative(Isolate* isolate, Vector<const char> name,
                                  Handle<String> source, int argc,
@@ skipping 2015 matching lines @@
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   DCHECK(!IsActive());
 }
 
 }  // namespace internal
 }  // namespace v8