Rename ASSERT* to DCHECK*.

src/unique.h

 // Copyright 2013 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_HYDROGEN_UNIQUE_H_
 #define V8_HYDROGEN_UNIQUE_H_
 
 #include "src/handles.h"
 #include "src/objects.h"
 #include "src/string-stream.h"
@@ skipping 25 matching lines @@
   explicit Unique(Handle<T> handle) {
     if (handle.is_null()) {
       raw_address_ = NULL;
     } else {
       // This is a best-effort check to prevent comparing Unique<T>'s created
       // in different GC eras; we require heap allocation to be disallowed at
       // creation time.
       // NOTE: we currently consider maps to be non-movable, so no special
       // assurance is required for creating a Unique<Map>.
       // TODO(titzer): other immortable immovable objects are also fine.
-      ASSERT(!AllowHeapAllocation::IsAllowed() || handle->IsMap());
+      DCHECK(!AllowHeapAllocation::IsAllowed() || handle->IsMap());
       raw_address_ = reinterpret_cast<Address>(*handle);
-      ASSERT_NE(raw_address_, NULL);  // Non-null should imply non-zero address.
+      DCHECK_NE(raw_address_, NULL);  // Non-null should imply non-zero address.
     }
     handle_ = handle;
   }
 
   // TODO(titzer): this is a hack to migrate to Unique<T> incrementally.
   Unique(Address raw_address, Handle<T> handle)
     : raw_address_(raw_address), handle_(handle) { }
 
   // Constructor for handling automatic up casting.
   // Eg. Unique<JSFunction> can be passed when Unique<Object> is expected.
   template <class S> Unique(Unique<S> uniq) {
 #ifdef DEBUG
     T* a = NULL;
     S* b = NULL;
     a = b;  // Fake assignment to enforce type checks.
     USE(a);
 #endif
     raw_address_ = uniq.raw_address_;
     handle_ = uniq.handle_;
   }
 
   template <typename U>
   inline bool operator==(const Unique<U>& other) const {
-    ASSERT(IsInitialized() && other.IsInitialized());
+    DCHECK(IsInitialized() && other.IsInitialized());
     return raw_address_ == other.raw_address_;
   }
 
   template <typename U>
   inline bool operator!=(const Unique<U>& other) const {
-    ASSERT(IsInitialized() && other.IsInitialized());
+    DCHECK(IsInitialized() && other.IsInitialized());
     return raw_address_ != other.raw_address_;
   }
 
   inline intptr_t Hashcode() const {
-    ASSERT(IsInitialized());
+    DCHECK(IsInitialized());
     return reinterpret_cast<intptr_t>(raw_address_);
   }
 
   inline bool IsNull() const {
-    ASSERT(IsInitialized());
+    DCHECK(IsInitialized());
     return raw_address_ == NULL;
   }
 
   inline bool IsKnownGlobal(void* global) const {
-    ASSERT(IsInitialized());
+    DCHECK(IsInitialized());
     return raw_address_ == reinterpret_cast<Address>(global);
   }
 
   inline Handle<T> handle() const {
     return handle_;
   }
 
   template <class S> static Unique<T> cast(Unique<S> that) {
     return Unique<T>(that.raw_address_, Handle<T>::cast(that.handle_));
   }
@@ skipping 94 matching lines @@
 template <typename T>
 class UniqueSet V8_FINAL : public ZoneObject {
  public:
   // Constructor. A new set will be empty.
   UniqueSet() : size_(0), capacity_(0), array_(NULL) { }
 
   // Capacity constructor. A new set will be empty.
   UniqueSet(int capacity, Zone* zone)
       : size_(0), capacity_(capacity),
         array_(zone->NewArray<Unique<T> >(capacity)) {
-    ASSERT(capacity <= kMaxCapacity);
+    DCHECK(capacity <= kMaxCapacity);
   }
 
   // Singleton constructor.
   UniqueSet(Unique<T> uniq, Zone* zone)
       : size_(1), capacity_(1), array_(zone->NewArray<Unique<T> >(1)) {
     array_[0] = uniq;
   }
 
   // Add a new element to this unique set. Mutates this set. O(|this|).
   void Add(Unique<T> uniq, Zone* zone) {
-    ASSERT(uniq.IsInitialized());
+    DCHECK(uniq.IsInitialized());
     // Keep the set sorted by the {raw_address} of the unique elements.
     for (int i = 0; i < size_; i++) {
       if (array_[i] == uniq) return;
       if (array_[i].raw_address_ > uniq.raw_address_) {
         // Insert in the middle.
         Grow(size_ + 1, zone);
         for (int j = size_ - 1; j >= i; j--) array_[j + 1] = array_[j];
         array_[i] = uniq;
         size_++;
         return;
@@ skipping 142 matching lines @@
 
   void Clear() {
     size_ = 0;
   }
 
   inline int size() const {
     return size_;
   }
 
   inline Unique<T> at(int index) const {
-    ASSERT(index >= 0 && index < size_);
+    DCHECK(index >= 0 && index < size_);
     return array_[index];
   }
 
  private:
   // These sets should be small, since operations are implemented with simple
   // linear algorithms. Enforce a maximum size.
   static const int kMaxCapacity = 65535;
 
   uint16_t size_;
   uint16_t capacity_;
@@ skipping 11 matching lines @@
       }
       capacity_ = new_capacity;
       array_ = new_array;
     }
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_UNIQUE_H_