[FastMalloc]: Annotate CSSSelector for heap profiling

third_party/WebKit/Source/core/css/CSSSelectorList.cpp

 /*
  * Copyright (C) 2008, 2012 Apple Inc. All rights reserved.
  * 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 12 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/css/CSSSelectorList.h"
 
 #include "core/css/parser/CSSParserSelector.h"
 #include "wtf/Partitions.h"
 #include "wtf/text/StringBuilder.h"
 
+namespace {
+    // CSSSelector is one of the top types that consume renderer memory,
+    // so instead of using the |WTF_HEAP_PROFILER_TYPE_NAME| macro in the
+    // allocations below, pass this type name constant to allow profiling
+    // in official builds.
+    const char kCSSSelectorTypeName[] = "blink::CSSSelector";
+}
+
 namespace blink {
 
 CSSSelectorList CSSSelectorList::copy() const
 {
     CSSSelectorList list;
 
     unsigned length = this->length();
-    list.m_selectorArray = reinterpret_cast<CSSSelector*>(WTF::Partitions::fastMalloc(sizeof(CSSSelector) * length, WTF_HEAP_PROFILER_TYPE_NAME(CSSSelector)));
+    list.m_selectorArray = reinterpret_cast<CSSSelector*>(WTF::Partitions::fastMalloc(sizeof(CSSSelector) * length, kCSSSelectorTypeName));
     for (unsigned i = 0; i < length; ++i)
         new (&list.m_selectorArray[i]) CSSSelector(m_selectorArray[i]);
 
     return list;
 }
 
 CSSSelectorList CSSSelectorList::adoptSelectorVector(Vector<OwnPtr<CSSParserSelector>>& selectorVector)
 {
     size_t flattenedSize = 0;
     for (size_t i = 0; i < selectorVector.size(); ++i) {
         for (CSSParserSelector* selector = selectorVector[i].get(); selector; selector = selector->tagHistory())
             ++flattenedSize;
     }
     ASSERT(flattenedSize);
 
     CSSSelectorList list;
-    list.m_selectorArray = reinterpret_cast<CSSSelector*>(WTF::Partitions::fastMalloc(sizeof(CSSSelector) * flattenedSize, WTF_HEAP_PROFILER_TYPE_NAME(CSSSelector)));
+    list.m_selectorArray = reinterpret_cast<CSSSelector*>(WTF::Partitions::fastMalloc(sizeof(CSSSelector) * flattenedSize, kCSSSelectorTypeName));
     size_t arrayIndex = 0;
     for (size_t i = 0; i < selectorVector.size(); ++i) {
         CSSParserSelector* current = selectorVector[i].get();
         while (current) {
             // Move item from the parser selector vector into m_selectorArray without invoking destructor (Ugh.)
             CSSSelector* currentSelector = current->releaseSelector().leakPtr();
             memcpy(&list.m_selectorArray[arrayIndex], currentSelector, sizeof(CSSSelector));
             WTF::Partitions::fastFree(currentSelector);
 
             current = current->tagHistory();
@@ skipping 100 matching lines @@
 }
 
 bool CSSSelectorList::selectorNeedsUpdatedDistribution(size_t index) const
 {
     return forEachTagSelector([](const CSSSelector& selector) -> bool {
         return selector.relationIsAffectedByPseudoContent() || selector.pseudoType() == CSSSelector::PseudoHostContext;
     }, selectorAt(index));
 }
 
 } // namespace blink