Source/WebCore/css/StyleProperties.h

   1 /*
   2  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
   3  * Copyright (C) 2004, 2005, 2006, 2008, 2012, 2013 Apple Inc. All rights reserved.
   4  * Copyright (C) 2013 Intel Corporation. All rights reserved.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public License
  17  * along with this library; see the file COPYING.LIB.  If not, write to
  18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21
  22 #pragma once
  23
  24 #include "CSSParserMode.h"
  25 #include "CSSParserTokenRange.h"
  26 #include "CSSProperty.h"
  27 #include "CSSValueKeywords.h"
  28 #include <memory>
  29 #include <wtf/ListHashSet.h>
  30 #include <wtf/TypeCasts.h>
  31 #include <wtf/Vector.h>
  32 #include <wtf/text/WTFString.h>
  33
  34 namespace WebCore {
  35
  36 class CSSDeferredParser;
  37 class CSSStyleDeclaration;
  38 class CachedResource;
  39 class ImmutableStyleProperties;
  40 class URL;
  41 class MutableStyleProperties;
  42 class PropertySetCSSStyleDeclaration;
  43 class StyledElement;
  44 class StylePropertyShorthand;
  45 class StyleSheetContents;
  46
  47 enum StylePropertiesType { ImmutablePropertiesType, MutablePropertiesType, DeferredPropertiesType };
  48
  49 class StylePropertiesBase : public RefCounted<StylePropertiesBase> {
  50 public:
  51     // Override RefCounted's deref() to ensure operator delete is called on
  52     // the appropriate subclass type.
  53     void deref();
  54
  55     StylePropertiesType type() const { return static_cast<StylePropertiesType>(m_type); }
  56
  57     CSSParserMode cssParserMode() const { return static_cast<CSSParserMode>(m_cssParserMode); }
  58
  59 protected:
  60     StylePropertiesBase(CSSParserMode cssParserMode, StylePropertiesType type)
  61         : m_cssParserMode(cssParserMode)
  62         , m_type(type)
  63         , m_arraySize(0)
  64     { }
  65
  66     StylePropertiesBase(CSSParserMode cssParserMode, unsigned immutableArraySize)
  67         : m_cssParserMode(cssParserMode)
  68         , m_type(ImmutablePropertiesType)
  69         , m_arraySize(immutableArraySize)
  70     { }
  71
  72     unsigned m_cssParserMode : 3;
  73     mutable unsigned m_type : 2;
  74     unsigned m_arraySize : 27;
  75 };
  76
  77 class StyleProperties : public StylePropertiesBase {
  78     friend class PropertyReference;
  79 public:
  80     class PropertyReference {
  81     public:
  82         PropertyReference(const StylePropertyMetadata& metadata, const CSSValue* value)
  83             : m_metadata(metadata)
  84             , m_value(value)
  85         { }
  86
  87         CSSPropertyID id() const { return static_cast<CSSPropertyID>(m_metadata.m_propertyID); }
  88         CSSPropertyID shorthandID() const { return m_metadata.shorthandID(); }
  89
  90         bool isImportant() const { return m_metadata.m_important; }
  91         bool isInherited() const { return m_metadata.m_inherited; }
  92         bool isImplicit() const { return m_metadata.m_implicit; }
  93
  94         String cssName() const;
  95         String cssText() const;
  96
  97         const CSSValue* value() const { return m_value; }
  98         // FIXME: We should try to remove this mutable overload.
  99         CSSValue* value() { return const_cast<CSSValue*>(m_value); }
 100
 101         // FIXME: Remove this.
 102         CSSProperty toCSSProperty() const { return CSSProperty(id(), const_cast<CSSValue*>(m_value), isImportant(), m_metadata.m_isSetFromShorthand, m_metadata.m_indexInShorthandsVector, isImplicit()); }
 103
 104     private:
 105         const StylePropertyMetadata& m_metadata;
 106         const CSSValue* m_value;
 107     };
 108
 109     unsigned propertyCount() const;
 110     bool isEmpty() const { return !propertyCount(); }
 111     PropertyReference propertyAt(unsigned) const;
 112
 113     WEBCORE_EXPORT RefPtr<CSSValue> getPropertyCSSValue(CSSPropertyID) const;
 114     WEBCORE_EXPORT String getPropertyValue(CSSPropertyID) const;
 115     bool propertyIsImportant(CSSPropertyID) const;
 116     String getPropertyShorthand(CSSPropertyID) const;
 117     bool isPropertyImplicit(CSSPropertyID) const;
 118
 119     RefPtr<CSSValue> getCustomPropertyCSSValue(const String& propertyName) const;
 120     String getCustomPropertyValue(const String& propertyName) const;
 121     bool customPropertyIsImportant(const String& propertyName) const;
 122
 123     Ref<MutableStyleProperties> copyBlockProperties() const;
 124
 125     WEBCORE_EXPORT Ref<MutableStyleProperties> mutableCopy() const;
 126     Ref<ImmutableStyleProperties> immutableCopyIfNeeded() const;
 127
 128     Ref<MutableStyleProperties> copyPropertiesInSet(const CSSPropertyID* set, unsigned length) const;
 129
 130     String asText() const;
 131
 132     bool hasCSSOMWrapper() const;
 133     bool isMutable() const { return type() == MutablePropertiesType; }
 134
 135     bool traverseSubresources(const std::function<bool (const CachedResource&)>& handler) const;
 136
 137     static unsigned averageSizeInBytes();
 138
 139 #ifndef NDEBUG
 140     void showStyle();
 141 #endif
 142
 143     bool propertyMatches(CSSPropertyID, const CSSValue*) const;
 144
 145 protected:
 146     StyleProperties(CSSParserMode cssParserMode, StylePropertiesType type)
 147         : StylePropertiesBase(cssParserMode, type)
 148     { }
 149
 150     StyleProperties(CSSParserMode cssParserMode, unsigned immutableArraySize)
 151         : StylePropertiesBase(cssParserMode, immutableArraySize)
 152     { }
 153
 154     int findPropertyIndex(CSSPropertyID) const;
 155     int findCustomPropertyIndex(const String& propertyName) const;
 156
 157 private:
 158     String getShorthandValue(const StylePropertyShorthand&) const;
 159     String getCommonValue(const StylePropertyShorthand&) const;
 160     String getAlignmentShorthandValue(const StylePropertyShorthand&) const;
 161     enum CommonValueMode { OmitUncommonValues, ReturnNullOnUncommonValues };
 162     String borderPropertyValue(CommonValueMode) const;
 163     String getLayeredShorthandValue(const StylePropertyShorthand&) const;
 164     String get4Values(const StylePropertyShorthand&) const;
 165     String borderSpacingValue(const StylePropertyShorthand&) const;
 166     String fontValue() const;
 167     void appendFontLonghandValueIfExplicit(CSSPropertyID, StringBuilder& result, String& value) const;
 168
 169     RefPtr<CSSValue> getPropertyCSSValueInternal(CSSPropertyID) const;
 170
 171     friend class PropertySetCSSStyleDeclaration;
 172 };
 173
 174 class ImmutableStyleProperties final : public StyleProperties {
 175 public:
 176     WEBCORE_EXPORT ~ImmutableStyleProperties();
 177     static Ref<ImmutableStyleProperties> create(const CSSProperty* properties, unsigned count, CSSParserMode);
 178
 179     unsigned propertyCount() const { return m_arraySize; }
 180     bool isEmpty() const { return !propertyCount(); }
 181     PropertyReference propertyAt(unsigned index) const;
 182
 183     const CSSValue** valueArray() const;
 184     const StylePropertyMetadata* metadataArray() const;
 185     int findPropertyIndex(CSSPropertyID) const;
 186     int findCustomPropertyIndex(const String& propertyName) const;
 187
 188     void* m_storage;
 189
 190 private:
 191     ImmutableStyleProperties(const CSSProperty*, unsigned count, CSSParserMode);
 192 };
 193
 194 inline const CSSValue** ImmutableStyleProperties::valueArray() const
 195 {
 196     return reinterpret_cast<const CSSValue**>(const_cast<const void**>((&(this->m_storage))));
 197 }
 198
 199 inline const StylePropertyMetadata* ImmutableStyleProperties::metadataArray() const
 200 {
 201     return reinterpret_cast_ptr<const StylePropertyMetadata*>(&reinterpret_cast_ptr<const char*>(&(this->m_storage))[m_arraySize * sizeof(CSSValue*)]);
 202 }
 203
 204 class MutableStyleProperties final : public StyleProperties {
 205 public:
 206     WEBCORE_EXPORT static Ref<MutableStyleProperties> create(CSSParserMode = HTMLQuirksMode);
 207     static Ref<MutableStyleProperties> create(const CSSProperty* properties, unsigned count);
 208
 209     WEBCORE_EXPORT ~MutableStyleProperties();
 210
 211     unsigned propertyCount() const { return m_propertyVector.size(); }
 212     bool isEmpty() const { return !propertyCount(); }
 213     PropertyReference propertyAt(unsigned index) const;
 214
 215     PropertySetCSSStyleDeclaration* cssStyleDeclaration();
 216
 217     bool addParsedProperties(const ParsedPropertyVector&);
 218     bool addParsedProperty(const CSSProperty&);
 219
 220     // These expand shorthand properties into multiple properties.
 221     bool setProperty(CSSPropertyID, const String& value, bool important, CSSParserContext);
 222     bool setProperty(CSSPropertyID, const String& value, bool important = false);
 223     void setProperty(CSSPropertyID, RefPtr<CSSValue>&&, bool important = false);
 224
 225     // These do not. FIXME: This is too messy, we can do better.
 226     bool setProperty(CSSPropertyID, CSSValueID identifier, bool important = false);
 227     bool setProperty(CSSPropertyID, CSSPropertyID identifier, bool important = false);
 228     bool setProperty(const CSSProperty&, CSSProperty* slot = nullptr);
 229
 230     bool removeProperty(CSSPropertyID, String* returnText = nullptr);
 231     void removeBlockProperties();
 232     bool removePropertiesInSet(const CSSPropertyID* set, unsigned length);
 233
 234     void mergeAndOverrideOnConflict(const StyleProperties&);
 235
 236     void clear();
 237     bool parseDeclaration(const String& styleDeclaration, CSSParserContext);
 238
 239     WEBCORE_EXPORT CSSStyleDeclaration* ensureCSSStyleDeclaration();
 240     CSSStyleDeclaration* ensureInlineCSSStyleDeclaration(StyledElement* parentElement);
 241
 242     int findPropertyIndex(CSSPropertyID) const;
 243     int findCustomPropertyIndex(const String& propertyName) const;
 244
 245     Vector<CSSProperty, 4> m_propertyVector;
 246
 247     // Methods for querying and altering CSS custom properties.
 248     bool setCustomProperty(const String& propertyName, const String& value, bool important, CSSParserContext);
 249     bool removeCustomProperty(const String& propertyName, String* returnText = nullptr);
 250
 251 private:
 252     explicit MutableStyleProperties(CSSParserMode);
 253     explicit MutableStyleProperties(const StyleProperties&);
 254     MutableStyleProperties(const CSSProperty* properties, unsigned count);
 255
 256     bool removeShorthandProperty(CSSPropertyID);
 257     CSSProperty* findCSSPropertyWithID(CSSPropertyID);
 258     CSSProperty* findCustomCSSPropertyWithName(const String&);
 259     std::unique_ptr<PropertySetCSSStyleDeclaration> m_cssomWrapper;
 260
 261     friend class StyleProperties;
 262 };
 263
 264 class DeferredStyleProperties final : public StylePropertiesBase {
 265 public:
 266     WEBCORE_EXPORT ~DeferredStyleProperties();
 267     static Ref<DeferredStyleProperties> create(const CSSParserTokenRange&, CSSDeferredParser&);
 268
 269     Ref<ImmutableStyleProperties> parseDeferredProperties();
 270
 271 private:
 272     DeferredStyleProperties(const CSSParserTokenRange&, CSSDeferredParser&);
 273
 274     Vector<CSSParserToken> m_tokens;
 275     Ref<CSSDeferredParser> m_parser;
 276 };
 277
 278 inline ImmutableStyleProperties::PropertyReference ImmutableStyleProperties::propertyAt(unsigned index) const
 279 {
 280     return PropertyReference(metadataArray()[index], valueArray()[index]);
 281 }
 282
 283 inline MutableStyleProperties::PropertyReference MutableStyleProperties::propertyAt(unsigned index) const
 284 {
 285     const CSSProperty& property = m_propertyVector[index];
 286     return PropertyReference(property.metadata(), property.value());
 287 }
 288
 289 inline StyleProperties::PropertyReference StyleProperties::propertyAt(unsigned index) const
 290 {
 291     if (is<MutableStyleProperties>(*this))
 292         return downcast<MutableStyleProperties>(*this).propertyAt(index);
 293     return downcast<ImmutableStyleProperties>(*this).propertyAt(index);
 294 }
 295
 296 inline unsigned StyleProperties::propertyCount() const
 297 {
 298     if (is<MutableStyleProperties>(*this))
 299         return downcast<MutableStyleProperties>(*this).propertyCount();
 300     return downcast<ImmutableStyleProperties>(*this).propertyCount();
 301 }
 302
 303 inline void StylePropertiesBase::deref()
 304 {
 305     if (!derefBase())
 306         return;
 307
 308     if (is<MutableStyleProperties>(*this))
 309         delete downcast<MutableStyleProperties>(this);
 310     else if (is<ImmutableStyleProperties>(*this))
 311         delete downcast<ImmutableStyleProperties>(this);
 312     else
 313         delete downcast<DeferredStyleProperties>(this);
 314 }
 315
 316 inline int StyleProperties::findPropertyIndex(CSSPropertyID propertyID) const
 317 {
 318     if (is<MutableStyleProperties>(*this))
 319         return downcast<MutableStyleProperties>(*this).findPropertyIndex(propertyID);
 320     return downcast<ImmutableStyleProperties>(*this).findPropertyIndex(propertyID);
 321 }
 322
 323 inline int StyleProperties::findCustomPropertyIndex(const String& propertyName) const
 324 {
 325     if (is<MutableStyleProperties>(*this))
 326         return downcast<MutableStyleProperties>(*this).findCustomPropertyIndex(propertyName);
 327     return downcast<ImmutableStyleProperties>(*this).findCustomPropertyIndex(propertyName);
 328 }
 329
 330 } // namespace WebCore
 331
 332 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleProperties)
 333     static bool isType(const WebCore::StylePropertiesBase& set) { return set.type() != WebCore::DeferredPropertiesType; }
 334 SPECIALIZE_TYPE_TRAITS_END()
 335
 336 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::MutableStyleProperties)
 337     static bool isType(const WebCore::StylePropertiesBase& set) { return set.type() == WebCore::MutablePropertiesType; }
 338 SPECIALIZE_TYPE_TRAITS_END()
 339
 340 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::ImmutableStyleProperties)
 341     static bool isType(const WebCore::StylePropertiesBase& set) { return set.type() == WebCore::ImmutablePropertiesType; }
 342 SPECIALIZE_TYPE_TRAITS_END()
 343
 344 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::DeferredStyleProperties)
 345     static bool isType(const WebCore::StylePropertiesBase& set) { return set.type() == WebCore::DeferredPropertiesType; }
 346 SPECIALIZE_TYPE_TRAITS_END()