[snapshot] introduce SnapshotCreator API.

src/snapshot/startup-serializer.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/startup-serializer.h"
 
 #include "src/objects-inl.h"
 #include "src/v8threads.h"
 
 namespace v8 {
 namespace internal {
 
 StartupSerializer::StartupSerializer(
     Isolate* isolate, SnapshotByteSink* sink,
-    FunctionCodeHandling function_code_handling)
+    v8::SnapshotCreator::FunctionCodeHandling function_code_handling)
     : Serializer(isolate, sink),
-      function_code_handling_(function_code_handling),
+      clear_function_code_(function_code_handling ==
+                           v8::SnapshotCreator::FunctionCodeHandling::kClear),
       serializing_builtins_(false) {
   InitializeCodeAddressMap();
 }
 
 StartupSerializer::~StartupSerializer() {
   OutputStatistics("StartupSerializer");
 }
 
 void StartupSerializer::SerializeObject(HeapObject* obj, HowToCode how_to_code,
                                         WhereToPoint where_to_point, int skip) {
   DCHECK(!obj->IsJSFunction());
 
-  if (function_code_handling_ == CLEAR_FUNCTION_CODE) {
+  if (clear_function_code_) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       // If the function code is compiled (either as native code or bytecode),
       // replace it with lazy-compile builtin. Only exception is when we are
       // serializing the canonical interpreter-entry-trampoline builtin.
       if (code->kind() == Code::FUNCTION ||
           (!serializing_builtins_ &&
            code->is_interpreter_trampoline_builtin())) {
         obj = isolate()->builtins()->builtin(Builtins::kCompileLazy);
       }
     } else if (obj->IsBytecodeArray()) {
       obj = isolate()->heap()->undefined_value();
     }
   } else if (obj->IsCode()) {
-    DCHECK_EQ(KEEP_FUNCTION_CODE, function_code_handling_);
     Code* code = Code::cast(obj);
     if (code->kind() == Code::FUNCTION) {
       code->ClearInlineCaches();
       code->set_profiler_ticks(0);
     }
   }
 
   int root_index = root_index_map_.Lookup(obj);
   // We can only encode roots as such if it has already been serialized.
   // That applies to root indices below the wave front.
@@ skipping 103 matching lines @@
   if (root_index == Heap::kStackLimitRootIndex ||
       root_index == Heap::kRealStackLimitRootIndex) {
     return true;
   }
   return Heap::RootIsImmortalImmovable(root_index) !=
          serializing_immortal_immovables_roots_;
 }
 
 }  // namespace internal
 }  // namespace v8