Merge WebKit at r75315: Initial merge by git.

Change-Id: I570314b346ce101c935ed22a626b48c2af266b84

1 files changed, 320 insertions, 0 deletions

diff --git a/Source/WebCore/css/CSSStyleSelector.h b/Source/WebCore/css/CSSStyleSelector.h
new file mode 100644
index 0000000..b57ba13
--- /dev/null
+++ b/Source/WebCore/css/CSSStyleSelector.h
@@ -0,0 +1,320 @@
+/*
+ * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 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
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef CSSStyleSelector_h
+#define CSSStyleSelector_h
+
+#include "CSSFontSelector.h"
+#include "CSSRule.h"
+#include "LinkHash.h"
+#include "MediaQueryExp.h"
+#include "RenderStyle.h"
+#include <wtf/HashMap.h>
+#include <wtf/HashSet.h>
+#include <wtf/RefPtr.h>
+#include <wtf/Vector.h>
+#include <wtf/text/StringHash.h>
+
+namespace WebCore {
+
+class CSSMutableStyleDeclaration;
+class CSSPageRule;
+class CSSPrimitiveValue;
+class CSSProperty;
+class CSSFontFace;
+class CSSFontFaceRule;
+class CSSImageValue;
+class CSSRuleData;
+class CSSRuleDataList;
+class CSSRuleList;
+class CSSRuleSet;
+class CSSSelector;
+class CSSStyleRule;
+class CSSStyleSheet;
+class CSSValue;
+class ContainerNode;
+class DataGridColumn;
+class Document;
+class Element;
+class Frame;
+class FrameView;
+class KURL;
+class KeyframeList;
+class KeyframeValue;
+class MediaQueryEvaluator;
+class Node;
+class Settings;
+class StyleImage;
+class StyleSheet;
+class StyleSheetList;
+class StyledElement;
+class WebKitCSSKeyframeRule;
+class WebKitCSSKeyframesRule;
+
+class MediaQueryResult : public Noncopyable {
+public:
+    MediaQueryResult(const MediaQueryExp& expr, bool result)
+        : m_expression(expr)
+        , m_result(result)
+    {
+    }
+
+    MediaQueryExp m_expression;
+    bool m_result;
+};
+
+    // This class selects a RenderStyle for a given element based on a collection of stylesheets.
+    class CSSStyleSelector : public Noncopyable {
+    public:
+        CSSStyleSelector(Document*, StyleSheetList* authorSheets, CSSStyleSheet* mappedElementSheet,
+                         CSSStyleSheet* pageUserSheet, const Vector<RefPtr<CSSStyleSheet> >* pageGroupUserSheets,
+                         bool strictParsing, bool matchAuthorAndUserStyles);
+        ~CSSStyleSelector();
+
+        PassRefPtr<RenderStyle> styleForElement(Element* e, RenderStyle* parentStyle = 0, bool allowSharing = true, bool resolveForRootDefault = false, bool matchVisitedPseudoClass = false);
+        
+        void keyframeStylesForAnimation(Element*, const RenderStyle*, KeyframeList& list);
+
+        PassRefPtr<RenderStyle> pseudoStyleForElement(PseudoId pseudo, Element* e, RenderStyle* parentStyle = 0, bool matchVisitedPseudoClass = false);
+
+        PassRefPtr<RenderStyle> styleForPage(int pageIndex);
+
+        static PassRefPtr<RenderStyle> styleForDocument(Document*);
+
+#if ENABLE(DATAGRID)
+        // Datagrid style computation (uses unique pseudo elements and structures)
+        PassRefPtr<RenderStyle> pseudoStyleForDataGridColumn(DataGridColumn*, RenderStyle* parentStyle);
+        PassRefPtr<RenderStyle> pseudoStyleForDataGridColumnHeader(DataGridColumn*, RenderStyle* parentStyle);
+#endif
+
+    private:
+        void initForStyleResolve(Element*, RenderStyle* parentStyle = 0, PseudoId = NOPSEUDO);
+        void initElement(Element*);
+        ALWAYS_INLINE RenderStyle* locateSharedStyle() const;
+        Node* locateCousinList(Element* parent, unsigned depth = 1) const;
+        bool canShareStyleWithElement(Node*) const;
+
+        RenderStyle* style() const { return m_style.get(); }
+
+        PassRefPtr<RenderStyle> styleForKeyframe(const RenderStyle*, const WebKitCSSKeyframeRule*, KeyframeValue&);
+
+    public:
+        // These methods will give back the set of rules that matched for a given element (or a pseudo-element).
+        PassRefPtr<CSSRuleList> styleRulesForElement(Element*, bool authorOnly, bool includeEmptyRules = false, CSSRuleFilter filter = AllCSSRules);
+        PassRefPtr<CSSRuleList> pseudoStyleRulesForElement(Element*, PseudoId, bool authorOnly, bool includeEmptyRules = false, CSSRuleFilter filter = AllCSSRules);
+
+        // Given a CSS keyword in the range (xx-small to -webkit-xxx-large), this function will return
+        // the correct font size scaled relative to the user's default (medium).
+        static float fontSizeForKeyword(Document*, int keyword, bool shouldUseFixedDefaultSize);
+
+        // Given a font size in pixel, this function will return legacy font size between 1 and 7.
+        static int legacyFontSize(Document*, int pixelFontSize, bool shouldUseFixedDefaultSize);
+
+    private:
+
+        // When the CSS keyword "larger" is used, this function will attempt to match within the keyword
+        // table, and failing that, will simply multiply by 1.2.
+        float largerFontSize(float size, bool quirksMode) const;
+
+        // Like the previous function, but for the keyword "smaller".
+        float smallerFontSize(float size, bool quirksMode) const;
+
+    public:
+        void setStyle(PassRefPtr<RenderStyle> s) { m_style = s; } // Used by the document when setting up its root style.
+
+        void applyPropertyToStyle(int id, CSSValue*, RenderStyle*);
+
+    private:
+        void setFontSize(FontDescription&, float size);
+        static float getComputedSizeFromSpecifiedSize(Document*, RenderStyle*, bool isAbsoluteSize, float specifiedSize, bool useSVGZoomRules);
+
+    public:
+        Color getColorFromPrimitiveValue(CSSPrimitiveValue*) const;
+
+        bool hasSelectorForAttribute(const AtomicString&) const;
+ 
+        CSSFontSelector* fontSelector() const { return m_fontSelector.get(); }
+
+        // Checks if a compound selector (which can consist of multiple simple selectors) matches the current element.
+        bool checkSelector(CSSSelector*);
+
+        void addViewportDependentMediaQueryResult(const MediaQueryExp*, bool result);
+
+        bool affectedByViewportChange() const;
+
+        void allVisitedStateChanged() { m_checker.allVisitedStateChanged(); }
+        void visitedStateChanged(LinkHash visitedHash) { m_checker.visitedStateChanged(visitedHash); }
+
+        void addKeyframeStyle(PassRefPtr<WebKitCSSKeyframesRule> rule);
+        void addPageStyle(PassRefPtr<CSSPageRule>);
+
+        static bool createTransformOperations(CSSValue* inValue, RenderStyle* inStyle, RenderStyle* rootStyle, TransformOperations& outOperations);
+
+    private:
+        enum SelectorMatch { SelectorMatches, SelectorFailsLocally, SelectorFailsCompletely };
+
+        // This function fixes up the default font size if it detects that the current generic font family has changed. -dwh
+        void checkForGenericFamilyChange(RenderStyle*, RenderStyle* parentStyle);
+        void checkForZoomChange(RenderStyle*, RenderStyle* parentStyle);
+        void checkForTextSizeAdjust();
+
+        void adjustRenderStyle(RenderStyle* styleToAdjust, RenderStyle* parentStyle, Element*);
+
+        void addMatchedRule(CSSRuleData* rule) { m_matchedRules.append(rule); }
+        void addMatchedDeclaration(CSSMutableStyleDeclaration* decl);
+
+        void matchRules(CSSRuleSet*, int& firstRuleIndex, int& lastRuleIndex, bool includeEmptyRules);
+        void matchRulesForList(CSSRuleDataList*, int& firstRuleIndex, int& lastRuleIndex, bool includeEmptyRules);
+        void sortMatchedRules(unsigned start, unsigned end);
+
+        template <bool firstPass>
+        void applyDeclarations(bool important, int startIndex, int endIndex);
+
+        void matchPageRules(CSSRuleSet*, bool isLeftPage, bool isFirstPage, const String& pageName);
+        void matchPageRulesForList(CSSRuleDataList*, bool isLeftPage, bool isFirstPage, const String& pageName);
+        bool isLeftPage(int pageIndex) const;
+        bool isRightPage(int pageIndex) const { return !isLeftPage(pageIndex); }
+        bool isFirstPage(int pageIndex) const;
+        String pageName(int pageIndex) const;
+        
+        OwnPtr<CSSRuleSet> m_authorStyle;
+        OwnPtr<CSSRuleSet> m_userStyle;
+
+        bool m_hasUAAppearance;
+        BorderData m_borderData;
+        FillLayer m_backgroundData;
+        Color m_backgroundColor;
+
+        typedef HashMap<AtomicStringImpl*, RefPtr<WebKitCSSKeyframesRule> > KeyframesRuleMap;
+        KeyframesRuleMap m_keyframesRuleMap;
+
+    public:
+        static RenderStyle* styleNotYetAvailable() { return s_styleNotYetAvailable; }
+
+        class SelectorChecker : public Noncopyable {
+        public:
+            SelectorChecker(Document*, bool strictParsing);
+
+            bool checkSelector(CSSSelector*, Element*) const;
+            SelectorMatch checkSelector(CSSSelector*, Element*, HashSet<AtomicStringImpl*>* selectorAttrs, PseudoId& dynamicPseudo, bool isSubSelector, bool encounteredLink, RenderStyle* = 0, RenderStyle* elementParentStyle = 0) const;
+            bool checkOneSelector(CSSSelector*, Element*, HashSet<AtomicStringImpl*>* selectorAttrs, PseudoId& dynamicPseudo, bool isSubSelector, RenderStyle*, RenderStyle* elementParentStyle) const;
+            bool checkScrollbarPseudoClass(CSSSelector*, PseudoId& dynamicPseudo) const;
+
+            EInsideLink determineLinkState(Element* element) const;
+            EInsideLink determineLinkStateSlowCase(Element* element) const;
+            void allVisitedStateChanged();
+            void visitedStateChanged(LinkHash visitedHash);
+
+            Document* m_document;
+            bool m_strictParsing;
+            bool m_collectRulesOnly;
+            bool m_sameOriginOnly;
+            PseudoId m_pseudoStyle;
+            bool m_documentIsHTML;
+            mutable bool m_matchVisitedPseudoClass;
+            mutable HashSet<LinkHash, LinkHashHash> m_linksCheckedForVisitedState;
+        };
+
+    private:
+        static RenderStyle* s_styleNotYetAvailable;
+
+        void matchUARules(int& firstUARule, int& lastUARule);
+        void updateFont();
+        void cacheBorderAndBackground();
+
+        void mapFillAttachment(CSSPropertyID, FillLayer*, CSSValue*);
+        void mapFillClip(CSSPropertyID, FillLayer*, CSSValue*);
+        void mapFillComposite(CSSPropertyID, FillLayer*, CSSValue*);
+        void mapFillOrigin(CSSPropertyID, FillLayer*, CSSValue*);
+        void mapFillImage(CSSPropertyID, FillLayer*, CSSValue*);
+        void mapFillRepeatX(CSSPropertyID, FillLayer*, CSSValue*);
+        void mapFillRepeatY(CSSPropertyID, FillLayer*, CSSValue*);
+        void mapFillSize(CSSPropertyID, FillLayer*, CSSValue*);
+        void mapFillXPosition(CSSPropertyID, FillLayer*, CSSValue*);
+        void mapFillYPosition(CSSPropertyID, FillLayer*, CSSValue*);
+
+        void mapAnimationDelay(Animation*, CSSValue*);
+        void mapAnimationDirection(Animation*, CSSValue*);
+        void mapAnimationDuration(Animation*, CSSValue*);
+        void mapAnimationFillMode(Animation*, CSSValue*);
+        void mapAnimationIterationCount(Animation*, CSSValue*);
+        void mapAnimationName(Animation*, CSSValue*);
+        void mapAnimationPlayState(Animation*, CSSValue*);
+        void mapAnimationProperty(Animation*, CSSValue*);
+        void mapAnimationTimingFunction(Animation*, CSSValue*);
+
+        void mapNinePieceImage(CSSPropertyID, CSSValue*, NinePieceImage&);
+
+        void applyProperty(int id, CSSValue*);
+        void applyPageSizeProperty(CSSValue*);
+        bool pageSizeFromName(CSSPrimitiveValue*, CSSPrimitiveValue*, Length& width, Length& height);
+        Length mmLength(double mm) const;
+        Length inchLength(double inch) const;
+#if ENABLE(SVG)
+        void applySVGProperty(int id, CSSValue*);
+#endif
+
+        void loadPendingImages();
+        
+        StyleImage* styleImage(CSSPropertyID, CSSValue* value);
+        StyleImage* cachedOrPendingFromValue(CSSPropertyID property, CSSImageValue* value);
+
+        // We collect the set of decls that match in |m_matchedDecls|.  We then walk the
+        // set of matched decls four times, once for those properties that others depend on (like font-size),
+        // and then a second time for all the remaining properties.  We then do the same two passes
+        // for any !important rules.
+        Vector<CSSMutableStyleDeclaration*, 64> m_matchedDecls;
+
+        // A buffer used to hold the set of matched rules for an element, and a temporary buffer used for
+        // merge sorting.
+        Vector<CSSRuleData*, 32> m_matchedRules;
+
+        RefPtr<CSSRuleList> m_ruleList;
+        
+        HashSet<int> m_pendingImageProperties; // Hash of CSSPropertyIDs
+
+        OwnPtr<MediaQueryEvaluator> m_medium;
+        RefPtr<RenderStyle> m_rootDefaultStyle;
+
+        PseudoId m_dynamicPseudo;
+
+        SelectorChecker m_checker;
+
+        RefPtr<RenderStyle> m_style;
+        RenderStyle* m_parentStyle;
+        RenderStyle* m_rootElementStyle;
+        Element* m_element;
+        StyledElement* m_styledElement;
+        EInsideLink m_elementLinkState;
+        ContainerNode* m_parentNode;
+        CSSValue* m_lineHeightValue;
+        bool m_fontDirty;
+        bool m_matchAuthorAndUserStyles;
+        
+        RefPtr<CSSFontSelector> m_fontSelector;
+        HashSet<AtomicStringImpl*> m_selectorAttrs;
+        Vector<CSSMutableStyleDeclaration*> m_additionalAttributeStyleDecls;
+        Vector<MediaQueryResult*> m_viewportDependentMediaQueryResults;
+    };
+
+} // namespace WebCore
+
+#endif // CSSStyleSelector_h