CSSValue Immediates: Change CSSValue to an object instead of a pointer

Source/core/css/CSSValueObject.h

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
-#ifndef CSSValue_h
-#define CSSValue_h
+#ifndef CSSValueObject_h
+#define CSSValueObject_h
 
 #include "core/CoreExport.h"
 #include "platform/heap/Handle.h"
-#include "platform/weborigin/KURL.h"
-#include "wtf/HashMap.h"
-#include "wtf/ListHashSet.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
-class CORE_EXPORT CSSValue : public RefCountedWillBeGarbageCollectedFinalized<CSSValue> {
+class CORE_EXPORT CSSValueObject : public RefCountedWillBeGarbageCollectedFinalized<CSSValueObject> {

[haraken, 2015/06/11 02:48:53]

CSSValue is allocated on a dedicated heap in Oilpan (for performance reasons).
Now that you renamed it to CSSValueObject, you need to make the corresponding
change in the heap. Would you open platform/heap/ThreadState.h and change
'H(CSSValue)' to 'H(CSSValueObject)'?

[sashab, 2015/06/11 23:05:35]

Ah, didn't know about this. Thanks; done.

 public:
 #if ENABLE(OILPAN)
-    // Override operator new to allocate CSSValue subtype objects onto
+    // Override operator new to allocate CSSValueObject subtype objects onto
     // a dedicated heap.
     GC_PLUGIN_IGNORE("crbug.com/443854")
     void* operator new(size_t size)
     {
         return allocateObject(size);
     }
     static void* allocateObject(size_t size)
     {
-        ThreadState* state = ThreadStateFor<ThreadingTrait<CSSValue>::Affinity>::state();
-        return Heap::allocateOnHeapIndex(state, size, CSSValueHeapIndex, GCInfoTrait<CSSValue>::index());
+        ThreadState* state = ThreadStateFor<ThreadingTrait<CSSValueObject>::Affinity>::state();
+        return Heap::allocateOnHeapIndex(state, size, CSSValueHeapIndex, GCInfoTrait<CSSValueObject>::index());
     }
 #else
     // Override RefCounted's deref() to ensure operator delete is called on
     // the appropriate subclass type.
     void deref()
     {
         if (derefBase())
             destroy();
     }
 #endif // !ENABLE(OILPAN)
@@ skipping 31 matching lines @@
     bool isLineBoxContainValue() const { return m_classType == LineBoxContainClass; }
     bool isCalcValue() const {return m_classType == CalculationClass; }
     bool isGridTemplateAreasValue() const { return m_classType == GridTemplateAreasClass; }
     bool isSVGDocumentValue() const { return m_classType == CSSSVGDocumentClass; }
     bool isContentDistributionValue() const { return m_classType == CSSContentDistributionClass; }
     bool isUnicodeRangeValue() const { return m_classType == UnicodeRangeClass; }
     bool isGridLineNamesValue() const { return m_classType == GridLineNamesClass; }
 
     bool hasFailedOrCanceledSubresources() const;
 
-    bool equals(const CSSValue&) const;
+    bool equals(const CSSValueObject&) const;
 
     void finalizeGarbageCollectedObject();
     DEFINE_INLINE_TRACE_AFTER_DISPATCH() { }
     DECLARE_TRACE();
 
-    // ~CSSValue should be public, because non-public ~CSSValue causes C2248
-    // error: 'blink::CSSValue::~CSSValue' : cannot access protected member
-    // declared in class 'blink::CSSValue' when compiling
+    // ~CSSValueObject should be public, because non-public ~CSSValueObject causes C2248
+    // error: 'blink::CSSValueObject::~CSSValueObject' : cannot access protected member
+    // declared in class 'blink::CSSValueObject' when compiling
     // 'source\wtf\refcounted.h' by using msvc.
-    ~CSSValue() { }
+    ~CSSValueObject() { }
 
 protected:
 
     static const size_t ClassTypeBits = 6;
     enum ClassType {
         PrimitiveClass,
 
         // Image classes.
         ImageClass,
         CursorImageClass,
@@ skipping 40 matching lines @@
 
     static const size_t ValueListSeparatorBits = 2;
     enum ValueListSeparator {
         SpaceSeparator,
         CommaSeparator,
         SlashSeparator
     };
 
     ClassType classType() const { return static_cast<ClassType>(m_classType); }
 
-    explicit CSSValue(ClassType classType)
+    explicit CSSValueObject(ClassType classType)
         : m_primitiveUnitType(0)
         , m_hasCachedCSSText(false)
         , m_isQuirkValue(false)
         , m_valueListSeparator(SpaceSeparator)
         , m_classType(classType)
     {
     }
 
     // NOTE: This class is non-virtual for memory and performance reasons.
     // Don't go making it virtual again unless you know exactly what you're doing!
 
 private:
     void destroy();
 
 protected:
     // The bits in this section are only used by specific subclasses but kept here
     // to maximize struct packing.
 
     // CSSPrimitiveValue bits:
     unsigned m_primitiveUnitType : 7; // CSSPrimitiveValue::UnitType
     mutable unsigned m_hasCachedCSSText : 1;
     unsigned m_isQuirkValue : 1;
 
     unsigned m_valueListSeparator : ValueListSeparatorBits;
 
 private:
     unsigned m_classType : ClassTypeBits; // ClassType
 };
 
-template<typename CSSValueType, size_t inlineCapacity>
-inline bool compareCSSValueVector(const WillBeHeapVector<RefPtrWillBeMember<CSSValueType>, inlineCapacity>& firstVector, const WillBeHeapVector<RefPtrWillBeMember<CSSValueType>, inlineCapacity>& secondVector)
+// TODO(sashab): Remove this; only compareCSSValueVector is needed.
+template<typename CSSValueObjectType, size_t inlineCapacity>
+inline bool compareCSSValueObjectVector(const WillBeHeapVector<RefPtrWillBeMember<CSSValueObjectType>, inlineCapacity>& firstVector, const WillBeHeapVector<RefPtrWillBeMember<CSSValueObjectType>, inlineCapacity>& secondVector)
 {
     size_t size = firstVector.size();
     if (size != secondVector.size())
         return false;
 
     for (size_t i = 0; i < size; i++) {
-        const RefPtrWillBeMember<CSSValueType>& firstPtr = firstVector[i];
-        const RefPtrWillBeMember<CSSValueType>& secondPtr = secondVector[i];
+        const RefPtrWillBeMember<CSSValueObjectType>& firstPtr = firstVector[i];
+        const RefPtrWillBeMember<CSSValueObjectType>& secondPtr = secondVector[i];
         if (firstPtr == secondPtr || (firstPtr && secondPtr && firstPtr->equals(*secondPtr)))
             continue;
         return false;
     }
     return true;
 }
 
 template<typename CSSValueType>
 inline bool compareCSSValuePtr(const RefPtr<CSSValueType>& first, const RefPtr<CSSValueType>& second)
 {
     return first ? second && first->equals(*second) : !second;
 }
 
 template<typename CSSValueType>
 inline bool compareCSSValuePtr(const RawPtr<CSSValueType>& first, const RawPtr<CSSValueType>& second)
 {
     return first ? second && first->equals(*second) : !second;
 }
 
 template<typename CSSValueType>
 inline bool compareCSSValuePtr(const Member<CSSValueType>& first, const Member<CSSValueType>& second)
 {
     return first ? second && first->equals(*second) : !second;
 }
 
-#define DEFINE_CSS_VALUE_TYPE_CASTS(thisType, predicate) \
-    DEFINE_TYPE_CASTS(thisType, CSSValue, value, value->predicate, value.predicate)
-
 } // namespace blink
 
-#endif // CSSValue_h
+#endif // CSSValueObject_h