Source/WebCore/css/StyleResolver.h

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public License
  16  * along with this library; see the file COPYING.LIB.  If not, write to
  17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  *
  20  */
  21
  22 #ifndef StyleResolver_h
  23 #define StyleResolver_h
  24
  25 #include "CSSToStyleMap.h"
  26 #include "CSSValueList.h"
  27 #include "DocumentRuleSets.h"
  28 #include "InspectorCSSOMWrappers.h"
  29 #include "LinkHash.h"
  30 #include "MediaQueryExp.h"
  31 #include "RenderStyle.h"
  32 #include "RuleFeature.h"
  33 #include "RuleSet.h"
  34 #include "RuntimeEnabledFeatures.h"
  35 #include "ScrollTypes.h"
  36 #include "SelectorChecker.h"
  37 #include "SelectorFilter.h"
  38 #include "StyleInheritedData.h"
  39 #include "StyleScopeResolver.h"
  40 #include "ViewportStyleResolver.h"
  41 #if ENABLE(CSS_FILTERS) && ENABLE(SVG)
  42 #include "WebKitCSSSVGDocumentValue.h"
  43 #endif
  44 #if ENABLE(CSS_SHADERS)
  45 #include "CustomFilterConstants.h"
  46 #endif
  47 #include <wtf/HashMap.h>
  48 #include <wtf/HashSet.h>
  49 #include <wtf/RefPtr.h>
  50 #include <wtf/Vector.h>
  51 #include <wtf/text/AtomicStringHash.h>
  52 #include <wtf/text/StringHash.h>
  53
  54 namespace WebCore {
  55
  56 class CSSCursorImageValue;
  57 class CSSFontSelector;
  58 class CSSFontFace;
  59 class CSSFontFaceRule;
  60 class CSSImageGeneratorValue;
  61 class CSSImageSetValue;
  62 class CSSImageValue;
  63 class CSSPageRule;
  64 class CSSPrimitiveValue;
  65 class CSSProperty;
  66 class CSSSelector;
  67 class CSSStyleSheet;
  68 class CSSValue;
  69 class ContainerNode;
  70 class CustomFilterOperation;
  71 class CustomFilterParameter;
  72 class CustomFilterParameterList;
  73 class CustomFilterProgram;
  74 struct CustomFilterProgramMixSettings;
  75 class Document;
  76 class DeprecatedStyleBuilder;
  77 class Element;
  78 class Frame;
  79 class FrameView;
  80 class URL;
  81 class KeyframeList;
  82 class KeyframeValue;
  83 class MediaQueryEvaluator;
  84 class Node;
  85 class RenderRegion;
  86 class RenderScrollbar;
  87 class RuleData;
  88 class RuleSet;
  89 class Settings;
  90 class StyleCustomFilterProgramCache;
  91 class StyleScopeResolver;
  92 class StyleImage;
  93 class StyleKeyframe;
  94 class StylePendingImage;
  95 class StyleProperties;
  96 class StyleRule;
  97 #if ENABLE(SHADOW_DOM)
  98 class StyleRuleHost;
  99 #endif
 100 class StyleRuleKeyframes;
 101 class StyleRulePage;
 102 class StyleRuleRegion;
 103 class StyleShader;
 104 class StyleSheet;
 105 class StyleSheetList;
 106 class StyledElement;
 107 class ViewportStyleResolver;
 108 class WebKitCSSFilterValue;
 109 class WebKitCSSShaderValue;
 110 class WebKitCSSSVGDocumentValue;
 111
 112 class MediaQueryResult {
 113     WTF_MAKE_NONCOPYABLE(MediaQueryResult); WTF_MAKE_FAST_ALLOCATED;
 114 public:
 115     MediaQueryResult(const MediaQueryExp& expr, bool result)
 116         : m_expression(expr)
 117         , m_result(result)
 118     {
 119     }
 120
 121     MediaQueryExp m_expression;
 122     bool m_result;
 123 };
 124
 125 enum StyleSharingBehavior {
 126     AllowStyleSharing,
 127     DisallowStyleSharing,
 128 };
 129
 130 // MatchOnlyUserAgentRules is used in media queries, where relative units
 131 // are interpreted according to the document root element style, and styled only
 132 // from the User Agent Stylesheet rules.
 133
 134 enum RuleMatchingBehavior {
 135     MatchAllRules,
 136     MatchAllRulesExcludingSMIL,
 137     MatchOnlyUserAgentRules,
 138 };
 139
 140 class PseudoStyleRequest {
 141 public:
 142     PseudoStyleRequest(PseudoId pseudoId, RenderScrollbar* scrollbar = 0, ScrollbarPart scrollbarPart = NoPart)
 143         : pseudoId(pseudoId)
 144         , scrollbarPart(scrollbarPart)
 145         , scrollbar(scrollbar)
 146     {
 147     }
 148
 149     PseudoId pseudoId;
 150     ScrollbarPart scrollbarPart;
 151     RenderScrollbar* scrollbar;
 152 };
 153
 154 // This class selects a RenderStyle for a given element based on a collection of stylesheets.
 155 class StyleResolver {
 156     WTF_MAKE_NONCOPYABLE(StyleResolver); WTF_MAKE_FAST_ALLOCATED;
 157 public:
 158     StyleResolver(Document&, bool matchAuthorAndUserStyles);
 159     ~StyleResolver();
 160
 161     // Using these during tree walk will allow style selector to optimize child and descendant selector lookups.
 162     void pushParentElement(Element*);
 163     void popParentElement(Element*);
 164     void pushParentShadowRoot(const ShadowRoot*);
 165     void popParentShadowRoot(const ShadowRoot*);
 166 #if ENABLE(SHADOW_DOM)
 167     void addHostRule(StyleRuleHost* rule, bool hasDocumentSecurityOrigin, const ContainerNode* scope) { ensureScopeResolver()->addHostRule(rule, hasDocumentSecurityOrigin, scope); }
 168 #endif
 169
 170     PassRef<RenderStyle> styleForElement(Element*, RenderStyle* parentStyle = 0, StyleSharingBehavior = AllowStyleSharing,
 171         RuleMatchingBehavior = MatchAllRules, RenderRegion* regionForStyling = 0);
 172
 173     void keyframeStylesForAnimation(Element*, const RenderStyle*, KeyframeList&);
 174
 175     PassRefPtr<RenderStyle> pseudoStyleForElement(Element*, const PseudoStyleRequest&, RenderStyle* parentStyle);
 176
 177     PassRef<RenderStyle> styleForPage(int pageIndex);
 178     PassRef<RenderStyle> defaultStyleForElement();
 179
 180     RenderStyle* style() const { return m_state.style(); }
 181     RenderStyle* parentStyle() const { return m_state.parentStyle(); }
 182     RenderStyle* rootElementStyle() const { return m_state.rootElementStyle(); }
 183     Element* element() { return m_state.element(); }
 184     Document& document() { return m_document; }
 185     StyleScopeResolver* scopeResolver() const { return m_scopeResolver.get(); }
 186     bool hasParentNode() const { return m_state.parentNode(); }
 187
 188     // FIXME: It could be better to call m_ruleSets.appendAuthorStyleSheets() directly after we factor StyleRsolver further.
 189     // https://bugs.webkit.org/show_bug.cgi?id=108890
 190     void appendAuthorStyleSheets(unsigned firstNew, const Vector<RefPtr<CSSStyleSheet>>&);
 191
 192     DocumentRuleSets& ruleSets() { return m_ruleSets; }
 193     const DocumentRuleSets& ruleSets() const { return m_ruleSets; }
 194     SelectorFilter& selectorFilter() { return m_selectorFilter; }
 195
 196 #if ENABLE(SHADOW_DOM)
 197     StyleScopeResolver* ensureScopeResolver()
 198     {
 199         ASSERT(RuntimeEnabledFeatures::sharedFeatures().shadowDOMEnabled());
 200         if (!m_scopeResolver)
 201             m_scopeResolver = adoptPtr(new StyleScopeResolver());
 202         return m_scopeResolver.get();
 203     }
 204 #endif
 205
 206 private:
 207     void initElement(Element*);
 208     RenderStyle* locateSharedStyle();
 209     bool styleSharingCandidateMatchesRuleSet(RuleSet*);
 210     bool styleSharingCandidateMatchesHostRules();
 211     Node* locateCousinList(Element* parent, unsigned& visitedNodeCount) const;
 212     StyledElement* findSiblingForStyleSharing(Node*, unsigned& count) const;
 213     bool canShareStyleWithElement(StyledElement*) const;
 214
 215     PassRef<RenderStyle> styleForKeyframe(const RenderStyle*, const StyleKeyframe*, KeyframeValue&);
 216
 217 public:
 218     // These methods will give back the set of rules that matched for a given element (or a pseudo-element).
 219     enum CSSRuleFilter {
 220         UAAndUserCSSRules   = 1 << 1,
 221         AuthorCSSRules      = 1 << 2,
 222         EmptyCSSRules       = 1 << 3,
 223         CrossOriginCSSRules = 1 << 4,
 224         AllButEmptyCSSRules = UAAndUserCSSRules | AuthorCSSRules | CrossOriginCSSRules,
 225         AllCSSRules         = AllButEmptyCSSRules | EmptyCSSRules,
 226     };
 227     Vector<RefPtr<StyleRuleBase>> styleRulesForElement(Element*, unsigned rulesToInclude = AllButEmptyCSSRules);
 228     Vector<RefPtr<StyleRuleBase>> pseudoStyleRulesForElement(Element*, PseudoId, unsigned rulesToInclude = AllButEmptyCSSRules);
 229
 230 public:
 231     void applyPropertyToStyle(CSSPropertyID, CSSValue*, RenderStyle*);
 232
 233     void applyPropertyToCurrentStyle(CSSPropertyID, CSSValue*);
 234
 235     void updateFont();
 236     void initializeFontStyle(Settings*);
 237
 238     void setFontSize(FontDescription&, float size);
 239
 240 public:
 241     bool useSVGZoomRules();
 242
 243     static bool colorFromPrimitiveValueIsDerivedFromElement(CSSPrimitiveValue*);
 244     Color colorFromPrimitiveValue(CSSPrimitiveValue*, bool forVisitedLink = false) const;
 245
 246     bool hasSelectorForId(const AtomicString&) const;
 247     bool hasSelectorForClass(const AtomicString&) const;
 248     bool hasSelectorForAttribute(const AtomicString&) const;
 249
 250     CSSFontSelector* fontSelector() const { return m_fontSelector.get(); }
 251 #if ENABLE(CSS_DEVICE_ADAPTATION)
 252     ViewportStyleResolver* viewportStyleResolver() { return m_viewportStyleResolver.get(); }
 253 #endif
 254
 255     void addViewportDependentMediaQueryResult(const MediaQueryExp*, bool result);
 256     bool hasViewportDependentMediaQueries() const { return !m_viewportDependentMediaQueryResults.isEmpty(); }
 257     bool affectedByViewportChange() const;
 258
 259     void addKeyframeStyle(PassRefPtr<StyleRuleKeyframes>);
 260
 261     bool checkRegionStyle(Element* regionElement);
 262
 263     bool usesSiblingRules() const { return !m_ruleSets.features().siblingRules.isEmpty(); }
 264     bool usesFirstLineRules() const { return m_ruleSets.features().usesFirstLineRules; }
 265     bool usesBeforeAfterRules() const { return m_ruleSets.features().usesBeforeAfterRules; }
 266
 267     void invalidateMatchedPropertiesCache();
 268
 269 #if ENABLE(CSS_FILTERS)
 270     bool createFilterOperations(CSSValue* inValue, FilterOperations& outOperations);
 271 #if ENABLE(CSS_SHADERS)
 272     StyleShader* styleShader(CSSValue*);
 273     StyleShader* cachedOrPendingStyleShaderFromValue(WebKitCSSShaderValue*);
 274     bool parseCustomFilterParameterList(CSSValue*, CustomFilterParameterList&);
 275     PassRefPtr<CustomFilterParameter> parseCustomFilterParameter(const String& name, CSSValue*);
 276     PassRefPtr<CustomFilterParameter> parseCustomFilterColorParameter(const String& name, CSSValueList*);
 277     PassRefPtr<CustomFilterParameter> parseCustomFilterArrayParameter(const String& name, CSSValueList*, bool);
 278     PassRefPtr<CustomFilterParameter> parseCustomFilterNumberParameter(const String& name, CSSValueList*);
 279     PassRefPtr<CustomFilterParameter> parseCustomFilterTransformParameter(const String& name, CSSValueList*);
 280     PassRefPtr<CustomFilterOperation> createCustomFilterOperationWithAtRuleReferenceSyntax(WebKitCSSFilterValue*);
 281     PassRefPtr<CustomFilterOperation> createCustomFilterOperationWithInlineSyntax(WebKitCSSFilterValue*);
 282     PassRefPtr<CustomFilterOperation> createCustomFilterOperation(WebKitCSSFilterValue*);
 283     void loadPendingShaders();
 284     PassRefPtr<CustomFilterProgram> lookupCustomFilterProgram(WebKitCSSShaderValue* vertexShader, WebKitCSSShaderValue* fragmentShader,
 285         CustomFilterProgramType, const CustomFilterProgramMixSettings&, CustomFilterMeshType);
 286 #endif
 287 #if ENABLE(SVG)
 288     void loadPendingSVGDocuments();
 289 #endif
 290 #endif // ENABLE(CSS_FILTERS)
 291
 292     void loadPendingResources();
 293
 294     int viewportPercentageValue(CSSPrimitiveValue& unit, int percentage);
 295
 296     struct RuleRange {
 297         RuleRange(int& firstRuleIndex, int& lastRuleIndex): firstRuleIndex(firstRuleIndex), lastRuleIndex(lastRuleIndex) { }
 298         int& firstRuleIndex;
 299         int& lastRuleIndex;
 300     };
 301
 302     struct MatchRanges {
 303         MatchRanges() : firstUARule(-1), lastUARule(-1), firstAuthorRule(-1), lastAuthorRule(-1), firstUserRule(-1), lastUserRule(-1) { }
 304         int firstUARule;
 305         int lastUARule;
 306         int firstAuthorRule;
 307         int lastAuthorRule;
 308         int firstUserRule;
 309         int lastUserRule;
 310         RuleRange UARuleRange() { return RuleRange(firstUARule, lastUARule); }
 311         RuleRange authorRuleRange() { return RuleRange(firstAuthorRule, lastAuthorRule); }
 312         RuleRange userRuleRange() { return RuleRange(firstUserRule, lastUserRule); }
 313     };
 314
 315     struct MatchedProperties {
 316         MatchedProperties();
 317         ~MatchedProperties();
 318
 319         RefPtr<StyleProperties> properties;
 320         union {
 321             struct {
 322                 unsigned linkMatchType : 2;
 323                 unsigned whitelistType : 2;
 324             };
 325             // Used to make sure all memory is zero-initialized since we compute the hash over the bytes of this object.
 326             void* possiblyPaddedMember;
 327         };
 328     };
 329
 330     struct MatchResult {
 331         MatchResult() : isCacheable(true) { }
 332         Vector<MatchedProperties, 64> matchedProperties;
 333         Vector<StyleRule*, 64> matchedRules;
 334         MatchRanges ranges;
 335         bool isCacheable;
 336
 337         void addMatchedProperties(const StyleProperties&, StyleRule* = 0, unsigned linkMatchType = SelectorChecker::MatchAll, PropertyWhitelistType = PropertyWhitelistNone);
 338     };
 339
 340 private:
 341     // This function fixes up the default font size if it detects that the current generic font family has changed. -dwh
 342     void checkForGenericFamilyChange(RenderStyle*, RenderStyle* parentStyle);
 343     void checkForZoomChange(RenderStyle*, RenderStyle* parentStyle);
 344 #if ENABLE(IOS_TEXT_AUTOSIZING)
 345     void checkForTextSizeAdjust(RenderStyle*);
 346 #endif
 347
 348     void adjustRenderStyle(RenderStyle& styleToAdjust, const RenderStyle& parentStyle, Element*);
 349     void adjustGridItemPosition(RenderStyle& styleToAdjust, const RenderStyle& parentStyle) const;
 350
 351     bool fastRejectSelector(const RuleData&) const;
 352
 353     void applyMatchedProperties(const MatchResult&, const Element*);
 354
 355     enum StyleApplicationPass {
 356         HighPriorityProperties,
 357         LowPriorityProperties
 358     };
 359     template <StyleApplicationPass pass>
 360     void applyMatchedProperties(const MatchResult&, bool important, int startIndex, int endIndex, bool inheritedOnly);
 361     template <StyleApplicationPass pass>
 362     void applyProperties(const StyleProperties*, StyleRule*, bool isImportant, bool inheritedOnly, PropertyWhitelistType = PropertyWhitelistNone);
 363     static bool isValidRegionStyleProperty(CSSPropertyID);
 364 #if ENABLE(VIDEO_TRACK)
 365     static bool isValidCueStyleProperty(CSSPropertyID);
 366 #endif
 367     void matchPageRules(MatchResult&, RuleSet*, bool isLeftPage, bool isFirstPage, const String& pageName);
 368     void matchPageRulesForList(Vector<StyleRulePage*>& matchedRules, const Vector<StyleRulePage*>&, bool isLeftPage, bool isFirstPage, const String& pageName);
 369     Settings* documentSettings() { return m_document.settings(); }
 370
 371     bool isLeftPage(int pageIndex) const;
 372     bool isRightPage(int pageIndex) const { return !isLeftPage(pageIndex); }
 373     bool isFirstPage(int pageIndex) const;
 374     String pageName(int pageIndex) const;
 375
 376     DocumentRuleSets m_ruleSets;
 377
 378     typedef HashMap<AtomicStringImpl*, RefPtr<StyleRuleKeyframes>> KeyframesRuleMap;
 379     KeyframesRuleMap m_keyframesRuleMap;
 380
 381 public:
 382     typedef HashMap<CSSPropertyID, RefPtr<CSSValue>> PendingImagePropertyMap;
 383 #if ENABLE(CSS_FILTERS) && ENABLE(SVG)
 384     typedef HashMap<FilterOperation*, RefPtr<WebKitCSSSVGDocumentValue>> PendingSVGDocumentMap;
 385 #endif
 386
 387     class State {
 388         WTF_MAKE_NONCOPYABLE(State);
 389     public:
 390         State()
 391         : m_element(0)
 392         , m_styledElement(0)
 393         , m_parentNode(0)
 394         , m_parentStyle(0)
 395         , m_rootElementStyle(0)
 396         , m_regionForStyling(0)
 397         , m_elementLinkState(NotInsideLink)
 398         , m_elementAffectedByClassRules(false)
 399         , m_applyPropertyToRegularStyle(true)
 400         , m_applyPropertyToVisitedLinkStyle(false)
 401 #if ENABLE(CSS_SHADERS)
 402         , m_hasPendingShaders(false)
 403 #endif
 404         , m_lineHeightValue(0)
 405         , m_fontDirty(false)
 406         , m_hasUAAppearance(false)
 407         , m_backgroundData(BackgroundFillLayer) { }
 408
 409     public:
 410         void initElement(Element*);
 411         void initForStyleResolve(Document&, Element*, RenderStyle* parentStyle = 0, RenderRegion* regionForStyling = 0);
 412         void clear();
 413
 414         Document& document() const { return m_element->document(); }
 415         Element* element() const { return m_element; }
 416         StyledElement* styledElement() const { return m_styledElement; }
 417         void setStyle(PassRef<RenderStyle> style) { m_style = std::move(style); }
 418         RenderStyle* style() const { return m_style.get(); }
 419         PassRef<RenderStyle> takeStyle() { return m_style.releaseNonNull(); }
 420
 421         const ContainerNode* parentNode() const { return m_parentNode; }
 422         void setParentStyle(PassRef<RenderStyle> parentStyle) { m_parentStyle = std::move(parentStyle); }
 423         RenderStyle* parentStyle() const { return m_parentStyle.get(); }
 424         RenderStyle* rootElementStyle() const { return m_rootElementStyle; }
 425
 426         const RenderRegion* regionForStyling() const { return m_regionForStyling; }
 427         EInsideLink elementLinkState() const { return m_elementLinkState; }
 428         void setElementAffectedByClassRules(bool isAffected) { m_elementAffectedByClassRules = isAffected; }
 429         bool elementAffectedByClassRules() const { return m_elementAffectedByClassRules; }
 430
 431         void setApplyPropertyToRegularStyle(bool isApply) { m_applyPropertyToRegularStyle = isApply; }
 432         void setApplyPropertyToVisitedLinkStyle(bool isApply) { m_applyPropertyToVisitedLinkStyle = isApply; }
 433         bool applyPropertyToRegularStyle() const { return m_applyPropertyToRegularStyle; }
 434         bool applyPropertyToVisitedLinkStyle() const { return m_applyPropertyToVisitedLinkStyle; }
 435         PendingImagePropertyMap& pendingImageProperties() { return m_pendingImageProperties; }
 436 #if ENABLE(CSS_FILTERS) && ENABLE(SVG)
 437         PendingSVGDocumentMap& pendingSVGDocuments() { return m_pendingSVGDocuments; }
 438 #endif
 439 #if ENABLE(CSS_SHADERS)
 440         void setHasPendingShaders(bool hasPendingShaders) { m_hasPendingShaders = hasPendingShaders; }
 441         bool hasPendingShaders() const { return m_hasPendingShaders; }
 442 #endif
 443
 444         void setLineHeightValue(CSSValue* value) { m_lineHeightValue = value; }
 445         CSSValue* lineHeightValue() { return m_lineHeightValue; }
 446         void setFontDirty(bool isDirty) { m_fontDirty = isDirty; }
 447         bool fontDirty() const { return m_fontDirty; }
 448
 449         void cacheBorderAndBackground();
 450         bool hasUAAppearance() const { return m_hasUAAppearance; }
 451         BorderData borderData() const { return m_borderData; }
 452         FillLayer backgroundData() const { return m_backgroundData; }
 453         Color backgroundColor() const { return m_backgroundColor; }
 454
 455         const FontDescription& fontDescription() { return m_style->fontDescription(); }
 456         const FontDescription& parentFontDescription() { return m_parentStyle->fontDescription(); }
 457         void setFontDescription(const FontDescription& fontDescription) { m_fontDirty |= m_style->setFontDescription(fontDescription); }
 458         void setZoom(float f) { m_fontDirty |= m_style->setZoom(f); }
 459         void setEffectiveZoom(float f) { m_fontDirty |= m_style->setEffectiveZoom(f); }
 460         void setWritingMode(WritingMode writingMode) { m_fontDirty |= m_style->setWritingMode(writingMode); }
 461         void setTextOrientation(TextOrientation textOrientation) { m_fontDirty |= m_style->setTextOrientation(textOrientation); }
 462
 463         bool useSVGZoomRules() const { return m_element && m_element->isSVGElement(); }
 464
 465     private:
 466         // FIXME(bug 108563): to make it easier to review, these member
 467         // variables are public. However we should add methods to access
 468         // these variables.
 469         Element* m_element;
 470         RefPtr<RenderStyle> m_style;
 471         StyledElement* m_styledElement;
 472         ContainerNode* m_parentNode;
 473         RefPtr<RenderStyle> m_parentStyle;
 474         RenderStyle* m_rootElementStyle;
 475
 476         // Required to ASSERT in applyProperties.
 477         RenderRegion* m_regionForStyling;
 478
 479         EInsideLink m_elementLinkState;
 480
 481         bool m_elementAffectedByClassRules;
 482
 483         bool m_applyPropertyToRegularStyle;
 484         bool m_applyPropertyToVisitedLinkStyle;
 485
 486         PendingImagePropertyMap m_pendingImageProperties;
 487 #if ENABLE(CSS_SHADERS)
 488         bool m_hasPendingShaders;
 489 #endif
 490 #if ENABLE(CSS_FILTERS) && ENABLE(SVG)
 491         PendingSVGDocumentMap m_pendingSVGDocuments;
 492 #endif
 493         CSSValue* m_lineHeightValue;
 494         bool m_fontDirty;
 495
 496         bool m_hasUAAppearance;
 497         BorderData m_borderData;
 498         FillLayer m_backgroundData;
 499         Color m_backgroundColor;
 500     };
 501
 502     static RenderStyle* styleNotYetAvailable() { return s_styleNotYetAvailable; }
 503
 504     PassRefPtr<StyleImage> styleImage(CSSPropertyID, CSSValue*);
 505     PassRefPtr<StyleImage> cachedOrPendingFromValue(CSSPropertyID, CSSImageValue*);
 506     PassRefPtr<StyleImage> generatedOrPendingFromValue(CSSPropertyID, CSSImageGeneratorValue&);
 507 #if ENABLE(CSS_IMAGE_SET)
 508     PassRefPtr<StyleImage> setOrPendingFromValue(CSSPropertyID, CSSImageSetValue*);
 509 #endif
 510     PassRefPtr<StyleImage> cursorOrPendingFromValue(CSSPropertyID, CSSCursorImageValue*);
 511
 512     bool applyPropertyToRegularStyle() const { return m_state.applyPropertyToRegularStyle(); }
 513     bool applyPropertyToVisitedLinkStyle() const { return m_state.applyPropertyToVisitedLinkStyle(); }
 514
 515     static Length convertToIntLength(const CSSPrimitiveValue*, const RenderStyle*, const RenderStyle* rootStyle, double multiplier = 1);
 516     static Length convertToFloatLength(const CSSPrimitiveValue*, const RenderStyle*, const RenderStyle* rootStyle, double multiplier = 1);
 517
 518     CSSToStyleMap* styleMap() { return &m_styleMap; }
 519     InspectorCSSOMWrappers& inspectorCSSOMWrappers() { return m_inspectorCSSOMWrappers; }
 520     const FontDescription& fontDescription() { return m_state.fontDescription(); }
 521     const FontDescription& parentFontDescription() { return m_state.parentFontDescription(); }
 522     void setFontDescription(const FontDescription& fontDescription) { m_state.setFontDescription(fontDescription); }
 523     void setZoom(float f) { m_state.setZoom(f); }
 524     void setEffectiveZoom(float f) { m_state.setEffectiveZoom(f); }
 525     void setWritingMode(WritingMode writingMode) { m_state.setWritingMode(writingMode); }
 526     void setTextOrientation(TextOrientation textOrientation) { m_state.setTextOrientation(textOrientation); }
 527
 528 private:
 529     static RenderStyle* s_styleNotYetAvailable;
 530
 531     void cacheBorderAndBackground();
 532
 533 private:
 534     bool canShareStyleWithControl(StyledElement*) const;
 535
 536     void applyProperty(CSSPropertyID, CSSValue*);
 537
 538 #if ENABLE(SVG)
 539     void applySVGProperty(CSSPropertyID, CSSValue*);
 540 #endif
 541
 542     PassRefPtr<StyleImage> loadPendingImage(StylePendingImage*);
 543     void loadPendingImages();
 544 #if ENABLE(CSS_SHAPES)
 545     void loadPendingShapeImage(ShapeValue*);
 546 #endif
 547
 548     static unsigned computeMatchedPropertiesHash(const MatchedProperties*, unsigned size);
 549     struct MatchedPropertiesCacheItem {
 550         Vector<MatchedProperties> matchedProperties;
 551         MatchRanges ranges;
 552         RefPtr<RenderStyle> renderStyle;
 553         RefPtr<RenderStyle> parentRenderStyle;
 554     };
 555     const MatchedPropertiesCacheItem* findFromMatchedPropertiesCache(unsigned hash, const MatchResult&);
 556     void addToMatchedPropertiesCache(const RenderStyle*, const RenderStyle* parentStyle, unsigned hash, const MatchResult&);
 557
 558     // Every N additions to the matched declaration cache trigger a sweep where entries holding
 559     // the last reference to a style declaration are garbage collected.
 560     void sweepMatchedPropertiesCache(Timer<StyleResolver>*);
 561
 562     bool classNamesAffectedByRules(const SpaceSplitString&) const;
 563     bool sharingCandidateHasIdenticalStyleAffectingAttributes(StyledElement*) const;
 564
 565
 566     unsigned m_matchedPropertiesCacheAdditionsSinceLastSweep;
 567
 568     typedef HashMap<unsigned, MatchedPropertiesCacheItem> MatchedPropertiesCache;
 569     MatchedPropertiesCache m_matchedPropertiesCache;
 570
 571     Timer<StyleResolver> m_matchedPropertiesCacheSweepTimer;
 572
 573     OwnPtr<MediaQueryEvaluator> m_medium;
 574     RefPtr<RenderStyle> m_rootDefaultStyle;
 575
 576     Document& m_document;
 577     SelectorFilter m_selectorFilter;
 578
 579     bool m_matchAuthorAndUserStyles;
 580
 581     RefPtr<CSSFontSelector> m_fontSelector;
 582     Vector<OwnPtr<MediaQueryResult>> m_viewportDependentMediaQueryResults;
 583
 584 #if ENABLE(CSS_DEVICE_ADAPTATION)
 585     RefPtr<ViewportStyleResolver> m_viewportStyleResolver;
 586 #endif
 587
 588     const DeprecatedStyleBuilder& m_deprecatedStyleBuilder;
 589
 590     OwnPtr<StyleScopeResolver> m_scopeResolver;
 591     CSSToStyleMap m_styleMap;
 592     InspectorCSSOMWrappers m_inspectorCSSOMWrappers;
 593
 594     State m_state;
 595
 596 #if ENABLE(CSS_SHADERS)
 597     OwnPtr<StyleCustomFilterProgramCache> m_customFilterProgramCache;
 598 #endif
 599
 600     friend class DeprecatedStyleBuilder;
 601     friend bool operator==(const MatchedProperties&, const MatchedProperties&);
 602     friend bool operator!=(const MatchedProperties&, const MatchedProperties&);
 603     friend bool operator==(const MatchRanges&, const MatchRanges&);
 604     friend bool operator!=(const MatchRanges&, const MatchRanges&);
 605 };
 606
 607 inline bool StyleResolver::hasSelectorForAttribute(const AtomicString &attributeName) const
 608 {
 609     ASSERT(!attributeName.isEmpty());
 610     return m_ruleSets.features().attrsInRules.contains(attributeName.impl());
 611 }
 612
 613 inline bool StyleResolver::hasSelectorForClass(const AtomicString& classValue) const
 614 {
 615     ASSERT(!classValue.isEmpty());
 616     return m_ruleSets.features().classesInRules.contains(classValue.impl());
 617 }
 618
 619 inline bool StyleResolver::hasSelectorForId(const AtomicString& idValue) const
 620 {
 621     ASSERT(!idValue.isEmpty());
 622     return m_ruleSets.features().idsInRules.contains(idValue.impl());
 623 }
 624
 625 inline bool checkRegionSelector(const CSSSelector* regionSelector, Element* regionElement)
 626 {
 627     if (!regionSelector || !regionElement)
 628         return false;
 629
 630     SelectorChecker selectorChecker(regionElement->document(), SelectorChecker::QueryingRules);
 631     for (const CSSSelector* s = regionSelector; s; s = CSSSelectorList::next(s)) {
 632         SelectorChecker::SelectorCheckingContext selectorCheckingContext(s, regionElement, SelectorChecker::VisitedMatchDisabled);
 633         PseudoId ignoreDynamicPseudo = NOPSEUDO;
 634         if (selectorChecker.match(selectorCheckingContext, ignoreDynamicPseudo))
 635             return true;
 636     }
 637     return false;
 638 }
 639
 640 class StyleResolverParentPusher {
 641 public:
 642     StyleResolverParentPusher(Element* parent)
 643         : m_parent(parent)
 644         , m_pushedStyleResolver(0)
 645     { }
 646     void push()
 647     {
 648         if (m_pushedStyleResolver)
 649             return;
 650         m_pushedStyleResolver = &m_parent->document().ensureStyleResolver();
 651         m_pushedStyleResolver->pushParentElement(m_parent);
 652     }
 653     ~StyleResolverParentPusher()
 654     {
 655         if (!m_pushedStyleResolver)
 656             return;
 657         // This tells us that our pushed style selector is in a bad state,
 658         // so we should just bail out in that scenario.
 659         ASSERT(m_pushedStyleResolver == &m_parent->document().ensureStyleResolver());
 660         if (m_pushedStyleResolver != &m_parent->document().ensureStyleResolver())
 661             return;
 662         m_pushedStyleResolver->popParentElement(m_parent);
 663     }
 664
 665 private:
 666     Element* m_parent;
 667     StyleResolver* m_pushedStyleResolver;
 668 };
 669
 670 } // namespace WebCore
 671
 672 #endif // StyleResolver_h