Rename ASSERT* to DCHECK*.

test/cctest/test-heap-profiler.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 850 matching lines @@
   virtual void EndOfStream() { ++eos_signaled_; }
   virtual WriteResult WriteAsciiChunk(char* buffer, int chars_written) {
     if (abort_countdown_ > 0) --abort_countdown_;
     if (abort_countdown_ == 0) return kAbort;
     CHECK_GT(chars_written, 0);
     i::Vector<char> chunk = buffer_.AddBlock(chars_written, '\0');
     i::MemCopy(chunk.start(), buffer, chars_written);
     return kContinue;
   }
   virtual WriteResult WriteUint32Chunk(uint32_t* buffer, int chars_written) {
-    ASSERT(false);
+    DCHECK(false);
     return kAbort;
   }
   void WriteTo(i::Vector<char> dest) { buffer_.WriteTo(dest); }
   int eos_signaled() { return eos_signaled_; }
   int size() { return buffer_.size(); }
 
  private:
   i::Collector<char> buffer_;
   int eos_signaled_;
   int abort_countdown_;
@@ skipping 148 matching lines @@
     : v8::OutputStream(stream),
       eos_signaled_(stream.eos_signaled_),
       updates_written_(stream.updates_written_),
       entries_count_(stream.entries_count_),
       entries_size_(stream.entries_size_),
       intervals_count_(stream.intervals_count_),
       first_interval_index_(stream.first_interval_index_) { }
   virtual ~TestStatsStream() {}
   virtual void EndOfStream() { ++eos_signaled_; }
   virtual WriteResult WriteAsciiChunk(char* buffer, int chars_written) {
-    ASSERT(false);
+    DCHECK(false);
     return kAbort;
   }
   virtual WriteResult WriteHeapStatsChunk(v8::HeapStatsUpdate* buffer,
                                           int updates_written) {
     ++intervals_count_;
-    ASSERT(updates_written);
+    DCHECK(updates_written);
     updates_written_ += updates_written;
     entries_count_ = 0;
     if (first_interval_index_ == -1 && updates_written != 0)
       first_interval_index_ = buffer[0].index;
     for (int i = 0; i < updates_written; ++i) {
       entries_count_ += buffer[i].count;
       entries_size_ += buffer[i].size;
     }
 
     return kContinue;
@@ skipping 1553 matching lines @@
   v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
 
   v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(isolate, 1024);
   CHECK_EQ(1024, static_cast<int>(ab->ByteLength()));
   CHECK(!ab->IsExternal());
   v8::ArrayBuffer::Contents ab_contents = ab->Externalize();
   CHECK(ab->IsExternal());
 
   CHECK_EQ(1024, static_cast<int>(ab_contents.ByteLength()));
   void* data = ab_contents.Data();
-  ASSERT(data != NULL);
+  DCHECK(data != NULL);
   v8::Local<v8::ArrayBuffer> ab2 =
       v8::ArrayBuffer::New(isolate, data, ab_contents.ByteLength());
   CHECK(ab2->IsExternal());
   env->Global()->Set(v8_str("ab1"), ab);
   env->Global()->Set(v8_str("ab2"), ab2);
 
   v8::Handle<v8::Value> result = CompileRun("ab2.byteLength");
   CHECK_EQ(1024, result->Int32Value());
 
   const v8::HeapSnapshot* snapshot =
@@ skipping 132 matching lines @@
   map.AddRange(ToAddress(0x180), 0x80, 6U);
   map.AddRange(ToAddress(0x180), 0x80, 7U);
   CHECK_EQ(7, map.GetTraceNodeId(ToAddress(0x180)));
   CHECK_EQ(5, map.GetTraceNodeId(ToAddress(0x200)));
   CHECK_EQ(3, static_cast<int>(map.size()));
 
   map.Clear();
   CHECK_EQ(0, static_cast<int>(map.size()));
   CHECK_EQ(0, map.GetTraceNodeId(ToAddress(0x400)));
 }