Rename ASSERT* to DCHECK*.

src/base/platform/platform-linux.cc

 // 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.
 
 // Platform-specific code for Linux goes here. For the POSIX-compatible
 // parts, the implementation is in platform-posix.cc.
 
 #include <pthread.h>
 #include <semaphore.h>
 #include <signal.h>
@@ skipping 254 matching lines @@
 #if defined(__native_client__)
                     // The Native Client port of V8 uses an interpreter,
                     // so code pages don't need PROT_EXEC.
                     PROT_READ,
 #else
                     PROT_READ | PROT_EXEC,
 #endif
                     MAP_PRIVATE,
                     fileno(f),
                     0);
-  ASSERT(addr != MAP_FAILED);
+  DCHECK(addr != MAP_FAILED);
   OS::Free(addr, size);
   fclose(f);
 }
 
 
 // Constants used for mmap.
 static const int kMmapFd = -1;
 static const int kMmapFdOffset = 0;
 
 
 VirtualMemory::VirtualMemory() : address_(NULL), size_(0) { }
 
 
 VirtualMemory::VirtualMemory(size_t size)
     : address_(ReserveRegion(size)), size_(size) { }
 
 
 VirtualMemory::VirtualMemory(size_t size, size_t alignment)
     : address_(NULL), size_(0) {
-  ASSERT(IsAligned(alignment, static_cast<intptr_t>(OS::AllocateAlignment())));
+  DCHECK(IsAligned(alignment, static_cast<intptr_t>(OS::AllocateAlignment())));
   size_t request_size = RoundUp(size + alignment,
                                 static_cast<intptr_t>(OS::AllocateAlignment()));
   void* reservation = mmap(OS::GetRandomMmapAddr(),
                            request_size,
                            PROT_NONE,
                            MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE,
                            kMmapFd,
                            kMmapFdOffset);
   if (reservation == MAP_FAILED) return;
 
   uint8_t* base = static_cast<uint8_t*>(reservation);
   uint8_t* aligned_base = RoundUp(base, alignment);
-  ASSERT_LE(base, aligned_base);
+  DCHECK_LE(base, aligned_base);
 
   // Unmap extra memory reserved before and after the desired block.
   if (aligned_base != base) {
     size_t prefix_size = static_cast<size_t>(aligned_base - base);
     OS::Free(base, prefix_size);
     request_size -= prefix_size;
   }
 
   size_t aligned_size = RoundUp(size, OS::AllocateAlignment());
-  ASSERT_LE(aligned_size, request_size);
+  DCHECK_LE(aligned_size, request_size);
 
   if (aligned_size != request_size) {
     size_t suffix_size = request_size - aligned_size;
     OS::Free(aligned_base + aligned_size, suffix_size);
     request_size -= suffix_size;
   }
 
-  ASSERT(aligned_size == request_size);
+  DCHECK(aligned_size == request_size);
 
   address_ = static_cast<void*>(aligned_base);
   size_ = aligned_size;
 #if defined(LEAK_SANITIZER)
   __lsan_register_root_region(address_, size_);
 #endif
 }
 
 
 VirtualMemory::~VirtualMemory() {
   if (IsReserved()) {
     bool result = ReleaseRegion(address(), size());
-    ASSERT(result);
+    DCHECK(result);
     USE(result);
   }
 }
 
 
 bool VirtualMemory::IsReserved() {
   return address_ != NULL;
 }
 
 
@@ skipping 73 matching lines @@
 #endif
   return munmap(base, size) == 0;
 }
 
 
 bool VirtualMemory::HasLazyCommits() {
   return true;
 }
 
 } }  // namespace v8::base