Add modern API for overriding the page's specified viewport configuration
[WebKit-https.git] / Source / WebCore / css / StyleProperties.h
index 9e9cf22..e8572e2 100644 (file)
  * Boston, MA 02110-1301, USA.
  */
 
-#ifndef StyleProperties_h
-#define StyleProperties_h
+#pragma once
 
-#include "CSSParserMode.h"
-#include "CSSPrimitiveValue.h"
+#include "CSSParserContext.h"
+#include "CSSParserTokenRange.h"
 #include "CSSProperty.h"
-#include "CSSPropertyNames.h"
 #include "CSSValueKeywords.h"
 #include <memory>
-#include <wtf/ListHashSet.h>
+#include <wtf/Function.h>
 #include <wtf/TypeCasts.h>
 #include <wtf/Vector.h>
 #include <wtf/text/WTFString.h>
 
 namespace WebCore {
 
-class CSSRule;
+class CSSDeferredParser;
 class CSSStyleDeclaration;
-class ComputedStyleExtractor;
+class CachedResource;
+class Color;
 class ImmutableStyleProperties;
-class URL;
 class MutableStyleProperties;
 class PropertySetCSSStyleDeclaration;
 class StyledElement;
 class StylePropertyShorthand;
 class StyleSheetContents;
 
-class StyleProperties : public RefCounted<StyleProperties> {
-    friend class PropertyReference;
+enum StylePropertiesType { ImmutablePropertiesType, MutablePropertiesType, DeferredPropertiesType };
+    
+class StylePropertiesBase : public RefCounted<StylePropertiesBase> {
 public:
     // Override RefCounted's deref() to ensure operator delete is called on
     // the appropriate subclass type.
     void deref();
+    
+    StylePropertiesType type() const { return static_cast<StylePropertiesType>(m_type); }
 
+    CSSParserMode cssParserMode() const { return static_cast<CSSParserMode>(m_cssParserMode); }
+
+protected:
+    StylePropertiesBase(CSSParserMode cssParserMode, StylePropertiesType type)
+        : m_cssParserMode(cssParserMode)
+        , m_type(type)
+        , m_arraySize(0)
+    { }
+    
+    StylePropertiesBase(CSSParserMode cssParserMode, unsigned immutableArraySize)
+        : m_cssParserMode(cssParserMode)
+        , m_type(ImmutablePropertiesType)
+        , m_arraySize(immutableArraySize)
+    { }
+    
+    unsigned m_cssParserMode : 3;
+    mutable unsigned m_type : 2;
+    unsigned m_arraySize : 27;
+};
+
+class StyleProperties : public StylePropertiesBase {
+    friend class PropertyReference;
+public:
     class PropertyReference {
     public:
         PropertyReference(const StylePropertyMetadata& metadata, const CSSValue* value)
@@ -86,17 +110,21 @@ public:
     bool isEmpty() const { return !propertyCount(); }
     PropertyReference propertyAt(unsigned) const;
 
-    WEBCORE_EXPORT PassRefPtr<CSSValue> getPropertyCSSValue(CSSPropertyID) const;
+    WEBCORE_EXPORT RefPtr<CSSValue> getPropertyCSSValue(CSSPropertyID) const;
     WEBCORE_EXPORT String getPropertyValue(CSSPropertyID) const;
+
+    WEBCORE_EXPORT Optional<Color> propertyAsColor(CSSPropertyID) const;
+    WEBCORE_EXPORT CSSValueID propertyAsValueID(CSSPropertyID) const;
+
     bool propertyIsImportant(CSSPropertyID) const;
     String getPropertyShorthand(CSSPropertyID) const;
     bool isPropertyImplicit(CSSPropertyID) const;
 
-    Ref<MutableStyleProperties> copyBlockProperties() const;
+    RefPtr<CSSValue> getCustomPropertyCSSValue(const String& propertyName) const;
+    String getCustomPropertyValue(const String& propertyName) const;
+    bool customPropertyIsImportant(const String& propertyName) const;
 
-    CSSParserMode cssParserMode() const { return static_cast<CSSParserMode>(m_cssParserMode); }
-
-    void addSubresourceStyleURLs(ListHashSet<URL>&, StyleSheetContents* contextStyleSheet) const;
+    Ref<MutableStyleProperties> copyBlockProperties() const;
 
     WEBCORE_EXPORT Ref<MutableStyleProperties> mutableCopy() const;
     Ref<ImmutableStyleProperties> immutableCopyIfNeeded() const;
@@ -105,10 +133,10 @@ public:
     
     String asText() const;
 
-    bool isMutable() const { return m_isMutable; }
     bool hasCSSOMWrapper() const;
+    bool isMutable() const { return type() == MutablePropertiesType; }
 
-    bool hasFailedOrCanceledSubresources() const;
+    bool traverseSubresources(const WTF::Function<bool (const CachedResource&)>& handler) const;
 
     static unsigned averageSizeInBytes();
 
@@ -119,39 +147,35 @@ public:
     bool propertyMatches(CSSPropertyID, const CSSValue*) const;
 
 protected:
-    StyleProperties(CSSParserMode cssParserMode)
-        : m_cssParserMode(cssParserMode)
-        , m_isMutable(true)
-        , m_arraySize(0)
+    StyleProperties(CSSParserMode cssParserMode, StylePropertiesType type)
+        : StylePropertiesBase(cssParserMode, type)
     { }
 
     StyleProperties(CSSParserMode cssParserMode, unsigned immutableArraySize)
-        : m_cssParserMode(cssParserMode)
-        , m_isMutable(false)
-        , m_arraySize(immutableArraySize)
+        : StylePropertiesBase(cssParserMode, immutableArraySize)
     { }
 
     int findPropertyIndex(CSSPropertyID) const;
+    int findCustomPropertyIndex(const String& propertyName) const;
 
-    unsigned m_cssParserMode : 2;
-    mutable unsigned m_isMutable : 1;
-    unsigned m_arraySize : 29;
-    
 private:
     String getShorthandValue(const StylePropertyShorthand&) const;
     String getCommonValue(const StylePropertyShorthand&) const;
-    enum CommonValueMode { OmitUncommonValues, ReturnNullOnUncommonValues };
-    String borderPropertyValue(CommonValueMode) const;
+    String getAlignmentShorthandValue(const StylePropertyShorthand&) const;
+    String borderPropertyValue(const StylePropertyShorthand&, const StylePropertyShorthand&, const StylePropertyShorthand&) const;
     String getLayeredShorthandValue(const StylePropertyShorthand&) const;
+    String get2Values(const StylePropertyShorthand&) const;
     String get4Values(const StylePropertyShorthand&) const;
     String borderSpacingValue(const StylePropertyShorthand&) const;
     String fontValue() const;
     void appendFontLonghandValueIfExplicit(CSSPropertyID, StringBuilder& result, String& value) const;
-
+    
+    RefPtr<CSSValue> getPropertyCSSValueInternal(CSSPropertyID) const;
+    
     friend class PropertySetCSSStyleDeclaration;
 };
 
-class ImmutableStyleProperties : public StyleProperties {
+class ImmutableStyleProperties final : public StyleProperties {
 public:
     WEBCORE_EXPORT ~ImmutableStyleProperties();
     static Ref<ImmutableStyleProperties> create(const CSSProperty* properties, unsigned count, CSSParserMode);
@@ -163,7 +187,8 @@ public:
     const CSSValue** valueArray() const;
     const StylePropertyMetadata* metadataArray() const;
     int findPropertyIndex(CSSPropertyID) const;
-
+    int findCustomPropertyIndex(const String& propertyName) const;
+    
     void* m_storage;
 
 private:
@@ -180,9 +205,9 @@ inline const StylePropertyMetadata* ImmutableStyleProperties::metadataArray() co
     return reinterpret_cast_ptr<const StylePropertyMetadata*>(&reinterpret_cast_ptr<const char*>(&(this->m_storage))[m_arraySize * sizeof(CSSValue*)]);
 }
 
-class MutableStyleProperties : public StyleProperties {
+class MutableStyleProperties final : public StyleProperties {
 public:
-    WEBCORE_EXPORT static Ref<MutableStyleProperties> create(CSSParserMode = CSSQuirksMode);
+    WEBCORE_EXPORT static Ref<MutableStyleProperties> create(CSSParserMode = HTMLQuirksMode);
     static Ref<MutableStyleProperties> create(const CSSProperty* properties, unsigned count);
 
     WEBCORE_EXPORT ~MutableStyleProperties();
@@ -193,37 +218,40 @@ public:
 
     PropertySetCSSStyleDeclaration* cssStyleDeclaration();
 
-    void addParsedProperties(const Vector<CSSProperty>&);
-    void addParsedProperty(const CSSProperty&);
+    bool addParsedProperties(const ParsedPropertyVector&);
+    bool addParsedProperty(const CSSProperty&);
 
     // These expand shorthand properties into multiple properties.
-    bool setProperty(CSSPropertyID, const String& value, bool important = false, StyleSheetContents* contextStyleSheet = 0);
-    void setProperty(CSSPropertyID, PassRefPtr<CSSValue>, bool important = false);
+    bool setProperty(CSSPropertyID, const String& value, bool important, CSSParserContext);
+    bool setProperty(CSSPropertyID, const String& value, bool important = false);
+    void setProperty(CSSPropertyID, RefPtr<CSSValue>&&, bool important = false);
 
     // These do not. FIXME: This is too messy, we can do better.
     bool setProperty(CSSPropertyID, CSSValueID identifier, bool important = false);
     bool setProperty(CSSPropertyID, CSSPropertyID identifier, bool important = false);
-    void appendPrefixingVariantProperty(const CSSProperty&);
-    void setPrefixingVariantProperty(const CSSProperty&);
-    void setProperty(const CSSProperty&, CSSProperty* slot = 0);
+    bool setProperty(const CSSProperty&, CSSProperty* slot = nullptr);
 
-    bool removeProperty(CSSPropertyID, String* returnText = 0);
-    void removePrefixedOrUnprefixedProperty(CSSPropertyID);
+    bool removeProperty(CSSPropertyID, String* returnText = nullptr);
     void removeBlockProperties();
     bool removePropertiesInSet(const CSSPropertyID* set, unsigned length);
 
     void mergeAndOverrideOnConflict(const StyleProperties&);
 
     void clear();
-    void parseDeclaration(const String& styleDeclaration, StyleSheetContents* contextStyleSheet);
+    bool parseDeclaration(const String& styleDeclaration, CSSParserContext);
 
-    WEBCORE_EXPORT CSSStyleDeclaration* ensureCSSStyleDeclaration();
-    CSSStyleDeclaration* ensureInlineCSSStyleDeclaration(StyledElement* parentElement);
+    WEBCORE_EXPORT CSSStyleDeclaration& ensureCSSStyleDeclaration();
+    CSSStyleDeclaration& ensureInlineCSSStyleDeclaration(StyledElement& parentElement);
 
     int findPropertyIndex(CSSPropertyID) const;
-
+    int findCustomPropertyIndex(const String& propertyName) const;
+    
     Vector<CSSProperty, 4> m_propertyVector;
 
+    // Methods for querying and altering CSS custom properties.
+    bool setCustomProperty(const Document*, const String& propertyName, const String& value, bool important, CSSParserContext);
+    bool removeCustomProperty(const String& propertyName, String* returnText = nullptr);
+
 private:
     explicit MutableStyleProperties(CSSParserMode);
     explicit MutableStyleProperties(const StyleProperties&);
@@ -231,11 +259,26 @@ private:
 
     bool removeShorthandProperty(CSSPropertyID);
     CSSProperty* findCSSPropertyWithID(CSSPropertyID);
+    CSSProperty* findCustomCSSPropertyWithName(const String&);
     std::unique_ptr<PropertySetCSSStyleDeclaration> m_cssomWrapper;
 
     friend class StyleProperties;
 };
 
+class DeferredStyleProperties final : public StylePropertiesBase {
+public:
+    WEBCORE_EXPORT ~DeferredStyleProperties();
+    static Ref<DeferredStyleProperties> create(const CSSParserTokenRange&, CSSDeferredParser&);
+
+    Ref<ImmutableStyleProperties> parseDeferredProperties();
+    
+private:
+    DeferredStyleProperties(const CSSParserTokenRange&, CSSDeferredParser&);
+    
+    Vector<CSSParserToken> m_tokens;
+    Ref<CSSDeferredParser> m_parser;
+};
+
 inline ImmutableStyleProperties::PropertyReference ImmutableStyleProperties::propertyAt(unsigned index) const
 {
     return PropertyReference(metadataArray()[index], valueArray()[index]);
@@ -261,15 +304,17 @@ inline unsigned StyleProperties::propertyCount() const
     return downcast<ImmutableStyleProperties>(*this).propertyCount();
 }
 
-inline void StyleProperties::deref()
+inline void StylePropertiesBase::deref()
 {
     if (!derefBase())
         return;
 
     if (is<MutableStyleProperties>(*this))
         delete downcast<MutableStyleProperties>(this);
-    else
+    else if (is<ImmutableStyleProperties>(*this))
         delete downcast<ImmutableStyleProperties>(this);
+    else
+        delete downcast<DeferredStyleProperties>(this);
 }
 
 inline int StyleProperties::findPropertyIndex(CSSPropertyID propertyID) const
@@ -279,14 +324,27 @@ inline int StyleProperties::findPropertyIndex(CSSPropertyID propertyID) const
     return downcast<ImmutableStyleProperties>(*this).findPropertyIndex(propertyID);
 }
 
+inline int StyleProperties::findCustomPropertyIndex(const String& propertyName) const
+{
+    if (is<MutableStyleProperties>(*this))
+        return downcast<MutableStyleProperties>(*this).findCustomPropertyIndex(propertyName);
+    return downcast<ImmutableStyleProperties>(*this).findCustomPropertyIndex(propertyName);
+}
+
 } // namespace WebCore
 
+SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleProperties)
+    static bool isType(const WebCore::StylePropertiesBase& set) { return set.type() != WebCore::DeferredPropertiesType; }
+SPECIALIZE_TYPE_TRAITS_END()
+
 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::MutableStyleProperties)
-    static bool isType(const WebCore::StyleProperties& set) { return set.isMutable(); }
+    static bool isType(const WebCore::StylePropertiesBase& set) { return set.type() == WebCore::MutablePropertiesType; }
 SPECIALIZE_TYPE_TRAITS_END()
 
 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::ImmutableStyleProperties)
-    static bool isType(const WebCore::StyleProperties& set) { return !set.isMutable(); }
+    static bool isType(const WebCore::StylePropertiesBase& set) { return set.type() == WebCore::ImmutablePropertiesType; }
 SPECIALIZE_TYPE_TRAITS_END()
 
-#endif // StyleProperties_h
+SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::DeferredStyleProperties)
+    static bool isType(const WebCore::StylePropertiesBase& set) { return set.type() == WebCore::DeferredPropertiesType; }
+SPECIALIZE_TYPE_TRAITS_END()