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

src/snapshot/serializer.h

 // 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.
 
 #ifndef V8_SNAPSHOT_SERIALIZER_H_
 #define V8_SNAPSHOT_SERIALIZER_H_
 
 #include "src/isolate.h"
 #include "src/log.h"
 #include "src/objects.h"
@@ skipping 102 matching lines @@
     address_to_name_map_.Insert(code->address(), name, length);
   }
 
   NameMap address_to_name_map_;
   Isolate* isolate_;
 };
 
 // There can be only one serializer per V8 process.
 class Serializer : public SerializerDeserializer {
  public:
-  Serializer(Isolate* isolate, SnapshotByteSink* sink);
+  explicit Serializer(Isolate* isolate);
   ~Serializer() override;
 
   void EncodeReservations(List<SerializedData::Reservation>* out) const;
 
   void SerializeDeferredObjects();
 
   Isolate* isolate() const { return isolate_; }
 
   SerializerReferenceMap* reference_map() { return &reference_map_; }
   RootIndexMap* root_index_map() { return &root_index_map_; }
@@ skipping 36 matching lines @@
 
   // Emit alignment prefix if necessary, return required padding space in bytes.
   int PutAlignmentPrefix(HeapObject* object);
 
   // Returns true if the object was successfully serialized.
   bool SerializeKnownObject(HeapObject* obj, HowToCode how_to_code,
                             WhereToPoint where_to_point, int skip);
 
   inline void FlushSkip(int skip) {
     if (skip != 0) {
-      sink_->Put(kSkip, "SkipFromSerializeObject");
-      sink_->PutInt(skip, "SkipDistanceFromSerializeObject");
+      sink_.Put(kSkip, "SkipFromSerializeObject");
+      sink_.PutInt(skip, "SkipDistanceFromSerializeObject");
     }
   }
 
   bool BackReferenceIsAlreadyAllocated(SerializerReference back_reference);
 
   // This will return the space for an object.
   SerializerReference AllocateLargeObject(int size);
   SerializerReference Allocate(AllocationSpace space, int size);
   int EncodeExternalReference(Address addr) {
     return external_reference_encoder_.Encode(addr);
   }
 
   bool HasNotExceededFirstPageOfEachSpace();
 
   // GetInt reads 4 bytes at once, requiring padding at the end.
   void Pad();
 
   // We may not need the code address map for logging for every instance
   // of the serializer.  Initialize it on demand.
   void InitializeCodeAddressMap();
 
   Code* CopyCode(Code* code);
 
   inline uint32_t max_chunk_size(int space) const {
     DCHECK_LE(0, space);
     DCHECK_LT(space, kNumberOfSpaces);
     return max_chunk_size_[space];
   }
 
-  SnapshotByteSink* sink() const { return sink_; }
+  const SnapshotByteSink* sink() const { return &sink_; }
 
   void QueueDeferredObject(HeapObject* obj) {
     DCHECK(reference_map_.Lookup(obj).is_back_reference());
     deferred_objects_.Add(obj);
   }
 
   void OutputStatistics(const char* name);
 
   Isolate* isolate_;
 
-  SnapshotByteSink* sink_;
+  SnapshotByteSink sink_;
   ExternalReferenceEncoder external_reference_encoder_;
 
   SerializerReferenceMap reference_map_;
   RootIndexMap root_index_map_;
 
   int recursion_depth_;
 
   friend class Deserializer;
   friend class ObjectSerializer;
   friend class RecursionScope;
@@ skipping 83 matching lines @@
   SnapshotByteSink* sink_;
   int reference_representation_;
   int bytes_processed_so_far_;
   bool code_has_been_output_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_SNAPSHOT_SERIALIZER_H_