Address review comments from a previous CL.

vm/snapshot.cc

 // Copyright (c) 2012, 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.
 
 #include "vm/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/exceptions.h"
 #include "vm/heap.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 
 namespace dart {
 
 enum {
   kInstanceId = ObjectStore::kMaxId,
   kMaxPredefinedObjectIds,
 };
 static const int kNumInitialReferencesInFullSnapshot = 160 * KB;
 static const int kNumInitialReferences = 4;
 
 
 static bool IsSingletonClassId(intptr_t index) {
-  // Check if this is a singleton object class which is shared by all isolates.
-  return (index >= Object::kClassClass && index < Object::kMaxId);
+  // Check if this is a singleton class which is shared by all isolates.
+  return ((index >= kClass && index <= kUnwindError) ||
+          (index >= kNullClassId && index <= kVoidClassId));
 }
 
 
 static bool IsObjectStoreClassId(intptr_t index) {
   // Check if this is a class which is stored in the object store.
-  return (index >= ObjectStore::kObjectClass && index < ObjectStore::kMaxId);
+  return ((index == kObject) || (index >= kInstance && index <= kJSRegExp));
 }
 
 
 static bool IsObjectStoreTypeId(intptr_t index) {
   // Check if this is a type which is stored in the object store.
   return (index >= ObjectStore::kObjectType &&
-          index <= ObjectStore::kListInterface);
+          index <= ObjectStore::kByteArrayInterface);
 }
 
 
 // TODO(5411462): Temporary setup of snapshot for testing purposes,
 // the actual creation of a snapshot maybe done differently.
 const Snapshot* Snapshot::SetupFromBuffer(const void* raw_memory) {
   ASSERT(raw_memory != NULL);
   ASSERT(kHeaderSize == sizeof(Snapshot));
   ASSERT(kLengthIndex == length_offset());
   ASSERT((kSnapshotFlagIndex * sizeof(int32_t)) == kind_offset());
@@ skipping 416 matching lines @@
 }
 
 
 RawClass* SnapshotReader::LookupInternalClass(intptr_t class_header) {
   SerializedHeaderType header_type = SerializedHeaderTag::decode(class_header);
 
   // If the header is an object Id, lookup singleton VM classes or classes
   // stored in the object store.
   if (header_type == kObjectId) {
     intptr_t header_value = SerializedHeaderData::decode(class_header);
-    if (IsObjectStoreClassId(header_value)) {
-      return object_store()->GetClass(header_value);
-    } else if (IsSingletonClassId(header_value)) {
-      return Object::GetSingletonClass(header_value);  // return the singleton.
+    if (IsObjectStoreClassId(header_value) ||
+        IsSingletonClassId(header_value)) {
+      return class_table()->At(header_value);
     }
   }
   return Class::null();
 }
 
 
 RawObject* SnapshotReader::AllocateUninitialized(const Class& cls,
                                                  intptr_t size) {
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
@@ skipping 20 matching lines @@
 
 
 RawObject* SnapshotReader::ReadIndexedObject(intptr_t object_id) {
   if (object_id == Object::kNullObject) {
     // This is a singleton null object, return it.
     return Object::null();
   }
   if (object_id == Object::kSentinelObject) {
     return Object::sentinel();
   }
-  if (IsSingletonClassId(object_id)) {
-    return Object::GetSingletonClass(object_id);  // return singleton object.
-  } else if (IsObjectStoreClassId(object_id)) {
-    return object_store()->GetClass(object_id);
+  if (IsSingletonClassId(object_id) || IsObjectStoreClassId(object_id)) {
+    return class_table()->At(object_id);
   } else if (object_id == ObjectStore::kTrueValue) {
     return object_store()->true_value();
   } else if (object_id == ObjectStore::kFalseValue) {
     return object_store()->false_value();
   } else if (kind_ != Snapshot::kFull) {
     if (IsObjectStoreTypeId(object_id)) {
       return object_store()->GetType(object_id);  // return type object.
     }
   }
 
@@ skipping 127 matching lines @@
     // this object id. Mark it as not having been serialized yet so that we
     // will serialize the object when we go through the forward list.
     intptr_t object_id = MarkObject(raw, kIsNotSerialized);
 
     RawArray* rawarray = reinterpret_cast<RawArray*>(raw);
 
     // Write out the serialization header value for this object.
     WriteSerializationMarker(kInlined, object_id);
 
     // Write out the class information.
-    WriteIndexedObject(ObjectStore::kArrayClass);
+    WriteIndexedObject(kArray);
 
     // Write out the length field.
     Write<RawObject*>(rawarray->ptr()->length_);
 
     return;
   }
   if (obj_kind == ImmutableArray::kInstanceKind) {
     // Object is being referenced, add it to the forward ref list and mark
     // it so that future references to this object in the snapshot will use
     // this object id. Mark it as not having been serialized yet so that we
     // will serialize the object when we go through the forward list.
     intptr_t object_id = MarkObject(raw, kIsNotSerialized);
 
     RawArray* rawarray = reinterpret_cast<RawArray*>(raw);
 
     // Write out the serialization header value for this object.
     WriteSerializationMarker(kInlined, object_id);
 
     // Write out the class information.
-    WriteIndexedObject(ObjectStore::kImmutableArrayClass);
+    WriteIndexedObject(kImmutableArray);
 
     // Write out the length field.
     Write<RawObject*>(rawarray->ptr()->length_);
 
     return;
   }
   // Object is being referenced, add it to the forward ref list and mark
   // it so that future references to this object in the snapshot will use
   // this object id. Mark it as not having been serialized yet so that we
   // will serialize the object when we go through the forward list.
@@ skipping 91 matching lines @@
   }
 
   // Check if it is a singleton sentinel object which is shared by all isolates.
   if (rawobj == Object::sentinel()) {
     WriteIndexedObject(Object::kSentinelObject);
     return true;
   }
 
   // Check if it is a singleton class object which is shared by
   // all isolates.
-  RawClass* raw_class = reinterpret_cast<RawClass*>(rawobj);
-  intptr_t index = Object::GetSingletonClassIndex(raw_class);
+  intptr_t index = Object::GetSingletonClassIndex(rawobj);
   if (index != Object::kInvalidIndex) {
     WriteIndexedObject(index);
     return true;
   }
 
   // Check if it is a singleton boolean true value.
   if (rawobj == object_store()->true_value()) {
     WriteIndexedObject(ObjectStore::kTrueValue);
     return true;
   }
@@ skipping 125 matching lines @@
 
       // Mark object as serialized.
       forward_list_[i]->set_state(kIsSerialized);
     }
   }
 }
 
 
 void SnapshotWriter::WriteClassId(RawClass* cls) {
   ASSERT(kind_ != Snapshot::kFull);
-  int id = object_store()->GetClassIndex(cls);
+  int id = cls->ptr()->id_;
   if (IsSingletonClassId(id) || IsObjectStoreClassId(id)) {
     WriteIndexedObject(id);
   } else {
     // TODO(5411462): Should restrict this to only core-lib classes in this
     // case.
     // Write out the class and tags information.
-    WriteObjectHeader(Object::kClassClass, GetObjectTags(cls));
+    WriteObjectHeader(kClass, GetObjectTags(cls));
 
     // Write out the library url and class name.
     RawLibrary* library = cls->ptr()->library_;
     ASSERT(library != Library::null());
     WriteObjectImpl(library->ptr()->url_);
     WriteObjectImpl(cls->ptr()->name_);
   }
 }
 
 
@@ skipping 40 matching lines @@
     RawObject* raw_obj = *current;
     if (as_references_) {
       writer_->WriteObjectRef(raw_obj);
     } else {
       writer_->WriteObjectImpl(raw_obj);
     }
   }
 }
 
 }  // namespace dart