Rename ASSERT* to DCHECK*.

src/base/platform/platform-win32.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 Win32.
 
 // Secure API functions are not available using MinGW with msvcrt.dll
 // on Windows XP. Make sure MINGW_HAS_SECURE_API is not defined to
 // disable definition of secure API functions in standard headers that
 // would conflict with our own implementation.
@@ skipping 53 matching lines @@
 }
 
 
 int fopen_s(FILE** pFile, const char* filename, const char* mode) {
   *pFile = fopen(filename, mode);
   return *pFile != NULL ? 0 : 1;
 }
 
 int _vsnprintf_s(char* buffer, size_t sizeOfBuffer, size_t count,
                  const char* format, va_list argptr) {
-  ASSERT(count == _TRUNCATE);
+  DCHECK(count == _TRUNCATE);
   return _vsnprintf(buffer, sizeOfBuffer, format, argptr);
 }
 
 
 int strncpy_s(char* dest, size_t dest_size, const char* source, size_t count) {
   CHECK(source != NULL);
   CHECK(dest != NULL);
   CHECK_GT(dest_size, 0);
 
   if (count == _TRUNCATE) {
@@ skipping 597 matching lines @@
 }
 
 
 void OS::StrNCpy(char* dest, int length, const char* src, size_t n) {
   // Use _TRUNCATE or strncpy_s crashes (by design) if buffer is too small.
   size_t buffer_size = static_cast<size_t>(length);
   if (n + 1 > buffer_size)  // count for trailing '\0'
     n = _TRUNCATE;
   int result = strncpy_s(dest, length, src, n);
   USE(result);
-  ASSERT(result == 0 || (n == _TRUNCATE && result == STRUNCATE));
+  DCHECK(result == 0 || (n == _TRUNCATE && result == STRUNCATE));
 }
 
 
 #undef _TRUNCATE
 #undef STRUNCATE
 
 
 // Get the system's page size used by VirtualAlloc() or the next power
 // of two. The reason for always returning a power of two is that the
 // rounding up in OS::Allocate expects that.
@@ skipping 80 matching lines @@
 
   // Windows XP SP2 allows Data Excution Prevention (DEP).
   int prot = is_executable ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
 
   LPVOID mbase = RandomizedVirtualAlloc(msize,
                                         MEM_COMMIT | MEM_RESERVE,
                                         prot);
 
   if (mbase == NULL) return NULL;
 
-  ASSERT(IsAligned(reinterpret_cast<size_t>(mbase), OS::AllocateAlignment()));
+  DCHECK(IsAligned(reinterpret_cast<size_t>(mbase), OS::AllocateAlignment()));
 
   *allocated = msize;
   return mbase;
 }
 
 
 void OS::Free(void* address, const size_t size) {
   // TODO(1240712): VirtualFree has a return value which is ignored here.
   VirtualFree(address, 0, MEM_RELEASE);
   USE(size);
@@ skipping 417 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* address = ReserveRegion(request_size);
   if (address == NULL) return;
   uint8_t* base = RoundUp(static_cast<uint8_t*>(address), alignment);
   // Try reducing the size by freeing and then reallocating a specific area.
   bool result = ReleaseRegion(address, request_size);
   USE(result);
-  ASSERT(result);
+  DCHECK(result);
   address = VirtualAlloc(base, size, MEM_RESERVE, PAGE_NOACCESS);
   if (address != NULL) {
     request_size = size;
-    ASSERT(base == static_cast<uint8_t*>(address));
+    DCHECK(base == static_cast<uint8_t*>(address));
   } else {
     // Resizing failed, just go with a bigger area.
     address = ReserveRegion(request_size);
     if (address == NULL) return;
   }
   address_ = address;
   size_ = request_size;
 }
 
 
 VirtualMemory::~VirtualMemory() {
   if (IsReserved()) {
     bool result = ReleaseRegion(address(), size());
-    ASSERT(result);
+    DCHECK(result);
     USE(result);
   }
 }
 
 
 bool VirtualMemory::IsReserved() {
   return address_ != NULL;
 }
 
 
 void VirtualMemory::Reset() {
   address_ = NULL;
   size_ = 0;
 }
 
 
 bool VirtualMemory::Commit(void* address, size_t size, bool is_executable) {
   return CommitRegion(address, size, is_executable);
 }
 
 
 bool VirtualMemory::Uncommit(void* address, size_t size) {
-  ASSERT(IsReserved());
+  DCHECK(IsReserved());
   return UncommitRegion(address, size);
 }
 
 
 bool VirtualMemory::Guard(void* address) {
   if (NULL == VirtualAlloc(address,
                            OS::CommitPageSize(),
                            MEM_COMMIT,
                            PAGE_NOACCESS)) {
     return false;
@@ skipping 98 matching lines @@
 // Wait for thread to terminate.
 void Thread::Join() {
   if (data_->thread_id_ != GetCurrentThreadId()) {
     WaitForSingleObject(data_->thread_, INFINITE);
   }
 }
 
 
 Thread::LocalStorageKey Thread::CreateThreadLocalKey() {
   DWORD result = TlsAlloc();
-  ASSERT(result != TLS_OUT_OF_INDEXES);
+  DCHECK(result != TLS_OUT_OF_INDEXES);
   return static_cast<LocalStorageKey>(result);
 }
 
 
 void Thread::DeleteThreadLocalKey(LocalStorageKey key) {
   BOOL result = TlsFree(static_cast<DWORD>(key));
   USE(result);
-  ASSERT(result);
+  DCHECK(result);
 }
 
 
 void* Thread::GetThreadLocal(LocalStorageKey key) {
   return TlsGetValue(static_cast<DWORD>(key));
 }
 
 
 void Thread::SetThreadLocal(LocalStorageKey key, void* value) {
   BOOL result = TlsSetValue(static_cast<DWORD>(key), value);
   USE(result);
-  ASSERT(result);
+  DCHECK(result);
 }
 
 
 
 void Thread::YieldCPU() {
   Sleep(0);
 }
 
 } }  // namespace v8::base