src/third_party/WebKit/Source/core/dom/ElementData.h

   1 /*
   2  * Copyright (C) 2013 Google Inc. All rights reserved.
   3  * Copyright (C) 2014 Apple Inc. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met:
   8  *
   9  *     * Redistributions of source code must retain the above copyright
  10  * notice, this list of conditions and the following disclaimer.
  11  *     * Redistributions in binary form must reproduce the above
  12  * copyright notice, this list of conditions and the following disclaimer
  13  * in the documentation and/or other materials provided with the
  14  * distribution.
  15  *     * Neither the name of Google Inc. nor the names of its
  16  * contributors may be used to endorse or promote products derived from
  17  * this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #ifndef ElementData_h
  33 #define ElementData_h
  34
  35 #include "core/dom/Attribute.h"
  36 #include "core/dom/AttributeCollection.h"
  37 #include "core/dom/SpaceSplitString.h"
  38 #include "platform/heap/Handle.h"
  39 #include "wtf/text/AtomicString.h"
  40
  41 namespace blink {
  42
  43 class ShareableElementData;
  44 class StylePropertySet;
  45 class UniqueElementData;
  46
  47 // ElementData represents very common, but not necessarily unique to an element,
  48 // data such as attributes, inline style, and parsed class names and ids.
  49 class ElementData : public RefCountedWillBeGarbageCollectedFinalized<ElementData> {
  50     WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
  51 public:
  52 #if ENABLE(OILPAN)
  53     // Override GarbageCollectedFinalized's finalizeGarbageCollectedObject to
  54     // dispatch to the correct subclass destructor.
  55     void finalizeGarbageCollectedObject();
  56 #else
  57     // Override RefCounted's deref() to ensure operator delete is called on
  58     // the appropriate subclass type.
  59     void deref();
  60 #endif
  61
  62     void clearClass() const { m_classNames.clear(); }
  63     void setClass(const AtomicString& className, bool shouldFoldCase) const { m_classNames.set(className, shouldFoldCase); }
  64     const SpaceSplitString& classNames() const { return m_classNames; }
  65
  66     const AtomicString& idForStyleResolution() const { return m_idForStyleResolution; }
  67     void setIdForStyleResolution(const AtomicString& newId) const { m_idForStyleResolution = newId; }
  68
  69     const StylePropertySet* inlineStyle() const { return m_inlineStyle.get(); }
  70
  71     const StylePropertySet* presentationAttributeStyle() const;
  72
  73     AttributeCollection attributes() const;
  74
  75     bool hasID() const { return !m_idForStyleResolution.isNull(); }
  76     bool hasClass() const { return !m_classNames.isNull(); }
  77
  78     bool isEquivalent(const ElementData* other) const;
  79
  80     bool isUnique() const { return m_isUnique; }
  81
  82     void traceAfterDispatch(Visitor*);
  83     void trace(Visitor*);
  84
  85 protected:
  86     ElementData();
  87     explicit ElementData(unsigned arraySize);
  88     ElementData(const ElementData&, bool isUnique);
  89
  90     // Keep the type in a bitfield instead of using virtual destructors to avoid adding a vtable.
  91     unsigned m_isUnique : 1;
  92     unsigned m_arraySize : 28;
  93     mutable unsigned m_presentationAttributeStyleIsDirty : 1;
  94     mutable unsigned m_styleAttributeIsDirty : 1;
  95     mutable unsigned m_animatedSVGAttributesAreDirty : 1;
  96
  97     mutable RefPtrWillBeMember<StylePropertySet> m_inlineStyle;
  98     mutable SpaceSplitString m_classNames;
  99     mutable AtomicString m_idForStyleResolution;
 100
 101 private:
 102     friend class Element;
 103     friend class ShareableElementData;
 104     friend class UniqueElementData;
 105     friend class SVGElement;
 106
 107 #if !ENABLE(OILPAN)
 108     void destroy();
 109 #endif
 110
 111     PassRefPtrWillBeRawPtr<UniqueElementData> makeUniqueCopy() const;
 112 };
 113
 114 #define DEFINE_ELEMENT_DATA_TYPE_CASTS(thisType,  pointerPredicate, referencePredicate) \
 115     template<typename T> inline thisType* to##thisType(const RefPtr<T>& data) { return to##thisType(data.get()); } \
 116     DEFINE_TYPE_CASTS(thisType, ElementData, data, pointerPredicate, referencePredicate)
 117
 118 #if COMPILER(MSVC)
 119 #pragma warning(push)
 120 #pragma warning(disable: 4200) // Disable "zero-sized array in struct/union" warning
 121 #endif
 122
 123 // SharableElementData is managed by ElementDataCache and is produced by
 124 // the parser during page load for elements that have identical attributes. This
 125 // is a memory optimization since it's very common for many elements to have
 126 // duplicate sets of attributes (ex. the same classes).
 127 class ShareableElementData FINAL : public ElementData {
 128 public:
 129     static PassRefPtrWillBeRawPtr<ShareableElementData> createWithAttributes(const Vector<Attribute>&);
 130
 131     explicit ShareableElementData(const Vector<Attribute>&);
 132     explicit ShareableElementData(const UniqueElementData&);
 133     ~ShareableElementData();
 134
 135     void traceAfterDispatch(Visitor* visitor) { ElementData::traceAfterDispatch(visitor); }
 136
 137     // Add support for placement new as ShareableElementData is not allocated
 138     // with a fixed size. Instead the allocated memory size is computed based on
 139     // the number of attributes. This requires us to use Heap::allocate directly
 140     // with the computed size and subsequently call placement new with the
 141     // allocated memory address.
 142     void* operator new(std::size_t, void* location)
 143     {
 144         return location;
 145     }
 146
 147     AttributeCollection attributes() const;
 148
 149     Attribute m_attributeArray[0];
 150 };
 151
 152 DEFINE_ELEMENT_DATA_TYPE_CASTS(ShareableElementData, !data->isUnique(), !data.isUnique());
 153
 154 #if COMPILER(MSVC)
 155 #pragma warning(pop)
 156 #endif
 157
 158 // UniqueElementData is created when an element needs to mutate its attributes
 159 // or gains presentation attribute style (ex. width="10"). It does not need to
 160 // be created to fill in values in the ElementData that are derived from
 161 // attributes. For example populating the m_inlineStyle from the style attribute
 162 // doesn't require a UniqueElementData as all elements with the same style
 163 // attribute will have the same inline style.
 164 class UniqueElementData FINAL : public ElementData {
 165 public:
 166     static PassRefPtrWillBeRawPtr<UniqueElementData> create();
 167     PassRefPtrWillBeRawPtr<ShareableElementData> makeShareableCopy() const;
 168
 169     MutableAttributeCollection attributes();
 170     AttributeCollection attributes() const;
 171
 172     UniqueElementData();
 173     explicit UniqueElementData(const ShareableElementData&);
 174     explicit UniqueElementData(const UniqueElementData&);
 175
 176     void traceAfterDispatch(Visitor*);
 177
 178     // FIXME: We might want to support sharing element data for elements with
 179     // presentation attribute style. Lots of table cells likely have the same
 180     // attributes. Most modern pages don't use presentation attributes though
 181     // so this might not make sense.
 182     mutable RefPtrWillBeMember<StylePropertySet> m_presentationAttributeStyle;
 183     AttributeVector m_attributeVector;
 184 };
 185
 186 DEFINE_ELEMENT_DATA_TYPE_CASTS(UniqueElementData, data->isUnique(), data.isUnique());
 187
 188 #if !ENABLE(OILPAN)
 189 inline void ElementData::deref()
 190 {
 191     if (!derefBase())
 192         return;
 193     destroy();
 194 }
 195 #endif
 196
 197 inline const StylePropertySet* ElementData::presentationAttributeStyle() const
 198 {
 199     if (!m_isUnique)
 200         return 0;
 201     return toUniqueElementData(this)->m_presentationAttributeStyle.get();
 202 }
 203
 204 inline AttributeCollection ElementData::attributes() const
 205 {
 206     if (isUnique())
 207         return toUniqueElementData(this)->attributes();
 208     return toShareableElementData(this)->attributes();
 209 }
 210
 211 inline AttributeCollection ShareableElementData::attributes() const
 212 {
 213     return AttributeCollection(m_attributeArray, m_arraySize);
 214 }
 215
 216 inline AttributeCollection UniqueElementData::attributes() const
 217 {
 218     return AttributeCollection(m_attributeVector.data(), m_attributeVector.size());
 219 }
 220
 221 inline MutableAttributeCollection UniqueElementData::attributes()
 222 {
 223     return MutableAttributeCollection(m_attributeVector);
 224 }
 225
 226 } // namespace blink
 227
 228 #endif // ElementData_h