Replace ASSERT, RELEASE_ASSERT, and ASSERT_NOT_REACHED in bindings

third_party/WebKit/Source/bindings/core/v8/V8GCController.cpp

 /*
  * Copyright (C) 2009 Google Inc. 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
@@ skipping 39 matching lines @@
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/wtf/Vector.h"
 #include "platform/wtf/allocator/Partitions.h"
 #include "public/platform/BlameContext.h"
 #include "public/platform/Platform.h"
 
 namespace blink {
 
 Node* V8GCController::OpaqueRootForGC(v8::Isolate*, Node* node) {
-  ASSERT(node);
+  DCHECK(node);
   if (node->isConnected()) {
     Document& document = node->GetDocument();
     if (HTMLImportsController* controller = document.ImportsController())
       return controller->Master();
     return &document;
   }
 
   if (node->IsAttributeNode()) {
     Node* owner_element = ToAttr(node)->ownerElement();
     if (!owner_element)
@@ skipping 21 matching lines @@
 
     // MinorGC does not collect objects because it may be expensive to
     // update references during minorGC
     if (class_id == WrapperTypeInfo::kObjectClassId) {
       v8::Persistent<v8::Object>::Cast(*value).MarkActive();
       return;
     }
 
     v8::Local<v8::Object> wrapper = v8::Local<v8::Object>::New(
         isolate_, v8::Persistent<v8::Object>::Cast(*value));
-    ASSERT(V8DOMWrapper::HasInternalFieldsSet(wrapper));
+    DCHECK(V8DOMWrapper::HasInternalFieldsSet(wrapper));
     if (ToWrapperTypeInfo(wrapper)->IsActiveScriptWrappable() &&
         ToScriptWrappable(wrapper)->HasPendingActivity()) {
       v8::Persistent<v8::Object>::Cast(*value).MarkActive();
       return;
     }
 
     if (class_id == WrapperTypeInfo::kNodeClassId) {
-      ASSERT(V8Node::hasInstance(wrapper, isolate_));
+      DCHECK(V8Node::hasInstance(wrapper, isolate_));
       Node* node = V8Node::toImpl(wrapper);
       if (node->HasEventListeners()) {
         v8::Persistent<v8::Object>::Cast(*value).MarkActive();
         return;
       }
       // FIXME: Remove the special handling for SVG elements.
       // We currently can't collect SVG Elements from minor gc, as we have
       // strong references from SVG property tear-offs keeping context SVG
       // element alive.
       if (node->IsSVGElement()) {
@@ skipping 217 matching lines @@
       TRACE_EVENT_BEGIN2("devtools.timeline,v8", "MajorGC",
                          "usedHeapSizeBefore", UsedHeapSize(isolate), "type",
                          "incremental marking");
       break;
     case v8::kGCTypeProcessWeakCallbacks:
       TRACE_EVENT_BEGIN2("devtools.timeline,v8", "MajorGC",
                          "usedHeapSizeBefore", UsedHeapSize(isolate), "type",
                          "weak processing");
       break;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
 }
 
 namespace {
 
 void UpdateCollectedPhantomHandles(v8::Isolate* isolate) {
   ThreadHeapStats& heap_stats = ThreadState::Current()->Heap().HeapStats();
   size_t count = isolate->NumberOfPhantomHandleResetsSinceLastCall();
   heap_stats.DecreaseWrapperCount(count);
   heap_stats.IncreaseCollectedWrapperCount(count);
@@ skipping 23 matching lines @@
       break;
     case v8::kGCTypeIncrementalMarking:
       TRACE_EVENT_END1("devtools.timeline,v8", "MajorGC", "usedHeapSizeAfter",
                        UsedHeapSize(isolate));
       break;
     case v8::kGCTypeProcessWeakCallbacks:
       TRACE_EVENT_END1("devtools.timeline,v8", "MajorGC", "usedHeapSizeAfter",
                        UsedHeapSize(isolate));
       break;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
 
   if (IsMainThread())
     ScriptForbiddenScope::Exit();
 
   if (BlameContext* blame_context =
           Platform::Current()->GetTopLevelBlameContext())
     blame_context->Leave();
 
   ThreadState* current_thread_state = ThreadState::Current();
@@ skipping 14 matching lines @@
       // Regarding (1), we force a precise GC at the end of the current event
       // loop. So if you want to collect all garbage, you need to wait until the
       // next event loop.  Regarding (2), it would be OK in practice to trigger
       // only one GC per gcEpilogue, because GCController.collectAll() forces
       // multiple V8's GC.
       current_thread_state->CollectGarbage(BlinkGC::kHeapPointersOnStack,
                                            BlinkGC::kGCWithSweep,
                                            BlinkGC::kForcedGC);
 
       // Forces a precise GC at the end of the current event loop.
-      RELEASE_ASSERT(!current_thread_state->IsInGC());
+      CHECK(!current_thread_state->IsInGC());
       current_thread_state->SetGCState(ThreadState::kFullGCScheduled);
     }
 
     // v8::kGCCallbackFlagCollectAllAvailableGarbage is used when V8 handles
     // low memory notifications.
     if ((flags & v8::kGCCallbackFlagCollectAllAvailableGarbage) ||
         (flags & v8::kGCCallbackFlagCollectAllExternalMemory)) {
       // This single GC is not enough. See the above comment.
       current_thread_state->CollectGarbage(BlinkGC::kHeapPointersOnStack,
                                            BlinkGC::kGCWithSweep,
@@ skipping 72 matching lines @@
     // we don't need to check other wrappers.
     if (pending_activity_found_)
       return;
 
     if (class_id != WrapperTypeInfo::kNodeClassId &&
         class_id != WrapperTypeInfo::kObjectClassId)
       return;
 
     v8::Local<v8::Object> wrapper = v8::Local<v8::Object>::New(
         isolate_, v8::Persistent<v8::Object>::Cast(*value));
-    ASSERT(V8DOMWrapper::HasInternalFieldsSet(wrapper));
+    DCHECK(V8DOMWrapper::HasInternalFieldsSet(wrapper));
     // The ExecutionContext check is heavy, so it should be done at the last.
     if (ToWrapperTypeInfo(wrapper)->IsActiveScriptWrappable() &&
         ToScriptWrappable(wrapper)->HasPendingActivity()) {
       // See the comment in MajorGCWrapperVisitor::VisitPersistentHandle.
       ExecutionContext* context =
           ToExecutionContext(wrapper->CreationContext());
       if (context == execution_context_ && context &&
           !context->IsContextDestroyed())
         pending_activity_found_ = true;
     }
   }
 
   bool PendingActivityFound() const { return pending_activity_found_; }
 
  private:
   v8::Isolate* isolate_;
   Persistent<ExecutionContext> execution_context_;
   bool pending_activity_found_;
 };
 
 bool V8GCController::HasPendingActivity(v8::Isolate* isolate,
                                         ExecutionContext* execution_context) {
   // V8GCController::hasPendingActivity is used only when a worker checks if
   // the worker contains any wrapper that has pending activities.
-  ASSERT(!IsMainThread());
+  DCHECK(!IsMainThread());
 
   DEFINE_THREAD_SAFE_STATIC_LOCAL(
       CustomCountHistogram, scan_pending_activity_histogram,
       new CustomCountHistogram("Blink.ScanPendingActivityDuration", 1, 1000,
                                50));
   double start_time = WTF::CurrentTimeMS();
   v8::HandleScope scope(isolate);
   PendingActivityVisitor visitor(isolate, execution_context);
   ToIsolate(execution_context)->VisitHandlesWithClassIds(&visitor);
   scan_pending_activity_histogram.Count(
       static_cast<int>(WTF::CurrentTimeMS() - start_time));
   return visitor.PendingActivityFound();
 }
 
 }  // namespace blink