Replace ASSERTs in platform/heap/ with DCHECKs

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef GCInfo_h
 #define GCInfo_h
 
 #include "platform/heap/Visitor.h"
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
@@ skipping 138 matching lines @@
   TraceCallback m_trace;
   FinalizationCallback m_finalize;
   bool m_nonTrivialFinalizer;
   bool m_hasVTable;
 };
 
 // s_gcInfoTable holds the per-class GCInfo descriptors; each heap
 // object header keeps its index into this table.
 extern PLATFORM_EXPORT GCInfo const** s_gcInfoTable;
 
-#if ENABLE(ASSERT)
+// The (max + 1) GCInfo index supported.
+// We assume that 14 bits is enough to represent all possible types: during
+// telemetry runs, we see about 1000 different types, looking at the output
+// of the oilpan gc clang plugin, there appear to be at most about 6000
+// types, so 14 bits should be more than twice as many bits as we will ever
+// encounter.
+static const size_t gcInfoMaxIndex = 1 << 14;

[haraken, 2017/01/06 04:18:49]

I hit a link error if I put this in GCInfo. I couldn't work around it, so put it
outside the class declaration.

[sof, 2017/01/08 07:10:46]

Do you remember what the link error was? 

+
+#if DCHECK_IS_ON()
 PLATFORM_EXPORT void assertObjectHasGCInfo(const void*, size_t gcInfoIndex);
 #endif
 
 class GCInfoTable {
   STATIC_ONLY(GCInfoTable);
 
  public:
   PLATFORM_EXPORT static void ensureGCInfoIndex(const GCInfo*, size_t*);
 
   static void init();
   static void shutdown();
 
   static size_t gcInfoIndex() { return s_gcInfoIndex; }
 
-  // The (max + 1) GCInfo index supported.
-  // We assume that 14 bits is enough to represent all possible types: during
-  // telemetry runs, we see about 1000 different types, looking at the output
-  // of the oilpan gc clang plugin, there appear to be at most about 6000
-  // types, so 14 bits should be more than twice as many bits as we will ever
-  // encounter.
-  static const size_t maxIndex = 1 << 14;
-
  private:
   static void resize();
 
   static int s_gcInfoIndex;
   static size_t s_gcInfoTableSize;
 };
 
 // GCInfoAtBaseType should be used when returning a unique 14 bit integer
 // for a given gcInfo.
 template <typename T>
 struct GCInfoAtBaseType {
   STATIC_ONLY(GCInfoAtBaseType);
   static size_t index() {
     static_assert(sizeof(T), "T must be fully defined");
     static const GCInfo gcInfo = {
         TraceTrait<T>::trace, FinalizerTrait<T>::finalize,
         FinalizerTrait<T>::nonTrivialFinalizer, std::is_polymorphic<T>::value,
     };
 
     static size_t gcInfoIndex = 0;
-    ASSERT(s_gcInfoTable);
+    DCHECK(s_gcInfoTable);
     if (!acquireLoad(&gcInfoIndex))
       GCInfoTable::ensureGCInfoIndex(&gcInfo, &gcInfoIndex);
-    ASSERT(gcInfoIndex >= 1);
-    ASSERT(gcInfoIndex < GCInfoTable::maxIndex);
+    DCHECK_GE(gcInfoIndex, 1UL);
+    DCHECK_LT(gcInfoIndex, gcInfoMaxIndex);
     return gcInfoIndex;
   }
 };
 
 template <typename T,
           bool = WTF::IsSubclassOfTemplate<typename std::remove_const<T>::type,
                                            GarbageCollected>::value>
 struct GetGarbageCollectedType;
 
 template <typename T>
@@ skipping 56 matching lines @@
 template <typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapDeque<T, inlineCapacity>>
     : public GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator>> {};
 template <typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashCountedSet<T, U, V>>
     : public GCInfoTrait<HashCountedSet<T, U, V, HeapAllocator>> {};
 
 }  // namespace blink
 
 #endif