Introduce code serializer/deserializer.

src/mksnapshot.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.
 
 #include <errno.h>
 #include <stdio.h>
 #ifdef COMPRESS_STARTUP_DATA_BZ2
 #include <bzlib.h>
 #endif
 #include <signal.h>
@@ skipping 14 matching lines @@
 
 
 class Compressor {
  public:
   virtual ~Compressor() {}
   virtual bool Compress(i::Vector<char> input) = 0;
   virtual i::Vector<char>* output() = 0;
 };
 
 
-class ListSnapshotSink : public i::SnapshotByteSink {
- public:
-  explicit ListSnapshotSink(i::List<char>* data) : data_(data) { }
-  virtual ~ListSnapshotSink() {}
-  virtual void Put(int byte, const char* description) { data_->Add(byte); }
-  virtual int Position() { return data_->length(); }
- private:
-  i::List<char>* data_;
-};
-
-
 class SnapshotWriter {
  public:
   explicit SnapshotWriter(const char* snapshot_file)
       : fp_(GetFileDescriptorOrDie(snapshot_file))
       , raw_file_(NULL)
       , raw_context_file_(NULL)
       , startup_blob_file_(NULL)
       , compressor_(NULL) {
   }
 
@@ skipping 30 matching lines @@
 
  private:
   void MaybeWriteStartupBlob(const i::List<char>& snapshot_data,
                              const i::Serializer& serializer,
                              const i::List<char>& context_snapshot_data,
                              const i::Serializer& context_serializer) const {
     if (!startup_blob_file_)
       return;
 
     i::List<char> startup_blob;
-    ListSnapshotSink sink(&startup_blob);
+    i::ListSnapshotSink sink(&startup_blob);
 
     int spaces[] = {
         i::NEW_SPACE, i::OLD_POINTER_SPACE, i::OLD_DATA_SPACE, i::CODE_SPACE,
         i::MAP_SPACE, i::CELL_SPACE,  i::PROPERTY_CELL_SPACE
     };
 
     i::byte* snapshot_bytes = reinterpret_cast<i::byte*>(snapshot_data.begin());
     sink.PutBlob(snapshot_bytes, snapshot_data.length(), "snapshot");
     for (size_t i = 0; i < ARRAY_SIZE(spaces); ++i)
       sink.PutInt(serializer.CurrentAllocationAddress(spaces[i]), "spaces");
@@ skipping 303 matching lines @@
     // If we don't do this then we end up with a stray root pointing at the
     // context even after we have disposed of the context.
     internal_isolate->heap()->CollectAllGarbage(
         i::Heap::kNoGCFlags, "mksnapshot");
     i::Object* raw_context = *v8::Utils::OpenPersistent(context);
     context.Reset();
 
     // This results in a somewhat smaller snapshot, probably because it gets
     // rid of some things that are cached between garbage collections.
     i::List<char> snapshot_data;
-    ListSnapshotSink snapshot_sink(&snapshot_data);
+    i::ListSnapshotSink snapshot_sink(&snapshot_data);
     i::StartupSerializer ser(internal_isolate, &snapshot_sink);
     ser.SerializeStrongReferences();
 
     i::List<char> context_data;
-    ListSnapshotSink contex_sink(&context_data);
+    i::ListSnapshotSink contex_sink(&context_data);
     i::PartialSerializer context_ser(internal_isolate, &ser, &contex_sink);
     context_ser.Serialize(&raw_context);
     ser.SerializeWeakReferences();
 
     {
       SnapshotWriter writer(argv[1]);
       if (i::FLAG_raw_file && i::FLAG_raw_context_file)
         writer.SetRawFiles(i::FLAG_raw_file, i::FLAG_raw_context_file);
       if (i::FLAG_startup_blob)
         writer.SetStartupBlobFile(i::FLAG_startup_blob);
   #ifdef COMPRESS_STARTUP_DATA_BZ2
       BZip2Compressor bzip2;
       writer.SetCompressor(&bzip2);
   #endif
       writer.WriteSnapshot(snapshot_data, ser, context_data, context_ser);
     }
   }
 
   isolate->Dispose();
   V8::Dispose();
   V8::ShutdownPlatform();
   delete platform;
   return 0;
 }