1 files changed, 163 insertions, 16 deletions
diff --git a/Source/WebCore/css/StyleRule.h b/Source/WebCore/css/StyleRule.h
index e230a94fd..f3989e0b2 100644
--- a/Source/WebCore/css/StyleRule.h
+++ b/Source/WebCore/css/StyleRule.h
@@ -23,39 +23,186 @@
 #define StyleRule_h
 
 #include "CSSSelectorList.h"
-#include "StylePropertySet.h"
-#include <wtf/PassRefPtr.h>
+#include "MediaList.h"
 #include <wtf/RefPtr.h>
 
 namespace WebCore {
 
+class CSSRule;
 class CSSStyleRule;
+class CSSStyleSheet;
+class StylePropertySet;
 
-class StyleRule {
-    WTF_MAKE_NONCOPYABLE(StyleRule); WTF_MAKE_FAST_ALLOCATED;
+class StyleRuleBase : public WTF::RefCountedBase {
 public:
-    StyleRule(int sourceLine, CSSStyleRule*);
-    ~StyleRule();
-            
-    const CSSSelectorList& selectorList() const { return m_selectorList; }
-    StylePropertySet* properties() const { return m_properties.get(); }
+    enum Type {
+        Unknown, // Not used.
+        Style,
+        Charset, // Not used. These are internally strings owned by the style sheet.
+        Import,
+        Media,
+        FontFace,
+        Page,
+        Keyframes,
+        Keyframe, // Not used. These are internally non-rule StyleKeyframe objects.
+        Region
+    };
+    Type type() const { return static_cast<Type>(m_type); }
     
-    void addSubresourceStyleURLs(ListHashSet<KURL>& urls, CSSStyleSheet*);
+    bool isCharsetRule() const { return type() == Charset; }
+    bool isFontFaceRule() const { return type() == FontFace; }
+    bool isKeyframesRule() const { return type() == Keyframes; }
+    bool isMediaRule() const { return type() == Media; }
+    bool isPageRule() const { return type() == Page; }
+    bool isStyleRule() const { return type() == Style; }
+    bool isRegionRule() const { return type() == Region; }
+    bool isImportRule() const { return type() == Import; }
+
+    PassRefPtr<StyleRuleBase> copy() const;
 
     int sourceLine() const { return m_sourceLine; }
+
+    void deref()
+    {
+        if (derefBase())
+            destroy();
+    }
+
+    // FIXME: There shouldn't be any need for the null parent version.
+    PassRefPtr<CSSRule> createCSSOMWrapper(CSSStyleSheet* parentSheet = 0) const;
+    PassRefPtr<CSSRule> createCSSOMWrapper(CSSRule* parentRule) const;
+
+protected:
+    StyleRuleBase(Type type, signed sourceLine = 0) : m_type(type), m_sourceLine(sourceLine) { }
+    StyleRuleBase(const StyleRuleBase& o) : WTF::RefCountedBase(), m_type(o.m_type), m_sourceLine(o.m_sourceLine) { }
+
+    ~StyleRuleBase() { }
+
+private:
+    void destroy();
     
-    CSSStyleRule* ensureCSSStyleRule() const;
+    PassRefPtr<CSSRule> createCSSOMWrapper(CSSStyleSheet* parentSheet, CSSRule* parentRule) const;
+
+    unsigned m_type : 4;
+    signed m_sourceLine : 28;
+};
+
+class StyleRule : public StyleRuleBase {
+public:
+    static PassRefPtr<StyleRule> create(int sourceLine) { return adoptRef(new StyleRule(sourceLine)); }
     
-    void adoptSelectorVector(Vector<OwnPtr<CSSParserSelector> >& selectors) { m_selectorList.adoptSelectorVector(selectors); }
-    void adoptSelectorList(CSSSelectorList& selectors) { m_selectorList.adopt(selectors); }
-    void setProperties(PassRefPtr<StylePropertySet> properties) { m_properties = properties; }
+    ~StyleRule();
+
+    const CSSSelectorList& selectorList() const { return m_selectorList; }
+    StylePropertySet* properties() const { return m_properties.get(); }
     
+    void parserAdoptSelectorVector(Vector<OwnPtr<CSSParserSelector> >& selectors) { m_selectorList.adoptSelectorVector(selectors); }
+    void wrapperAdoptSelectorList(CSSSelectorList& selectors) { m_selectorList.adopt(selectors); }
+    void setProperties(PassRefPtr<StylePropertySet>);
+
+    PassRefPtr<StyleRule> copy() const { return adoptRef(new StyleRule(*this)); }
+
+    static unsigned averageSizeInBytes();
+
 private:
+    StyleRule(int sourceLine);
+    StyleRule(const StyleRule&);
+
     RefPtr<StylePropertySet> m_properties;
     CSSSelectorList m_selectorList;
-    signed m_sourceLine;
+};
+
+class StyleRuleFontFace : public StyleRuleBase {
+public:
+    static PassRefPtr<StyleRuleFontFace> create() { return adoptRef(new StyleRuleFontFace); }
+    
+    ~StyleRuleFontFace();
+
+    StylePropertySet* properties() const { return m_properties.get(); }
+
+    void setProperties(PassRefPtr<StylePropertySet>);
+
+    PassRefPtr<StyleRuleFontFace> copy() const { return adoptRef(new StyleRuleFontFace(*this)); }
+
+private:
+    StyleRuleFontFace();
+    StyleRuleFontFace(const StyleRuleFontFace&);
 
-    CSSStyleRule* m_cssomWrapper;
+    RefPtr<StylePropertySet> m_properties;
+};
+
+class StyleRulePage : public StyleRuleBase {
+public:
+    static PassRefPtr<StyleRulePage> create() { return adoptRef(new StyleRulePage); }
+
+    ~StyleRulePage();
+
+    const CSSSelector* selector() const { return m_selectorList.first(); }    
+    StylePropertySet* properties() const { return m_properties.get(); }
+
+    void parserAdoptSelectorVector(Vector<OwnPtr<CSSParserSelector> >& selectors) { m_selectorList.adoptSelectorVector(selectors); }
+    void wrapperAdoptSelectorList(CSSSelectorList& selectors) { m_selectorList.adopt(selectors); }
+    void setProperties(PassRefPtr<StylePropertySet>);
+
+    PassRefPtr<StyleRulePage> copy() const { return adoptRef(new StyleRulePage(*this)); }
+
+private:
+    StyleRulePage();
+    StyleRulePage(const StyleRulePage&);
+    
+    RefPtr<StylePropertySet> m_properties;
+    CSSSelectorList m_selectorList;
+};
+
+class StyleRuleBlock : public StyleRuleBase {
+public:
+    const Vector<RefPtr<StyleRuleBase> >& childRules() const { return m_childRules; }
+    
+    void wrapperInsertRule(unsigned, PassRefPtr<StyleRuleBase>);
+    void wrapperRemoveRule(unsigned);
+    
+protected:
+    StyleRuleBlock(Type, Vector<RefPtr<StyleRuleBase> >& adoptRule);
+    StyleRuleBlock(const StyleRuleBlock&);
+    
+private:
+    Vector<RefPtr<StyleRuleBase> > m_childRules;
+};
+
+class StyleRuleMedia : public StyleRuleBlock {
+public:
+    static PassRefPtr<StyleRuleMedia> create(PassRefPtr<MediaQuerySet> media, Vector<RefPtr<StyleRuleBase> >& adoptRules)
+    {
+        return adoptRef(new StyleRuleMedia(media, adoptRules));
+    }
+
+    MediaQuerySet* mediaQueries() const { return m_mediaQueries.get(); }
+
+    PassRefPtr<StyleRuleMedia> copy() const { return adoptRef(new StyleRuleMedia(*this)); }
+
+private:
+    StyleRuleMedia(PassRefPtr<MediaQuerySet>, Vector<RefPtr<StyleRuleBase> >& adoptRules);
+    StyleRuleMedia(const StyleRuleMedia&);
+
+    RefPtr<MediaQuerySet> m_mediaQueries;
+};
+
+class StyleRuleRegion : public StyleRuleBlock {
+public:
+    static PassRefPtr<StyleRuleRegion> create(Vector<OwnPtr<CSSParserSelector> >* selectors, Vector<RefPtr<StyleRuleBase> >& adoptRules)
+    {
+        return adoptRef(new StyleRuleRegion(selectors, adoptRules));
+    }
+
+    const CSSSelectorList& selectorList() const { return m_selectorList; }
+
+    PassRefPtr<StyleRuleRegion> copy() const { return adoptRef(new StyleRuleRegion(*this)); }
+
+private:
+    StyleRuleRegion(Vector<OwnPtr<CSSParserSelector> >*, Vector<RefPtr<StyleRuleBase> >& adoptRules);
+    StyleRuleRegion(const StyleRuleRegion&);
+    
+    CSSSelectorList m_selectorList;
 };
 
 } // namespace WebCore