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

src/snapshot/partial-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/partial-serializer.h"
 
 #include "src/objects-inl.h"
 
 namespace v8 {
 namespace internal {
 
 PartialSerializer::PartialSerializer(Isolate* isolate,
-                                     Serializer* startup_snapshot_serializer,
-                                     SnapshotByteSink* sink)
-    : Serializer(isolate, sink),
+                                     Serializer* startup_snapshot_serializer)
+    : Serializer(isolate),
       startup_serializer_(startup_snapshot_serializer),
       next_partial_cache_index_(0) {
   InitializeCodeAddressMap();
 }
 
 PartialSerializer::~PartialSerializer() {
   OutputStatistics("PartialSerializer");
 }
 
 void PartialSerializer::Serialize(Object** o) {
@@ skipping 30 matching lines @@
   int root_index = root_index_map_.Lookup(obj);
   if (root_index != RootIndexMap::kInvalidRootIndex) {
     PutRoot(root_index, obj, how_to_code, where_to_point, skip);
     return;
   }
 
   if (ShouldBeInThePartialSnapshotCache(obj)) {
     FlushSkip(skip);
 
     int cache_index = PartialSnapshotCacheIndex(obj);
-    sink_->Put(kPartialSnapshotCache + how_to_code + where_to_point,
-               "PartialSnapshotCache");
-    sink_->PutInt(cache_index, "partial_snapshot_cache_index");
+    sink_.Put(kPartialSnapshotCache + how_to_code + where_to_point,
+              "PartialSnapshotCache");
+    sink_.PutInt(cache_index, "partial_snapshot_cache_index");
     return;
   }
 
   // Pointers from the partial snapshot to the objects in the startup snapshot
   // should go through the root array or through the partial snapshot cache.
   // If this is not the case you may have to add something to the root array.
   DCHECK(!startup_serializer_->reference_map()->Lookup(obj).is_valid());
   // All the internalized strings that the partial snapshot needs should be
   // either in the root table or in the partial snapshot cache.
   DCHECK(!obj->IsInternalizedString());
 
   if (SerializeKnownObject(obj, how_to_code, where_to_point, skip)) return;
 
   FlushSkip(skip);
 
   // Clear literal boilerplates.
   if (obj->IsJSFunction()) {
     LiteralsArray* literals = JSFunction::cast(obj)->literals();
     for (int i = 0; i < literals->literals_count(); i++) {
       literals->set_literal_undefined(i);
     }
   }
 
   // Object has not yet been serialized.  Serialize it here.
-  ObjectSerializer serializer(this, obj, sink_, how_to_code, where_to_point);
+  ObjectSerializer serializer(this, obj, &sink_, how_to_code, where_to_point);
   serializer.Serialize();
 }
 
 int PartialSerializer::PartialSnapshotCacheIndex(HeapObject* heap_object) {
   int index = partial_cache_index_map_.LookupOrInsert(
       heap_object, next_partial_cache_index_);
   if (index == PartialCacheIndexMap::kInvalidIndex) {
     // This object is not part of the partial snapshot cache yet. Add it to the
     // startup snapshot so we can refer to it via partial snapshot index from
     // the partial snapshot.
@@ skipping 10 matching lines @@
   // would cause dupes.
   DCHECK(!o->IsScript());
   return o->IsName() || o->IsSharedFunctionInfo() || o->IsHeapNumber() ||
          o->IsCode() || o->IsScopeInfo() || o->IsAccessorInfo() ||
          o->map() ==
              startup_serializer_->isolate()->heap()->fixed_cow_array_map();
 }
 
 }  // namespace internal
 }  // namespace v8