Rename ASSERT* to DCHECK*.

src/base/platform/platform-macos.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 MacOS goes here. For the POSIX-compatible
 // parts, the implementation is in platform-posix.cc.
 
 #include <dlfcn.h>
 #include <mach/mach_init.h>
 #include <mach-o/dyld.h>
@@ skipping 166 matching lines @@
 
 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_ANON | 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;
 }
 
 
 VirtualMemory::~VirtualMemory() {
   if (IsReserved()) {
     bool result = ReleaseRegion(address(), size());
-    ASSERT(result);
+    DCHECK(result);
     USE(result);
   }
 }
 
 
 bool VirtualMemory::IsReserved() {
   return address_ != NULL;
 }
 
 
@@ skipping 62 matching lines @@
 bool VirtualMemory::ReleaseRegion(void* address, size_t size) {
   return munmap(address, size) == 0;
 }
 
 
 bool VirtualMemory::HasLazyCommits() {
   return false;
 }
 
 } }  // namespace v8::base