[snapshot] remove metadata field.

src/api.cc

 // Copyright 2012 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/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 367 matching lines @@
     i::PrintF("Executing custom snapshot script %s took %0.3f ms\n", name,
               timer.Elapsed().InMillisecondsF());
   }
   timer.Stop();
   CHECK(!try_catch.HasCaught());
   return true;
 }
 
 StartupData SerializeIsolateAndContext(
     Isolate* isolate, Persistent<Context>* context,
-    i::Snapshot::Metadata metadata,
     i::StartupSerializer::FunctionCodeHandling function_code_handling) {
   if (context->IsEmpty()) return {NULL, 0};
 
   i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
 
   // If we don't do this then we end up with a stray root pointing at the
   // context even after we have disposed of the context.
   internal_isolate->heap()->CollectAllAvailableGarbage("mksnapshot");
 
   // GC may have cleared weak cells, so compact any WeakFixedArrays
@@ skipping 22 matching lines @@
   i::SnapshotByteSink snapshot_sink;
   i::StartupSerializer ser(internal_isolate, &snapshot_sink,
                            function_code_handling);
   ser.SerializeStrongReferences();
 
   i::SnapshotByteSink context_sink;
   i::PartialSerializer context_ser(internal_isolate, &ser, &context_sink);
   context_ser.Serialize(&raw_context);
   ser.SerializeWeakReferencesAndDeferred();
 
-  return i::Snapshot::CreateSnapshotBlob(ser, context_ser, metadata);
+  return i::Snapshot::CreateSnapshotBlob(ser, context_ser);
 }
 
 }  // namespace
 
 StartupData V8::CreateSnapshotDataBlob(const char* embedded_source) {
   // Create a new isolate and a new context from scratch, optionally run
   // a script to embed, and serialize to create a snapshot blob.
   StartupData result = {NULL, 0};
 
   base::ElapsedTimer timer;
@@ skipping 11 matching lines @@
     {
       HandleScope handle_scope(isolate);
       Local<Context> new_context = Context::New(isolate);
       context.Reset(isolate, new_context);
       if (embedded_source != NULL &&
           !RunExtraCode(isolate, new_context, embedded_source, "<embedded>")) {
         context.Reset();
       }
     }
 
-    i::Snapshot::Metadata metadata;
-    metadata.set_embeds_script(embedded_source != NULL);
-
     result = SerializeIsolateAndContext(
-        isolate, &context, metadata, i::StartupSerializer::CLEAR_FUNCTION_CODE);
+        isolate, &context, i::StartupSerializer::CLEAR_FUNCTION_CODE);
     DCHECK(context.IsEmpty());
   }
   isolate->Dispose();
 
   if (i::FLAG_profile_deserialization) {
     i::PrintF("Creating snapshot took %0.3f ms\n",
               timer.Elapsed().InMillisecondsF());
   }
   timer.Stop();
   return result;
@@ skipping 30 matching lines @@
       Local<Context> new_context = Context::New(isolate);
       success = RunExtraCode(isolate, new_context, warmup_source, "<warm-up>");
     }
     if (success) {
       HandleScope handle_scope(isolate);
       isolate->ContextDisposedNotification(false);
       Local<Context> new_context = Context::New(isolate);
       context.Reset(isolate, new_context);
     }
 
-    i::Snapshot::Metadata metadata;
-    metadata.set_embeds_script(i::Snapshot::EmbedsScript(internal_isolate));
-
     result = SerializeIsolateAndContext(
-        isolate, &context, metadata, i::StartupSerializer::KEEP_FUNCTION_CODE);
+        isolate, &context, i::StartupSerializer::KEEP_FUNCTION_CODE);
     DCHECK(context.IsEmpty());
   }
   isolate->Dispose();
 
   if (i::FLAG_profile_deserialization) {
     i::PrintF("Warming up snapshot took %0.3f ms\n",
               timer.Elapsed().InMillisecondsF());
   }
   timer.Stop();
   return result;
@@ skipping 6734 matching lines @@
   }
 
   if (params.add_histogram_sample_callback) {
     v8_isolate->SetAddHistogramSampleFunction(
         params.add_histogram_sample_callback);
   }
   SetResourceConstraints(isolate, params.constraints);
   // TODO(jochen): Once we got rid of Isolate::Current(), we can remove this.
   Isolate::Scope isolate_scope(v8_isolate);
   if (params.entry_hook || !i::Snapshot::Initialize(isolate)) {
-    // If the isolate has a function entry hook, it needs to re-build all its
-    // code stubs with entry hooks embedded, so don't deserialize a snapshot.
-    if (i::Snapshot::EmbedsScript(isolate)) {
-      // If the snapshot embeds a script, we cannot initialize the isolate
-      // without the snapshot as a fallback. This is unlikely to happen though.
-      V8_Fatal(__FILE__, __LINE__,
-               "Initializing isolate from custom startup snapshot failed");
-    }
     isolate->Init(NULL);
   }
   return v8_isolate;
 }
 
 
 void Isolate::Dispose() {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
   if (!Utils::ApiCheck(!isolate->IsInUse(),
                        "v8::Isolate::Dispose()",
@@ skipping 1529 matching lines @@
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 }  // namespace internal
 }  // namespace v8