Replace ASSERT with DHCECK_op in platform/heap

third_party/WebKit/Source/platform/heap/ThreadState.h

 /*
  * Copyright (C) 2013 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 128 matching lines @@
 
    private:
     ThreadState* state_;
   };
 
   class SweepForbiddenScope final {
     STACK_ALLOCATED();
 
    public:
     explicit SweepForbiddenScope(ThreadState* state) : state_(state) {
-      ASSERT(!state_->sweep_forbidden_);
+      DCHECK(!state_->sweep_forbidden_);
       state_->sweep_forbidden_ = true;
     }
     ~SweepForbiddenScope() {
-      ASSERT(state_->sweep_forbidden_);
+      DCHECK(state_->sweep_forbidden_);
       state_->sweep_forbidden_ = false;
     }
 
    private:
     ThreadState* state_;
   };
 
   // Used to denote when access to unmarked objects is allowed but we shouldn't
   // ressurect it by making new references (e.g. during weak processing and pre
   // finalizer).
@@ skipping 187 matching lines @@
   void EnterSafePoint(BlinkGC::StackState, void*);
   void LeaveSafePoint();
 
   void RecordStackEnd(intptr_t* end_of_stack) { end_of_stack_ = end_of_stack; }
   NO_SANITIZE_ADDRESS void CopyStackUntilSafePointScope();
 
   // Get one of the heap structures for this thread.
   // The thread heap is split into multiple heap parts based on object types
   // and object sizes.
   BaseArena* Arena(int arena_index) const {
-    ASSERT(0 <= arena_index);
-    ASSERT(arena_index < BlinkGC::kNumberOfArenas);
+    DCHECK_LE(0, arena_index);
+    DCHECK_LT(arena_index, BlinkGC::kNumberOfArenas);
     return arenas_[arena_index];
   }
 
 #if DCHECK_IS_ON()
   // Infrastructure to determine if an address is within one of the
   // address ranges for the Blink heap. If the address is in the Blink
   // heap the containing heap page is returned.
   BasePage* FindPageFromAddress(Address);
   BasePage* FindPageFromAddress(const void* pointer) {
     return FindPageFromAddress(
@@ skipping 52 matching lines @@
   }
 
   // By entering a gc-forbidden scope, conservative GCs will not
   // be allowed while handling an out-of-line allocation request.
   // Intended used when constructing subclasses of GC mixins, where
   // the object being constructed cannot be safely traced & marked
   // fully should a GC be allowed while its subclasses are being
   // constructed.
   void EnterGCForbiddenScopeIfNeeded(
       GarbageCollectedMixinConstructorMarker* gc_mixin_marker) {
-    ASSERT(CheckThread());
+    DCHECK(CheckThread());
     if (!gc_mixin_marker_) {
       EnterMixinConstructionScope();
       gc_mixin_marker_ = gc_mixin_marker;
     }
   }
   void LeaveGCForbiddenScopeIfNeeded(
       GarbageCollectedMixinConstructorMarker* gc_mixin_marker) {
-    ASSERT(CheckThread());
+    DCHECK(CheckThread());
     if (gc_mixin_marker_ == gc_mixin_marker) {
       LeaveMixinConstructionScope();
       gc_mixin_marker_ = nullptr;
     }
   }
 
   // vectorBackingArena() returns an arena that the vector allocation should
   // use.  We have four vector arenas and want to choose the best arena here.
   //
   // The goal is to improve the succession rate where expand and
@@ skipping 13 matching lines @@
   // To implement the heuristics, we add an arenaAge to each arena. The arenaAge
   // is updated if:
   //
   // - a vector on the arena is expanded; or
   // - a vector that meets the condition (*) is allocated on the arena
   //
   //   (*) More than 33% of the same type of vectors have been promptly
   //       freed since the last GC.
   //
   BaseArena* VectorBackingArena(size_t gc_info_index) {
-    ASSERT(CheckThread());
+    DCHECK(CheckThread());
     size_t entry_index = gc_info_index & kLikelyToBePromptlyFreedArrayMask;
     --likely_to_be_promptly_freed_[entry_index];
     int arena_index = vector_backing_arena_index_;
     // If m_likelyToBePromptlyFreed[entryIndex] > 0, that means that
     // more than 33% of vectors of the type have been promptly freed
     // since the last GC.
     if (likely_to_be_promptly_freed_[entry_index] > 0) {
       arena_ages_[arena_index] = ++current_arena_ages_;
       vector_backing_arena_index_ =
           ArenaIndexOfVectorArenaLeastRecentlyExpanded(
               BlinkGC::kVector1ArenaIndex, BlinkGC::kVector4ArenaIndex);
     }
-    ASSERT(IsVectorArenaIndex(arena_index));
+    DCHECK(IsVectorArenaIndex(arena_index));
     return arenas_[arena_index];
   }
   BaseArena* ExpandedVectorBackingArena(size_t gc_info_index);
   static bool IsVectorArenaIndex(int arena_index) {
     return BlinkGC::kVector1ArenaIndex <= arena_index &&
            arena_index <= BlinkGC::kVector4ArenaIndex;
   }
   void AllocationPointAdjusted(int arena_index);
   void PromptlyFreed(size_t gc_info_index);
 
@@ skipping 212 matching lines @@
 template <ThreadAffinity affinity>
 class ThreadStateFor;
 
 template <>
 class ThreadStateFor<kMainThreadOnly> {
   STATIC_ONLY(ThreadStateFor);
 
  public:
   static ThreadState* GetState() {
     // This specialization must only be used from the main thread.
-    ASSERT(ThreadState::Current()->IsMainThread());
+    DCHECK(ThreadState::Current()->IsMainThread());
     return ThreadState::MainThreadState();
   }
 };
 
 template <>
 class ThreadStateFor<kAnyThread> {
   STATIC_ONLY(ThreadStateFor);
 
  public:
   static ThreadState* GetState() { return ThreadState::Current(); }
 };
 
 }  // namespace blink
 
 #endif  // ThreadState_h