- Add extra checking when validating objects.

vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 404 matching lines @@
   static RawClass* var_descriptors_class_;  // Class of LocalVarDescriptors.
   static RawClass* exception_handlers_class_;  // Class of ExceptionHandlers.
   static RawClass* context_class_;  // Class of the Context vm object.
   static RawClass* context_scope_class_;  // Class of ContextScope vm object.
   static RawClass* icdata_class_;  // Class of ICData.
   static RawClass* api_error_class_;  // Class of ApiError.
   static RawClass* language_error_class_;  // Class of LanguageError.
   static RawClass* unhandled_exception_class_;  // Class of UnhandledException.
   static RawClass* unwind_error_class_;  // Class of UnwindError.
 
-  friend void RawObject::Validate() const;
+  friend void RawObject::Validate(Isolate* isolate) const;
   friend class SnapshotReader;
 
   // Disallow allocation.
   void* operator new(size_t size);
   // Disallow copy constructor.
   DISALLOW_COPY_AND_ASSIGN(Object);
 };
 
 
 class Class : public Object {
@@ skipping 753 matching lines @@
     ASSERT(sizeof(RawTypeArguments) == (sizeof(RawObject) + (1 * kWordSize)));
     return RoundedAllocationSize(sizeof(RawTypeArguments) + (len * kWordSize));
   }
 
   static RawTypeArguments* New(intptr_t len);
 
  private:
   // Make sure that the array size cannot wrap around.
   static const intptr_t kMaxTypes = 512 * 1024 * 1024;
   RawAbstractType** TypeAddr(intptr_t index) const;
-  void SetLength(intptr_t value);
+  void SetLength(intptr_t value) const;
 
   HEAP_OBJECT_IMPLEMENTATION(TypeArguments, AbstractTypeArguments);
   friend class Class;
 };
 
 
 // An instance of InstantiatedTypeArguments is never encountered at compile
 // time, but only at run time, when type parameters can be matched to actual
 // types.
 // An instance of InstantiatedTypeArguments consists of a pair of
@@ skipping 2283 matching lines @@
  private:
   // Make sure that the array size cannot wrap around.
   static const intptr_t kMaxArrayElements = 512 * 1024 * 1024;
 
   RawObject** ObjectAddr(intptr_t index) const {
     // TODO(iposva): Determine if we should throw an exception here.
     ASSERT((index >= 0) && (index < Length()));
     return &raw_ptr()->data()[index];
   }
 
-  void SetLength(intptr_t value) {
+  void SetLength(intptr_t value) const {
     // This is only safe because we create a new Smi, which does not cause
     // heap allocation.
     raw_ptr()->length_ = Smi::New(value);
   }
 
   HEAP_OBJECT_IMPLEMENTATION(Array, Instance);
   friend class Class;
 };
 
 
@@ skipping 188 matching lines @@
 
   template<typename T>
   T* Addr(intptr_t byte_offset) const {
     intptr_t limit = byte_offset + sizeof(T);
     // TODO(iposva): Determine if we should throw an exception here.
     ASSERT((byte_offset >= 0) && (limit <= Length()));
     uint8_t* addr = &raw_ptr()->data()[byte_offset];
     return reinterpret_cast<T*>(addr);
   }
 
-  void SetLength(intptr_t value) {
+  void SetLength(intptr_t value) const {
     raw_ptr()->length_ = Smi::New(value);
   }
 
   HEAP_OBJECT_IMPLEMENTATION(InternalByteArray, ByteArray);
   friend class Class;
 };
 
 
 class ExternalByteArray : public ByteArray {
  public:
@@ skipping 49 matching lines @@
 
   template<typename T>
   T* Addr(intptr_t byte_offset) const {
     intptr_t limit = byte_offset + sizeof(T);
     // TODO(iposva): Determine if we should throw an exception here.
     ASSERT((byte_offset >= 0) && (limit <= Length()));
     uint8_t* addr = &raw_ptr()->external_data_->data()[byte_offset];
     return reinterpret_cast<T*>(addr);
   }
 
-  void SetLength(intptr_t value) {
+  void SetLength(intptr_t value) const {
     raw_ptr()->length_ = Smi::New(value);
   }
 
-  void SetExternalData(ExternalByteArrayData* data) {
+  void SetExternalData(ExternalByteArrayData* data) const {
     raw_ptr()->external_data_ = data;
   }
 
   static void Finalize(Dart_Handle handle, void* peer);
 
   HEAP_OBJECT_IMPLEMENTATION(ExternalByteArray, ByteArray);
   friend class Class;
 };
 
 
@@ skipping 127 matching lines @@
   static intptr_t InstanceSize(intptr_t len) {
     return RoundedAllocationSize(sizeof(RawJSRegExp) + len);
   }
 
   static RawJSRegExp* New(intptr_t length, Heap::Space space = Heap::kNew);
 
  private:
   void set_type(RegExType type) const { raw_ptr()->type_ = type; }
   void set_flags(intptr_t value) const { raw_ptr()->flags_ = value; }
 
-  void SetLength(intptr_t value) {
+  void SetLength(intptr_t value) const {
     // This is only safe because we create a new Smi, which does not cause
     // heap allocation.
     raw_ptr()->data_length_ = Smi::New(value);
   }
 
   HEAP_OBJECT_IMPLEMENTATION(JSRegExp, Instance);
   friend class Class;
 };
 
 
@@ skipping 74 matching lines @@
 }
 
 
 intptr_t Stackmap::SizeInBits() const {
   return (Smi::Value(raw_ptr()->bitmap_size_in_bytes_) * kBitsPerByte);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_