Rename ASSERT* to DCHECK*.

src/objects-visiting.h

 // Copyright 2012 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.
 
 #ifndef V8_OBJECTS_VISITING_H_
 #define V8_OBJECTS_VISITING_H_
 
 #include "src/allocation.h"
 
 // This file provides base classes and auxiliary methods for defining
@@ skipping 97 matching lines @@
 
   static VisitorId GetVisitorId(Map* map) {
     return GetVisitorId(map->instance_type(), map->instance_size());
   }
 
   // For visitors that allow specialization by size calculate VisitorId based
   // on size, base visitor id and generic visitor id.
   static VisitorId GetVisitorIdForSize(VisitorId base,
                                        VisitorId generic,
                                        int object_size) {
-    ASSERT((base == kVisitDataObject) ||
+    DCHECK((base == kVisitDataObject) ||
            (base == kVisitStruct) ||
            (base == kVisitJSObject));
-    ASSERT(IsAligned(object_size, kPointerSize));
-    ASSERT(kMinObjectSizeInWords * kPointerSize <= object_size);
-    ASSERT(object_size <= Page::kMaxRegularHeapObjectSize);
+    DCHECK(IsAligned(object_size, kPointerSize));
+    DCHECK(kMinObjectSizeInWords * kPointerSize <= object_size);
+    DCHECK(object_size <= Page::kMaxRegularHeapObjectSize);
 
     const VisitorId specialization = static_cast<VisitorId>(
         base + (object_size >> kPointerSizeLog2) - kMinObjectSizeInWords);
 
     return Min(specialization, generic);
   }
 };
 
 
 template<typename Callback>
@@ skipping 10 matching lines @@
 
   inline Callback GetVisitorById(StaticVisitorBase::VisitorId id) {
     return reinterpret_cast<Callback>(callbacks_[id]);
   }
 
   inline Callback GetVisitor(Map* map) {
     return reinterpret_cast<Callback>(callbacks_[map->visitor_id()]);
   }
 
   void Register(StaticVisitorBase::VisitorId id, Callback callback) {
-    ASSERT(id < StaticVisitorBase::kVisitorIdCount);  // id is unsigned.
+    DCHECK(id < StaticVisitorBase::kVisitorIdCount);  // id is unsigned.
     callbacks_[id] = reinterpret_cast<base::AtomicWord>(callback);
   }
 
   template<typename Visitor,
            StaticVisitorBase::VisitorId base,
            StaticVisitorBase::VisitorId generic,
            int object_size_in_words>
   void RegisterSpecialization() {
     static const int size = object_size_in_words * kPointerSize;
     Register(StaticVisitorBase::GetVisitorIdForSize(base, generic, size),
@@ skipping 47 matching lines @@
     BodyVisitorBase<StaticVisitor>::IteratePointers(
         map->GetHeap(),
         object,
         BodyDescriptor::kStartOffset,
         object_size);
     return static_cast<ReturnType>(object_size);
   }
 
   template<int object_size>
   static inline ReturnType VisitSpecialized(Map* map, HeapObject* object) {
-    ASSERT(BodyDescriptor::SizeOf(map, object) == object_size);
+    DCHECK(BodyDescriptor::SizeOf(map, object) == object_size);
     BodyVisitorBase<StaticVisitor>::IteratePointers(
         map->GetHeap(),
         object,
         BodyDescriptor::kStartOffset,
         object_size);
     return static_cast<ReturnType>(object_size);
   }
 };
 
 
@@ skipping 234 matching lines @@
 // the next element. Given the head of the list, this function removes dead
 // elements from the list and if requested records slots for next-element
 // pointers. The template parameter T is a WeakListVisitor that defines how to
 // access the next-element pointers.
 template <class T>
 Object* VisitWeakList(Heap* heap, Object* list, WeakObjectRetainer* retainer);
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_VISITING_H_