Rename ASSERT* to DCHECK*.

src/d8.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.
 
 
 // Defined when linking against shared lib on Windows.
 #if defined(USING_V8_SHARED) && !defined(V8_SHARED)
 #define V8_SHARED
 #endif
 
@@ skipping 37 matching lines @@
 #include "src/d8-debug.h"
 #include "src/debug.h"
 #include "src/natives.h"
 #include "src/v8.h"
 #endif  // !V8_SHARED
 
 #if !defined(_WIN32) && !defined(_WIN64)
 #include <unistd.h>  // NOLINT
 #endif
 
-#ifndef ASSERT
-#define ASSERT(condition) assert(condition)
+#ifndef DCHECK
+#define DCHECK(condition) assert(condition)
 #endif
 
 namespace v8 {
 
 
 static Handle<Value> Throw(Isolate* isolate, const char* message) {
   return isolate->ThrowException(String::NewFromUtf8(isolate, message));
 }
 
 
@@ skipping 109 matching lines @@
   Local<UnboundScript> script =
       ScriptCompiler::CompileUnbound(isolate, &script_source, compile_options);
 
   // Was caching requested & successful? Then compile again, now with cache.
   if (script_source.GetCachedData()) {
     if (compile_options == ScriptCompiler::kProduceCodeCache) {
       compile_options = ScriptCompiler::kConsumeCodeCache;
     } else if (compile_options == ScriptCompiler::kProduceParserCache) {
       compile_options = ScriptCompiler::kConsumeParserCache;
     } else {
-      ASSERT(false);  // A new compile option?
+      DCHECK(false);  // A new compile option?
     }
     ScriptCompiler::Source cached_source(
         source, origin, new v8::ScriptCompiler::CachedData(
                             script_source.GetCachedData()->data,
                             script_source.GetCachedData()->length,
                             v8::ScriptCompiler::CachedData::BufferNotOwned));
     script = ScriptCompiler::CompileUnbound(isolate, &cached_source,
                                             compile_options);
   }
   return script;
@@ skipping 28 matching lines @@
     return false;
   } else {
     PerIsolateData* data = PerIsolateData::Get(isolate);
     Local<Context> realm =
         Local<Context>::New(isolate, data->realms_[data->realm_current_]);
     realm->Enter();
     Handle<Value> result = script->BindToCurrentContext()->Run();
     realm->Exit();
     data->realm_current_ = data->realm_switch_;
     if (result.IsEmpty()) {
-      ASSERT(try_catch.HasCaught());
+      DCHECK(try_catch.HasCaught());
       // Print errors that happened during execution.
       if (report_exceptions && !FLAG_debugger)
         ReportException(isolate, &try_catch);
       return false;
     } else {
-      ASSERT(!try_catch.HasCaught());
+      DCHECK(!try_catch.HasCaught());
       if (print_result) {
 #if !defined(V8_SHARED)
         if (options.test_shell) {
 #endif
           if (!result->IsUndefined()) {
             // If all went well and the result wasn't undefined then print
             // the returned value.
             v8::String::Utf8Value str(result);
             fwrite(*str, sizeof(**str), str.length(), stdout);
             printf("\n");
@@ skipping 485 matching lines @@
 Counter* Shell::GetCounter(const char* name, bool is_histogram) {
   Counter* counter = counter_map_->Lookup(name);
 
   if (counter == NULL) {
     counter = counters_->GetNextCounter();
     if (counter != NULL) {
       counter_map_->Set(name, counter);
       counter->Bind(name, is_histogram);
     }
   } else {
-    ASSERT(counter->is_histogram() == is_histogram);
+    DCHECK(counter->is_histogram() == is_histogram);
   }
   return counter;
 }
 
 
 int* Shell::LookupCounter(const char* name) {
   Counter* counter = GetCounter(name, false);
 
   if (counter != NULL) {
     return counter->ptr();
@@ skipping 75 matching lines @@
 #ifdef COMPRESS_STARTUP_DATA_BZ2
 class BZip2Decompressor : public v8::StartupDataDecompressor {
  public:
   virtual ~BZip2Decompressor() { }
 
  protected:
   virtual int DecompressData(char* raw_data,
                              int* raw_data_size,
                              const char* compressed_data,
                              int compressed_data_size) {
-    ASSERT_EQ(v8::StartupData::kBZip2,
+    DCHECK_EQ(v8::StartupData::kBZip2,
               v8::V8::GetCompressedStartupDataAlgorithm());
     unsigned int decompressed_size = *raw_data_size;
     int result =
         BZ2_bzBuffToBuffDecompress(raw_data,
                                    &decompressed_size,
                                    const_cast<char*>(compressed_data),
                                    compressed_data_size,
                                    0, 1);
     if (result == BZ_OK) {
       *raw_data_size = decompressed_size;
@@ skipping 96 matching lines @@
 
 Local<Context> Shell::CreateEvaluationContext(Isolate* isolate) {
 #ifndef V8_SHARED
   // This needs to be a critical section since this is not thread-safe
   base::LockGuard<base::Mutex> lock_guard(&context_mutex_);
 #endif  // !V8_SHARED
   // Initialize the global objects
   Handle<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
   EscapableHandleScope handle_scope(isolate);
   Local<Context> context = Context::New(isolate, NULL, global_template);
-  ASSERT(!context.IsEmpty());
+  DCHECK(!context.IsEmpty());
   Context::Scope scope(context);
 
 #ifndef V8_SHARED
   i::Factory* factory = reinterpret_cast<i::Isolate*>(isolate)->factory();
   i::JSArguments js_args = i::FLAG_js_arguments;
   i::Handle<i::FixedArray> arguments_array =
       factory->NewFixedArray(js_args.argc);
   for (int j = 0; j < js_args.argc; j++) {
     i::Handle<i::String> arg =
         factory->NewStringFromUtf8(i::CStrVector(js_args[j])).ToHandleChecked();
@@ skipping 126 matching lines @@
   data.GetIsolate()->AdjustAmountOfExternalAllocatedMemory(
       -static_cast<intptr_t>(byte_length));
 
   delete[] data.GetParameter()->data;
   data.GetParameter()->handle.Reset();
   delete data.GetParameter();
 }
 
 
 void Shell::ReadBuffer(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  ASSERT(sizeof(char) == sizeof(uint8_t));  // NOLINT
+  DCHECK(sizeof(char) == sizeof(uint8_t));  // NOLINT
   String::Utf8Value filename(args[0]);
   int length;
   if (*filename == NULL) {
     Throw(args.GetIsolate(), "Error loading file");
     return;
   }
 
   Isolate* isolate = args.GetIsolate();
   DataAndPersistent* data = new DataAndPersistent;
   data->data = reinterpret_cast<uint8_t*>(
@@ skipping 570 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif