Rename ASSERT* to DCHECK*.

src/global-handles.h

 // Copyright 2011 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_GLOBAL_HANDLES_H_
 #define V8_GLOBAL_HANDLES_H_
 
 #include "include/v8.h"
 #include "include/v8-profiler.h"
 
@@ skipping 19 matching lines @@
 // the group is alive, all objects in the same group are considered alive.
 // An object group is used to simulate object relationship in a DOM tree.
 
 // An implicit references group consists of two parts: a parent object and a
 // list of children objects.  If the parent is alive, all the children are alive
 // too.
 
 struct ObjectGroup {
   explicit ObjectGroup(size_t length)
       : info(NULL), length(length) {
-    ASSERT(length > 0);
+    DCHECK(length > 0);
     objects = new Object**[length];
   }
   ~ObjectGroup();
 
   v8::RetainedObjectInfo* info;
   Object*** objects;
   size_t length;
 };
 
 
 struct ImplicitRefGroup {
   ImplicitRefGroup(HeapObject** parent, size_t length)
       : parent(parent), length(length) {
-    ASSERT(length > 0);
+    DCHECK(length > 0);
     children = new Object**[length];
   }
   ~ImplicitRefGroup();
 
   HeapObject** parent;
   Object*** children;
   size_t length;
 };
 
 
@@ skipping 263 matching lines @@
   // Create an EternalHandle, overwriting the index.
   void Create(Isolate* isolate, Object* object, int* index);
 
   // Grab the handle for an existing EternalHandle.
   inline Handle<Object> Get(int index) {
     return Handle<Object>(GetLocation(index));
   }
 
   // Grab the handle for an existing SingletonHandle.
   inline Handle<Object> GetSingleton(SingletonHandle singleton) {
-    ASSERT(Exists(singleton));
+    DCHECK(Exists(singleton));
     return Get(singleton_handles_[singleton]);
   }
 
   // Checks whether a SingletonHandle has been assigned.
   inline bool Exists(SingletonHandle singleton) {
     return singleton_handles_[singleton] != kInvalidIndex;
   }
 
   // Assign a SingletonHandle to an empty slot and returns the handle.
   Handle<Object> CreateSingleton(Isolate* isolate,
@@ skipping 11 matching lines @@
   void PostGarbageCollectionProcessing(Heap* heap);
 
  private:
   static const int kInvalidIndex = -1;
   static const int kShift = 8;
   static const int kSize = 1 << kShift;
   static const int kMask = 0xff;
 
   // Gets the slot for an index
   inline Object** GetLocation(int index) {
-    ASSERT(index >= 0 && index < size_);
+    DCHECK(index >= 0 && index < size_);
     return &blocks_[index >> kShift][index & kMask];
   }
 
   int size_;
   List<Object**> blocks_;
   List<int> new_space_indices_;
   int singleton_handles_[NUMBER_OF_SINGLETON_HANDLES];
 
   DISALLOW_COPY_AND_ASSIGN(EternalHandles);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_GLOBAL_HANDLES_H_