Create temporary handles in the snapshot object during initialization and use them instead of cre...

vm/snapshot.h

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_SNAPSHOT_H_
 #define VM_SNAPSHOT_H_
 
 #include "vm/allocation.h"
 #include "vm/assert.h"
 #include "vm/bitfield.h"
 #include "vm/globals.h"
 #include "vm/growable_array.h"
 #include "vm/isolate.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 // Forward declarations.
+class AbstractType;
+class AbstractTypeArguments;
+class Class;
 class Heap;
 class Library;
 class Object;
 class ObjectStore;
 class RawClass;
 class RawObject;
+class String;
 
 static const int8_t kSerializedBitsPerByte = 7;
 static const int8_t kMaxSerializedUnsignedValuePerByte = 127;
 static const int8_t kMaxSerializedValuePerByte = 63;
 static const int8_t kMinSerializedValuePerByte = -64;
 static const uint8_t kEndByteMarker = (255 - kMaxSerializedValuePerByte);
 static const int8_t kSerializedByteMask = (1 << kSerializedBitsPerByte) - 1;
 
 // Serialized object header encoding is as follows:
 // - Smi: the Smi value is written as is (last bit is not tagged).
@@ skipping 237 matching lines @@
   // MessageWriter and SnapshotWriter needs access to the private Raw
   // classes.
   friend class BaseWriter;
   DISALLOW_COPY_AND_ASSIGN(WriteStream);
 };
 
 
 // Reads a snapshot into objects.
 class SnapshotReader {
  public:
-  SnapshotReader(const Snapshot* snapshot, Isolate* isolate)
-      : stream_(snapshot->content(), snapshot->length()),
-        kind_(snapshot->kind()),
-        isolate_(isolate),
-        backward_references_() { }
+  SnapshotReader(const Snapshot* snapshot, Isolate* isolate);
   ~SnapshotReader() { }
 
   // Reads raw data (for basic types).
   // sizeof(T) must be in {1,2,4,8}.
   template <typename T>
   T Read() {
     return ReadStream::Raw<sizeof(T), T>::Read(&stream_);
   }
 
   // Reads an intptr_t type value.
   intptr_t ReadIntptrValue() {
     int64_t value = Read<int64_t>();
     ASSERT((value <= kIntptrMax) && (value >= kIntptrMin));
     return value;
   }
 
   Isolate* isolate() const { return isolate_; }
   Heap* heap() const { return isolate_->heap(); }
   ObjectStore* object_store() const { return isolate_->object_store(); }
+  Object* ObjectHandle() { return &obj_; }
+  String* StringHandle() { return &str_; }
+  AbstractType* TypeHandle() { return &type_; }
+  AbstractTypeArguments* TypeArgumentsHandle() { return &type_arguments_; }
 
   // Reads an object.
   RawObject* ReadObject();
 
   RawClass* ReadClassId(intptr_t object_id);
 
   // Add object to backward references.
   void AddBackwardReference(intptr_t id, Object* obj);
 
   // Read a full snap shot.
   void ReadFullSnapshot();
 
  private:
   // Internal implementation of ReadObject once the header value is read.
   RawObject* ReadObjectImpl(intptr_t header);
 
   // Read an object that was serialized as an Id (singleton, object store,
   // or an object that was already serialized before).
   RawObject* ReadIndexedObject(intptr_t object_id);
 
   // Read an inlined object from the stream.
   RawObject* ReadInlinedObject(intptr_t object_id);
 
   // Based on header field check to see if it is an internal VM class.
   RawClass* LookupInternalClass(intptr_t class_header);
 
   ReadStream stream_;  // input stream.
   Snapshot::Kind kind_;  // Indicates type of snapshot(full, script, message).
   Isolate* isolate_;  // Current isolate.
+  Class& cls_;  // Temporary Class handle.
+  Object& obj_;  // Temporary Object handle.
+  String& str_;  // Temporary String handle.
+  Library& library_;  // Temporary library handle.
+  AbstractType& type_;  // Temporary type handle.
+  AbstractTypeArguments& type_arguments_;  // Temporary type argument handle.
   GrowableArray<Object*> backward_references_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotReader);
 };
 
 
 class BaseWriter {
  public:
   // Size of the snapshot.
   intptr_t BytesWritten() const { return stream_.bytes_written(); }
@@ skipping 161 matching lines @@
 
  private:
   SnapshotWriter* writer_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // VM_SNAPSHOT_H_