Rename ASSERT* to DCHECK*.

src/compilation-cache.cc

 // Copyright 2011 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.
 
 #include "src/v8.h"
 
 #include "src/assembler.h"
 #include "src/compilation-cache.h"
 #include "src/serialize.h"
 
@@ skipping 25 matching lines @@
   for (int i = 0; i < kSubCacheCount; ++i) {
     subcaches_[i] = subcaches[i];
   }
 }
 
 
 CompilationCache::~CompilationCache() {}
 
 
 Handle<CompilationCacheTable> CompilationSubCache::GetTable(int generation) {
-  ASSERT(generation < generations_);
+  DCHECK(generation < generations_);
   Handle<CompilationCacheTable> result;
   if (tables_[generation]->IsUndefined()) {
     result = CompilationCacheTable::New(isolate(), kInitialCacheSize);
     tables_[generation] = *result;
   } else {
     CompilationCacheTable* table =
         CompilationCacheTable::cast(tables_[generation]);
     result = Handle<CompilationCacheTable>(table, isolate());
   }
   return result;
@@ skipping 129 matching lines @@
     // The level NUMBER_OF_SCRIPT_GENERATIONS is equivalent to a cache miss.
     isolate()->stats_table()->AddHistogramSample(script_histogram_, generation);
   }
 
   // Once outside the manacles of the handle scope, we need to recheck
   // to see if we actually found a cached script. If so, we return a
   // handle created in the caller's handle scope.
   if (result != NULL) {
     Handle<SharedFunctionInfo> shared(SharedFunctionInfo::cast(result),
                                       isolate());
-    ASSERT(HasOrigin(shared,
+    DCHECK(HasOrigin(shared,
                      name,
                      line_offset,
                      column_offset,
                      is_shared_cross_origin));
     // If the script was found in a later generation, we promote it to
     // the first generation to let it survive longer in the cache.
     if (generation != 0) Put(source, context, shared);
     isolate()->counters()->compilation_cache_hits()->Increment();
     return shared;
   } else {
@@ skipping 121 matching lines @@
     Handle<Context> context,
     StrictMode strict_mode,
     int scope_position) {
   if (!IsEnabled()) return MaybeHandle<SharedFunctionInfo>();
 
   MaybeHandle<SharedFunctionInfo> result;
   if (context->IsNativeContext()) {
     result = eval_global_.Lookup(
         source, context, strict_mode, scope_position);
   } else {
-    ASSERT(scope_position != RelocInfo::kNoPosition);
+    DCHECK(scope_position != RelocInfo::kNoPosition);
     result = eval_contextual_.Lookup(
         source, context, strict_mode, scope_position);
   }
   return result;
 }
 
 
 MaybeHandle<FixedArray> CompilationCache::LookupRegExp(Handle<String> source,
                                                   JSRegExp::Flags flags) {
   if (!IsEnabled()) return MaybeHandle<FixedArray>();
@@ skipping 14 matching lines @@
 void CompilationCache::PutEval(Handle<String> source,
                                Handle<Context> context,
                                Handle<SharedFunctionInfo> function_info,
                                int scope_position) {
   if (!IsEnabled()) return;
 
   HandleScope scope(isolate());
   if (context->IsNativeContext()) {
     eval_global_.Put(source, context, function_info, scope_position);
   } else {
-    ASSERT(scope_position != RelocInfo::kNoPosition);
+    DCHECK(scope_position != RelocInfo::kNoPosition);
     eval_contextual_.Put(source, context, function_info, scope_position);
   }
 }
 
 
 
 void CompilationCache::PutRegExp(Handle<String> source,
                                  JSRegExp::Flags flags,
                                  Handle<FixedArray> data) {
   if (!IsEnabled()) {
@@ skipping 37 matching lines @@
 }
 
 
 void CompilationCache::Disable() {
   enabled_ = false;
   Clear();
 }
 
 
 } }  // namespace v8::internal