[serializer] prepare attached references for general use.

src/snapshot/deserializer.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_DESERIALIZER_H_
 #define V8_SNAPSHOT_DESERIALIZER_H_
 
 #include "src/heap/heap.h"
 #include "src/objects.h"
 #include "src/snapshot/serializer-common.h"
@@ skipping 35 matching lines @@
   // Deserialize the snapshot into an empty heap.
   void Deserialize(Isolate* isolate);
 
   // Deserialize a single object and the objects reachable from it.
   MaybeHandle<Object> DeserializePartial(Isolate* isolate,
                                          Handle<JSGlobalProxy> global_proxy);
 
   // Deserialize a shared function info. Fail gracefully.
   MaybeHandle<SharedFunctionInfo> DeserializeCode(Isolate* isolate);
 
-  // Pass a vector of externally-provided objects referenced by the snapshot.
-  // The ownership to its backing store is handed over as well.
-  void SetAttachedObjects(Vector<Handle<Object> > attached_objects) {
-    attached_objects_ = attached_objects;
+  // Add an object to back an attached reference. The order to add objects must
+  // mirror the order they are added in the serializer.
+  void AddAttachedObject(Handle<HeapObject> attached_object) {
+    attached_objects_.Add(attached_object);
   }
 
  private:
   void VisitPointers(Object** start, Object** end) override;
 
   void Synchronize(VisitorSynchronization::SyncTag tag) override;
 
   void VisitRuntimeEntry(RelocInfo* rinfo) override { UNREACHABLE(); }
 
   void Initialize(Isolate* isolate);
@@ skipping 40 matching lines @@
   // snapshot by chunk index and offset.
   HeapObject* GetBackReferencedObject(int space);
 
   Object** CopyInNativesSource(Vector<const char> source_vector,
                                Object** current);
 
   // Cached current isolate.
   Isolate* isolate_;
 
   // Objects from the attached object descriptions in the serialized user code.
-  Vector<Handle<Object> > attached_objects_;
+  List<Handle<HeapObject> > attached_objects_;
 
   SnapshotByteSource source_;
   uint32_t magic_number_;
 
   // The address of the next object that will be allocated in each space.
   // Each space has a number of chunks reserved by the GC, with each chunk
   // fitting into a page. Deserialized objects are allocated into the
   // current chunk of the target space by bumping up high water mark.
   Heap::Reservation reservations_[kNumberOfSpaces];
   uint32_t current_chunk_[kNumberOfPreallocatedSpaces];
@@ skipping 10 matching lines @@
 
   AllocationAlignment next_alignment_;
 
   DISALLOW_COPY_AND_ASSIGN(Deserializer);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_SNAPSHOT_DESERIALIZER_H_