[snapshot] make snapshot sink a non-dynamic member of the serializer.

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,
+    Isolate* isolate,
     v8::SnapshotCreator::FunctionCodeHandling function_code_handling)
-    : Serializer(isolate, sink),
+    : Serializer(isolate),
       clear_function_code_(function_code_handling ==
                            v8::SnapshotCreator::FunctionCodeHandling::kClear),
       serializing_builtins_(false) {
   InitializeCodeAddressMap();
 }
 
 StartupSerializer::~StartupSerializer() {
   OutputStatistics("StartupSerializer");
 }
 
@@ skipping 31 matching lines @@
       PutRoot(root_index, obj, how_to_code, where_to_point, skip);
       return;
     }
   }
 
   if (SerializeKnownObject(obj, how_to_code, where_to_point, skip)) return;
 
   FlushSkip(skip);
 
   // Object has not yet been serialized.  Serialize it here.
-  ObjectSerializer object_serializer(this, obj, sink_, how_to_code,
+  ObjectSerializer object_serializer(this, obj, &sink_, how_to_code,
                                      where_to_point);
   object_serializer.Serialize();
 
   if (serializing_immortal_immovables_roots_ &&
       root_index != RootIndexMap::kInvalidRootIndex) {
     // Make sure that the immortal immovable root has been included in the first
     // chunk of its reserved space , so that it is deserialized onto the first
     // page of its space and stays immortal immovable.
     SerializerReference ref = reference_map_.Lookup(obj);
     CHECK(ref.is_back_reference() && ref.chunk_index() == 0);
   }
 }
 
 void StartupSerializer::SerializeWeakReferencesAndDeferred() {
   // This comes right after serialization of the partial snapshot, where we
   // add entries to the partial snapshot cache of the startup snapshot. Add
   // one entry with 'undefined' to terminate the partial snapshot cache.
   Object* undefined = isolate()->heap()->undefined_value();
   VisitPointer(&undefined);
   isolate()->heap()->IterateWeakRoots(this, VISIT_ALL);
   SerializeDeferredObjects();
   Pad();
 }
 
 void StartupSerializer::Synchronize(VisitorSynchronization::SyncTag tag) {
   // We expect the builtins tag after builtins have been serialized.
   DCHECK(!serializing_builtins_ || tag == VisitorSynchronization::kBuiltins);
   serializing_builtins_ = (tag == VisitorSynchronization::kHandleScope);
-  sink_->Put(kSynchronize, "Synchronize");
+  sink_.Put(kSynchronize, "Synchronize");
 }
 
 void StartupSerializer::SerializeStrongReferences() {
   Isolate* isolate = this->isolate();
   // No active threads.
   CHECK_NULL(isolate->thread_manager()->FirstThreadStateInUse());
   // No active or weak handles.
   CHECK(isolate->handle_scope_implementer()->blocks()->is_empty());
   CHECK_EQ(0, isolate->global_handles()->NumberOfWeakHandles());
   CHECK_EQ(0, isolate->eternal_handles()->NumberOfHandles());
@@ skipping 51 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