[snapshot] pass arguments as pointers, not references.

src/snapshot/snapshot-common.cc

 // Copyright 2006-2008 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.
 
 // The common functionality when building with or without snapshots.
 
 #include "src/snapshot/snapshot.h"
 
 #include "src/api.h"
 #include "src/base/platform/platform.h"
@@ skipping 68 matching lines @@
   if (!maybe_context.ToHandle(&result)) return MaybeHandle<Context>();
   CHECK(result->IsContext());
   if (FLAG_profile_deserialization) {
     double ms = timer.Elapsed().InMillisecondsF();
     int bytes = context_data.length();
     PrintF("[Deserializing context (%d bytes) took %0.3f ms]\n", bytes, ms);
   }
   return Handle<Context>::cast(result);
 }
 
-void CalculateFirstPageSizes(const SnapshotData& startup_snapshot,
-                             const SnapshotData& context_snapshot,
+void CalculateFirstPageSizes(const SnapshotData* startup_snapshot,
+                             const SnapshotData* context_snapshot,
                              uint32_t* sizes_out) {
   Vector<const SerializedData::Reservation> startup_reservations =
-      startup_snapshot.Reservations();
+      startup_snapshot->Reservations();
   Vector<const SerializedData::Reservation> context_reservations =
-      context_snapshot.Reservations();
+      context_snapshot->Reservations();
   int startup_index = 0;
   int context_index = 0;
 
   if (FLAG_profile_deserialization) {
     int startup_total = 0;
     int context_total = 0;
-    for (auto& reservation : startup_reservations) {
+    for (const auto& reservation : startup_reservations) {
       startup_total += reservation.chunk_size();
     }
-    for (auto& reservation : context_reservations) {
+    for (const auto& reservation : context_reservations) {
       context_total += reservation.chunk_size();
     }
     PrintF(
         "Deserialization will reserve:\n"
         "%10d bytes per isolate\n"
         "%10d bytes per context\n",
         startup_total, context_total);
   }
 
   for (int space = 0; space < i::Serializer::kNumberOfSpaces; space++) {
@@ skipping 29 matching lines @@
     }
     startup_index++;
     context_index++;
   }
 
   DCHECK_EQ(startup_reservations.length(), startup_index);
   DCHECK_EQ(context_reservations.length(), context_index);
 }
 
 v8::StartupData Snapshot::CreateSnapshotBlob(
-    const i::StartupSerializer& startup_ser,
-    const i::PartialSerializer& context_ser) {
-  SnapshotData startup_snapshot(startup_ser);
-  SnapshotData context_snapshot(context_ser);
+    const StartupSerializer* startup_serializer,
+    const PartialSerializer* context_serializer) {
+  SnapshotData startup_snapshot(startup_serializer);
+  SnapshotData context_snapshot(context_serializer);
   Vector<const byte> startup_data = startup_snapshot.RawData();
   Vector<const byte> context_data = context_snapshot.RawData();
 
   uint32_t first_page_sizes[kNumPagedSpaces];
 
-  CalculateFirstPageSizes(startup_snapshot, context_snapshot, first_page_sizes);
+  CalculateFirstPageSizes(&startup_snapshot, &context_snapshot,
+                          first_page_sizes);
 
   int startup_length = startup_data.length();
   int context_length = context_data.length();
   int context_offset = ContextOffset(startup_length);
 
   int length = context_offset + context_length;
   char* data = new char[length];
 
   memcpy(data + kFirstPageSizesOffset, first_page_sizes,
          kNumPagedSpaces * kInt32Size);
@@ skipping 28 matching lines @@
   int startup_length;
   memcpy(&startup_length, data->data + kStartupLengthOffset, kIntSize);
   int context_offset = ContextOffset(startup_length);
   const byte* context_data =
       reinterpret_cast<const byte*>(data->data + context_offset);
   DCHECK_LT(context_offset, data->raw_size);
   int context_length = data->raw_size - context_offset;
   return Vector<const byte>(context_data, context_length);
 }
 
-SnapshotData::SnapshotData(const Serializer& ser) {
+SnapshotData::SnapshotData(const Serializer* serializer) {
   DisallowHeapAllocation no_gc;
   List<Reservation> reservations;
-  ser.EncodeReservations(&reservations);
-  const List<byte>& payload = ser.sink()->data();
+  serializer->EncodeReservations(&reservations);
+  const List<byte>* payload = serializer->sink()->data();
 
   // Calculate sizes.
   int reservation_size = reservations.length() * kInt32Size;
-  int size = kHeaderSize + reservation_size + payload.length();
+  int size = kHeaderSize + reservation_size + payload->length();
 
   // Allocate backing store and create result data.
   AllocateData(size);
 
   // Set header values.
-  SetMagicNumber(ser.isolate());
+  SetMagicNumber(serializer->isolate());
   SetHeaderValue(kCheckSumOffset, Version::Hash());
   SetHeaderValue(kNumReservationsOffset, reservations.length());
-  SetHeaderValue(kPayloadLengthOffset, payload.length());
+  SetHeaderValue(kPayloadLengthOffset, payload->length());
 
   // Copy reservation chunk sizes.
   CopyBytes(data_ + kHeaderSize, reinterpret_cast<byte*>(reservations.begin()),
             reservation_size);
 
   // Copy serialized data.
-  CopyBytes(data_ + kHeaderSize + reservation_size, payload.begin(),
-            static_cast<size_t>(payload.length()));
+  CopyBytes(data_ + kHeaderSize + reservation_size, payload->begin(),
+            static_cast<size_t>(payload->length()));
 }
 
 bool SnapshotData::IsSane() {
   return GetHeaderValue(kCheckSumOffset) == Version::Hash();
 }
 
 Vector<const SerializedData::Reservation> SnapshotData::Reservations() const {
   return Vector<const Reservation>(
       reinterpret_cast<const Reservation*>(data_ + kHeaderSize),
       GetHeaderValue(kNumReservationsOffset));
 }
 
 Vector<const byte> SnapshotData::Payload() const {
   int reservations_size = GetHeaderValue(kNumReservationsOffset) * kInt32Size;
   const byte* payload = data_ + kHeaderSize + reservations_size;
   int length = GetHeaderValue(kPayloadLengthOffset);
   DCHECK_EQ(data_ + size_, payload + length);
   return Vector<const byte>(payload, length);
 }
 
 }  // namespace internal
 }  // namespace v8