Rename ASSERT* to DCHECK*.

src/hashmap.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_HASHMAP_H_
 #define V8_HASHMAP_H_
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/utils.h"
@@ skipping 146 matching lines @@
   // not break the search. If, while searching for the next empty entry, an
   // entry is encountered which does not have its initial position between the
   // entry to remove and the position looked at, then this entry can be moved to
   // the place of the entry to remove without breaking the search for it. The
   // entry made vacant by this move is now the entry to remove and the process
   // starts over.
   // Algorithm from http://en.wikipedia.org/wiki/Open_addressing.
 
   // This guarantees loop termination as there is at least one empty entry so
   // eventually the removed entry will have an empty entry after it.
-  ASSERT(occupancy_ < capacity_);
+  DCHECK(occupancy_ < capacity_);
 
   // p is the candidate entry to clear. q is used to scan forwards.
   Entry* q = p;  // Start at the entry to remove.
   while (true) {
     // Move q to the next entry.
     q = q + 1;
     if (q == map_end()) {
       q = map_;
     }
 
@@ skipping 39 matching lines @@
 typename TemplateHashMapImpl<AllocationPolicy>::Entry*
     TemplateHashMapImpl<AllocationPolicy>::Start() const {
   return Next(map_ - 1);
 }
 
 
 template<class AllocationPolicy>
 typename TemplateHashMapImpl<AllocationPolicy>::Entry*
     TemplateHashMapImpl<AllocationPolicy>::Next(Entry* p) const {
   const Entry* end = map_end();
-  ASSERT(map_ - 1 <= p && p < end);
+  DCHECK(map_ - 1 <= p && p < end);
   for (p++; p < end; p++) {
     if (p->key != NULL) {
       return p;
     }
   }
   return NULL;
 }
 
 
 template<class AllocationPolicy>
 typename TemplateHashMapImpl<AllocationPolicy>::Entry*
     TemplateHashMapImpl<AllocationPolicy>::Probe(void* key, uint32_t hash) {
-  ASSERT(key != NULL);
+  DCHECK(key != NULL);
 
-  ASSERT(IsPowerOf2(capacity_));
+  DCHECK(IsPowerOf2(capacity_));
   Entry* p = map_ + (hash & (capacity_ - 1));
   const Entry* end = map_end();
-  ASSERT(map_ <= p && p < end);
+  DCHECK(map_ <= p && p < end);
 
-  ASSERT(occupancy_ < capacity_);  // Guarantees loop termination.
+  DCHECK(occupancy_ < capacity_);  // Guarantees loop termination.
   while (p->key != NULL && (hash != p->hash || !match_(key, p->key))) {
     p++;
     if (p >= end) {
       p = map_;
     }
   }
 
   return p;
 }
 
 
 template<class AllocationPolicy>
 void TemplateHashMapImpl<AllocationPolicy>::Initialize(
     uint32_t capacity, AllocationPolicy allocator) {
-  ASSERT(IsPowerOf2(capacity));
+  DCHECK(IsPowerOf2(capacity));
   map_ = reinterpret_cast<Entry*>(allocator.New(capacity * sizeof(Entry)));
   if (map_ == NULL) {
     v8::internal::FatalProcessOutOfMemory("HashMap::Initialize");
     return;
   }
   capacity_ = capacity;
   Clear();
 }
 
 
@@ skipping 64 matching lines @@
   Iterator end() const { return Iterator(this, NULL); }
   Iterator find(Key* key, bool insert = false,
                 AllocationPolicy allocator = AllocationPolicy()) {
     return Iterator(this, this->Lookup(key, key->Hash(), insert, allocator));
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_HASHMAP_H_