Imported WebKit commit 7e538425aa020340619e927792f3d895061fb54b (http://svn.webkit.org/repository/webkit/trunk@116286)

1 files changed, 161 insertions, 58 deletions

diff --git a/Source/WebCore/css/CSSStyleSheet.h b/Source/WebCore/css/CSSStyleSheet.h
index e73491918..9bd30578b 100644
--- a/Source/WebCore/css/CSSStyleSheet.h
+++ b/Source/WebCore/css/CSSStyleSheet.h
@@ -1,6 +1,6 @@
 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
- * Copyright (C) 2004, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2006, 2007, 2008, 2009, 2010, 2012 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
@@ -21,117 +21,220 @@
 #ifndef CSSStyleSheet_h
 #define CSSStyleSheet_h
 
-#include "CSSRuleList.h"
+#include "CSSParserMode.h"
 #include "StyleSheet.h"
+#include <wtf/HashMap.h>
+#include <wtf/text/AtomicStringHash.h>
 
 namespace WebCore {
 
-struct CSSNamespace;
+class CSSCharsetRule;
+class CSSImportRule;
 class CSSParser;
 class CSSRule;
+class CSSRuleList;
+class CSSStyleSheet;
 class CachedCSSStyleSheet;
 class CachedResourceLoader;
 class Document;
+class MediaQuerySet;
+class SecurityOrigin;
+class StyleRuleBase;
+class StyleRuleImport;
 
 typedef int ExceptionCode;
 
-class CSSStyleSheet : public StyleSheet {
+class StyleSheetInternal : public RefCounted<StyleSheetInternal> {
 public:
-    static PassRefPtr<CSSStyleSheet> create()
-    {
-        return adoptRef(new CSSStyleSheet(static_cast<CSSImportRule*>(0), String(), KURL(), String()));
-    }
-    static PassRefPtr<CSSStyleSheet> create(Node* ownerNode)
-    {
-        return adoptRef(new CSSStyleSheet(ownerNode, String(), KURL(), String()));
-    }
-    static PassRefPtr<CSSStyleSheet> create(Node* ownerNode, const String& originalURL, const KURL& finalURL, const String& charset)
-    {
-        return adoptRef(new CSSStyleSheet(ownerNode, originalURL, finalURL, charset));
-    }
-    static PassRefPtr<CSSStyleSheet> create(CSSImportRule* ownerRule, const String& originalURL, const KURL& finalURL, const String& charset)
+    static PassRefPtr<StyleSheetInternal> create(const CSSParserContext& context = CSSParserContext(CSSStrictMode))
     {
-        return adoptRef(new CSSStyleSheet(ownerRule, originalURL, finalURL, charset));
+        return adoptRef(new StyleSheetInternal(0, String(), KURL(), context));
     }
-    static PassRefPtr<CSSStyleSheet> createInline(Node* ownerNode, const KURL& finalURL)
+    static PassRefPtr<StyleSheetInternal> create(const String& originalURL, const KURL& finalURL, const CSSParserContext& context)
     {
-        return adoptRef(new CSSStyleSheet(ownerNode, finalURL.string(), finalURL, String()));
+        return adoptRef(new StyleSheetInternal(0, originalURL, finalURL, context));
     }
-
-    virtual ~CSSStyleSheet();
-
-    CSSStyleSheet* parentStyleSheet() const
+    static PassRefPtr<StyleSheetInternal> create(StyleRuleImport* ownerRule, const String& originalURL, const KURL& finalURL, const CSSParserContext& context)
     {
-        StyleSheet* parentSheet = StyleSheet::parentStyleSheet();
-        ASSERT(!parentSheet || parentSheet->isCSSStyleSheet());
-        return static_cast<CSSStyleSheet*>(parentSheet);
+        return adoptRef(new StyleSheetInternal(ownerRule, originalURL, finalURL, context));
     }
 
-    PassRefPtr<CSSRuleList> cssRules(bool omitCharsetRules = false);
-    unsigned insertRule(const String& rule, unsigned index, ExceptionCode&);
-    void deleteRule(unsigned index, ExceptionCode&);
+    ~StyleSheetInternal();
+    
+    const CSSParserContext& parserContext() const { return m_parserContext; }
 
-    // IE Extensions
-    PassRefPtr<CSSRuleList> rules() { return cssRules(true); }
-    int addRule(const String& selector, const String& style, int index, ExceptionCode&);
-    int addRule(const String& selector, const String& style, ExceptionCode&);
-    void removeRule(unsigned index, ExceptionCode& ec) { deleteRule(index, ec); }
-
-    void addNamespace(CSSParser*, const AtomicString& prefix, const AtomicString& uri);
     const AtomicString& determineNamespace(const AtomicString& prefix);
 
     void styleSheetChanged();
 
-    virtual bool parseString(const String&, bool strict = true);
+    void parseAuthorStyleSheet(const CachedCSSStyleSheet*, const SecurityOrigin*);
+    bool parseString(const String&);
+    bool parseStringAtLine(const String&, int startLineNumber);
 
-    bool parseStringAtLine(const String&, bool strict, int startLineNumber);
+    bool isCacheable() const;
 
-    virtual bool isLoading();
+    bool isLoading() const;
 
     void checkLoaded();
     void startLoadingDynamicSheet();
 
-    Node* findStyleSheetOwnerNode() const;
-    Document* findDocument();
+    StyleSheetInternal* rootStyleSheet() const;
+    Node* singleOwnerNode() const;
+    Document* singleOwnerDocument() const;
 
-    const String& charset() const { return m_charset; }
+    const String& charset() const { return m_parserContext.charset; }
 
     bool loadCompleted() const { return m_loadCompleted; }
 
     KURL completeURL(const String& url) const;
     void addSubresourceStyleURLs(ListHashSet<KURL>&);
 
-    void setStrictParsing(bool b) { m_strictParsing = b; }
-    bool useStrictParsing() const { return m_strictParsing; }
-
     void setIsUserStyleSheet(bool b) { m_isUserStyleSheet = b; }
     bool isUserStyleSheet() const { return m_isUserStyleSheet; }
     void setHasSyntacticallyValidCSSHeader(bool b) { m_hasSyntacticallyValidCSSHeader = b; }
     bool hasSyntacticallyValidCSSHeader() const { return m_hasSyntacticallyValidCSSHeader; }
 
-    void append(PassRefPtr<CSSRule>);
-    void remove(unsigned index);
+    void parserAddNamespace(const AtomicString& prefix, const AtomicString& uri);
+    void parserAppendRule(PassRefPtr<StyleRuleBase>);
+    void parserSetEncodingFromCharsetRule(const String& encoding); 
+    void parserSetUsesRemUnits(bool b) { m_usesRemUnits = b; }
 
-    unsigned length() const { return m_children.size(); }
-    CSSRule* item(unsigned index) { return index < length() ? m_children.at(index).get() : 0; }
+    void clearRules();
+
+    // Rules other than @charset and @import.
+    const Vector<RefPtr<StyleRuleBase> >& childRules() const { return m_childRules; }
+    const Vector<RefPtr<StyleRuleImport> >& importRules() const { return m_importRules; }
 
     void notifyLoadedSheet(const CachedCSSStyleSheet*);
+    
+    StyleSheetInternal* parentStyleSheet() const;
+    StyleRuleImport* ownerRule() const { return m_ownerRule; }
+    void clearOwnerRule() { m_ownerRule = 0; }
+    
+    // Note that href is the URL that started the redirect chain that led to
+    // this style sheet. This property probably isn't useful for much except
+    // the JavaScript binding (which needs to use this value for security).
+    String originalURL() const { return m_originalURL; }
+    
+    const KURL& finalURL() const { return m_finalURL; }
+    const KURL& baseURL() const { return m_parserContext.baseURL; }
+
+    unsigned ruleCount() const;
+    
+    bool usesRemUnits() const { return m_usesRemUnits; }
+
+    unsigned estimatedSizeInBytes() const;
+    
+    bool wrapperInsertRule(PassRefPtr<StyleRuleBase>, unsigned index);
+    void wrapperDeleteRule(unsigned index);
+
+    PassRefPtr<CSSRule> createChildRuleCSSOMWrapper(unsigned index, CSSStyleSheet* parentWrapper);
+
+    PassRefPtr<StyleSheetInternal> copy() const { return adoptRef(new StyleSheetInternal(*this)); }
+
+    void registerClient(CSSStyleSheet*);
+    void unregisterClient(CSSStyleSheet*);
 
 private:
-    CSSStyleSheet(Node* ownerNode, const String& originalURL, const KURL& finalURL, const String& charset);
-    CSSStyleSheet(CSSImportRule* ownerRule, const String& originalURL, const KURL& finalURL, const String& charset);
+    StyleSheetInternal(StyleRuleImport* ownerRule, const String& originalURL, const KURL& baseURL, const CSSParserContext&);
+    StyleSheetInternal(const StyleSheetInternal&);
 
-    virtual bool isCSSStyleSheet() const { return true; }
-    virtual String type() const { return "text/css"; }
+    void clearCharsetRule();
+    bool hasCharsetRule() const { return !m_encodingFromCharsetRule.isNull(); }
+
+    StyleRuleImport* m_ownerRule;
+
+    String m_originalURL;
+    KURL m_finalURL;
+
+    String m_encodingFromCharsetRule;
+    Vector<RefPtr<StyleRuleImport> > m_importRules;
+    Vector<RefPtr<StyleRuleBase> > m_childRules;
+    typedef HashMap<AtomicString, AtomicString> PrefixNamespaceURIMap;
+    PrefixNamespaceURIMap m_namespaces;
 
-    Vector<RefPtr<CSSRule> > m_children;
-    OwnPtr<CSSNamespace> m_namespaces;
-    String m_charset;
     bool m_loadCompleted : 1;
-    bool m_strictParsing : 1;
     bool m_isUserStyleSheet : 1;
     bool m_hasSyntacticallyValidCSSHeader : 1;
     bool m_didLoadErrorOccur : 1;
+    bool m_usesRemUnits : 1;
+    bool m_hasMutated : 1;
+    
+    CSSParserContext m_parserContext;
+
+    Vector<CSSStyleSheet*> m_clients;
+};
+
+class CSSStyleSheet : public StyleSheet {
+public:
+    static RefPtr<CSSStyleSheet> create(PassRefPtr<StyleSheetInternal> sheet, CSSImportRule* ownerRule = 0) 
+    { 
+        return adoptRef(new CSSStyleSheet(sheet, ownerRule));
+    }
+    static RefPtr<CSSStyleSheet> create(PassRefPtr<StyleSheetInternal> sheet, Node* ownerNode)
+    { 
+        return adoptRef(new CSSStyleSheet(sheet, ownerNode));
+    }
+    static PassRefPtr<CSSStyleSheet> createInline(Node*, const KURL&, const String& encoding = String());
+
+    virtual ~CSSStyleSheet();
+
+    virtual CSSStyleSheet* parentStyleSheet() const OVERRIDE;
+    virtual Node* ownerNode() const OVERRIDE { return m_ownerNode; }
+    virtual MediaList* media() const OVERRIDE;
+    virtual String href() const OVERRIDE { return m_internal->originalURL(); }  
+    virtual String title() const OVERRIDE { return m_title; }
+    virtual bool disabled() const OVERRIDE { return m_isDisabled; }
+    virtual void setDisabled(bool) OVERRIDE;
+    
+    PassRefPtr<CSSRuleList> cssRules();
+    unsigned insertRule(const String& rule, unsigned index, ExceptionCode&);
+    void deleteRule(unsigned index, ExceptionCode&);
+    
+    // IE Extensions
+    PassRefPtr<CSSRuleList> rules();
+    int addRule(const String& selector, const String& style, int index, ExceptionCode&);
+    int addRule(const String& selector, const String& style, ExceptionCode&);
+    void removeRule(unsigned index, ExceptionCode& ec) { deleteRule(index, ec); }
+    
+    // For CSSRuleList.
+    unsigned length() const;
+    CSSRule* item(unsigned index);
+
+    virtual void clearOwnerNode() OVERRIDE { m_ownerNode = 0; }
+    virtual CSSImportRule* ownerRule() const OVERRIDE { return m_ownerRule; }
+    virtual KURL baseURL() const OVERRIDE { return m_internal->baseURL(); }
+    virtual bool isLoading() const OVERRIDE { return m_internal->isLoading(); }
+    
+    void clearOwnerRule() { m_ownerRule = 0; }
+    void styleSheetChanged() { m_internal->styleSheetChanged(); }
+    Document* ownerDocument() const;
+    MediaQuerySet* mediaQueries() const { return m_mediaQueries.get(); }
+    void setMediaQueries(PassRefPtr<MediaQuerySet>);
+    void setTitle(const String& title) { m_title = title; }
+    
+    void clearChildRuleCSSOMWrappers();
+
+    StyleSheetInternal* internal() const { return m_internal.get(); }
+
+private:
+    CSSStyleSheet(PassRefPtr<StyleSheetInternal>, CSSImportRule* ownerRule);
+    CSSStyleSheet(PassRefPtr<StyleSheetInternal>, Node* ownerNode);
+
+    virtual bool isCSSStyleSheet() const { return true; }
+    virtual String type() const { return "text/css"; }
+    
+    RefPtr<StyleSheetInternal> m_internal;
+    bool m_isDisabled;
+    String m_title;
+    RefPtr<MediaQuerySet> m_mediaQueries;
+
+    Node* m_ownerNode;
+    CSSImportRule* m_ownerRule;
+
+    mutable RefPtr<MediaList> m_mediaCSSOMWrapper;
+    mutable Vector<RefPtr<CSSRule> > m_childRuleCSSOMWrappers;
+    mutable OwnPtr<CSSRuleList> m_ruleListCSSOMWrapper;
 };
 
 } // namespace