src/third_party/WebKit/Source/core/css/resolver/StyleResolver.cpp

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
   4  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
   5  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
   6  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
   7  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
   8  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
   9  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  10  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
  11  * Copyright (C) 2012 Google Inc. All rights reserved.
  12  *
  13  * This library is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU Library General Public
  15  * License as published by the Free Software Foundation; either
  16  * version 2 of the License, or (at your option) any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * Library General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Library General Public License
  24  * along with this library; see the file COPYING.LIB.  If not, write to
  25  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  26  * Boston, MA 02110-1301, USA.
  27  */
  28
  29 #include "config.h"
  30 #include "core/css/resolver/StyleResolver.h"
  31
  32 #include "core/CSSPropertyNames.h"
  33 #include "core/HTMLNames.h"
  34 #include "core/StylePropertyShorthand.h"
  35 #include "core/animation/ActiveAnimations.h"
  36 #include "core/animation/AnimatableValue.h"
  37 #include "core/animation/Animation.h"
  38 #include "core/animation/AnimationTimeline.h"
  39 #include "core/animation/css/CSSAnimatableValueFactory.h"
  40 #include "core/animation/css/CSSAnimations.h"
  41 #include "core/animation/interpolation/StyleInterpolation.h"
  42 #include "core/css/CSSCalculationValue.h"
  43 #include "core/css/CSSDefaultStyleSheets.h"
  44 #include "core/css/CSSFontSelector.h"
  45 #include "core/css/CSSKeyframeRule.h"
  46 #include "core/css/CSSKeyframesRule.h"
  47 #include "core/css/CSSReflectValue.h"
  48 #include "core/css/CSSRuleList.h"
  49 #include "core/css/CSSSelector.h"
  50 #include "core/css/CSSStyleRule.h"
  51 #include "core/css/CSSValueList.h"
  52 #include "core/css/CSSValuePool.h"
  53 #include "core/css/ElementRuleCollector.h"
  54 #include "core/css/FontFace.h"
  55 #include "core/css/MediaQueryEvaluator.h"
  56 #include "core/css/PageRuleCollector.h"
  57 #include "core/css/StylePropertySet.h"
  58 #include "core/css/StyleRuleImport.h"
  59 #include "core/css/StyleSheetContents.h"
  60 #include "core/css/parser/BisonCSSParser.h"
  61 #include "core/css/resolver/AnimatedStyleBuilder.h"
  62 #include "core/css/resolver/MatchResult.h"
  63 #include "core/css/resolver/MediaQueryResult.h"
  64 #include "core/css/resolver/SharedStyleFinder.h"
  65 #include "core/css/resolver/StyleAdjuster.h"
  66 #include "core/css/resolver/StyleResolverParentScope.h"
  67 #include "core/css/resolver/StyleResolverState.h"
  68 #include "core/css/resolver/StyleResolverStats.h"
  69 #include "core/css/resolver/ViewportStyleResolver.h"
  70 #include "core/dom/CSSSelectorWatch.h"
  71 #include "core/dom/NodeRenderStyle.h"
  72 #include "core/dom/StyleEngine.h"
  73 #include "core/dom/Text.h"
  74 #include "core/dom/shadow/ElementShadow.h"
  75 #include "core/dom/shadow/ShadowRoot.h"
  76 #include "core/frame/FrameView.h"
  77 #include "core/frame/LocalFrame.h"
  78 #include "core/html/HTMLIFrameElement.h"
  79 #include "core/inspector/InspectorInstrumentation.h"
  80 #include "core/rendering/RenderView.h"
  81 #include "core/rendering/style/KeyframeList.h"
  82 #include "core/svg/SVGDocumentExtensions.h"
  83 #include "core/svg/SVGElement.h"
  84 #include "core/svg/SVGFontFaceElement.h"
  85 #include "platform/RuntimeEnabledFeatures.h"
  86 #include "wtf/StdLibExtras.h"
  87
  88 namespace {
  89
  90 using namespace WebCore;
  91
  92 void setAnimationUpdateIfNeeded(StyleResolverState& state, Element& element)
  93 {
  94     // If any changes to CSS Animations were detected, stash the update away for application after the
  95     // render object is updated if we're in the appropriate scope.
  96     if (state.animationUpdate())
  97         element.ensureActiveAnimations().cssAnimations().setPendingUpdate(state.takeAnimationUpdate());
  98 }
  99
 100 } // namespace
 101
 102 namespace WebCore {
 103
 104 using namespace HTMLNames;
 105
 106 RenderStyle* StyleResolver::s_styleNotYetAvailable;
 107
 108 static StylePropertySet* leftToRightDeclaration()
 109 {
 110     DEFINE_STATIC_REF(MutableStylePropertySet, leftToRightDecl, (MutableStylePropertySet::create()));
 111     if (leftToRightDecl->isEmpty())
 112         leftToRightDecl->setProperty(CSSPropertyDirection, CSSValueLtr);
 113     return leftToRightDecl;
 114 }
 115
 116 static StylePropertySet* rightToLeftDeclaration()
 117 {
 118     DEFINE_STATIC_REF(MutableStylePropertySet, rightToLeftDecl, (MutableStylePropertySet::create()));
 119     if (rightToLeftDecl->isEmpty())
 120         rightToLeftDecl->setProperty(CSSPropertyDirection, CSSValueRtl);
 121     return rightToLeftDecl;
 122 }
 123
 124 static void addFontFaceRule(Document* document, CSSFontSelector* cssFontSelector, const StyleRuleFontFace* fontFaceRule)
 125 {
 126     RefPtrWillBeRawPtr<FontFace> fontFace = FontFace::create(document, fontFaceRule);
 127     if (fontFace)
 128         cssFontSelector->fontFaceCache()->add(cssFontSelector, fontFaceRule, fontFace);
 129 }
 130
 131 StyleResolver::StyleResolver(Document& document)
 132     : m_document(document)
 133     , m_viewportStyleResolver(ViewportStyleResolver::create(&document))
 134     , m_needCollectFeatures(false)
 135     , m_styleResourceLoader(document.fetcher())
 136     , m_styleSharingDepth(0)
 137     , m_styleResolverStatsSequence(0)
 138     , m_accessCount(0)
 139 {
 140     FrameView* view = document.view();
 141     if (view)
 142         m_medium = adoptPtr(new MediaQueryEvaluator(view->mediaType(), &view->frame()));
 143     else
 144         m_medium = adoptPtr(new MediaQueryEvaluator("all"));
 145
 146     m_styleTree.clear();
 147
 148     initWatchedSelectorRules(CSSSelectorWatch::from(document).watchedCallbackSelectors());
 149
 150 #if ENABLE(SVG_FONTS)
 151     if (document.svgExtensions()) {
 152         const WillBeHeapHashSet<RawPtrWillBeMember<SVGFontFaceElement> >& svgFontFaceElements = document.svgExtensions()->svgFontFaceElements();
 153         WillBeHeapHashSet<RawPtrWillBeMember<SVGFontFaceElement> >::const_iterator end = svgFontFaceElements.end();
 154         for (WillBeHeapHashSet<RawPtrWillBeMember<SVGFontFaceElement> >::const_iterator it = svgFontFaceElements.begin(); it != end; ++it)
 155             addFontFaceRule(&document, document.styleEngine()->fontSelector(), (*it)->fontFaceRule());
 156     }
 157 #endif
 158 }
 159
 160 void StyleResolver::initWatchedSelectorRules(const WillBeHeapVector<RefPtrWillBeMember<StyleRule> >& watchedSelectors)
 161 {
 162     if (!watchedSelectors.size())
 163         return;
 164     m_watchedSelectorsRules = RuleSet::create();
 165     for (unsigned i = 0; i < watchedSelectors.size(); ++i)
 166         m_watchedSelectorsRules->addStyleRule(watchedSelectors[i].get(), RuleHasNoSpecialState);
 167 }
 168
 169 void StyleResolver::lazyAppendAuthorStyleSheets(unsigned firstNew, const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet> >& styleSheets)
 170 {
 171     unsigned size = styleSheets.size();
 172     for (unsigned i = firstNew; i < size; ++i)
 173         m_pendingStyleSheets.add(styleSheets[i].get());
 174 }
 175
 176 void StyleResolver::removePendingAuthorStyleSheets(const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet> >& styleSheets)
 177 {
 178     for (unsigned i = 0; i < styleSheets.size(); ++i)
 179         m_pendingStyleSheets.remove(styleSheets[i].get());
 180 }
 181
 182 void StyleResolver::appendCSSStyleSheet(CSSStyleSheet* cssSheet)
 183 {
 184     ASSERT(cssSheet);
 185     ASSERT(!cssSheet->disabled());
 186     if (cssSheet->mediaQueries() && !m_medium->eval(cssSheet->mediaQueries(), &m_viewportDependentMediaQueryResults))
 187         return;
 188
 189     ContainerNode* scopingNode = ScopedStyleResolver::scopingNodeFor(document(), cssSheet);
 190     if (!scopingNode)
 191         return;
 192
 193     ScopedStyleResolver* resolver = ensureScopedStyleResolver(scopingNode);
 194     ASSERT(resolver);
 195     resolver->addRulesFromSheet(cssSheet, *m_medium, this);
 196 }
 197
 198 void StyleResolver::appendPendingAuthorStyleSheets()
 199 {
 200     setBuildScopedStyleTreeInDocumentOrder(false);
 201     for (WillBeHeapListHashSet<RawPtrWillBeMember<CSSStyleSheet>, 16>::iterator it = m_pendingStyleSheets.begin(); it != m_pendingStyleSheets.end(); ++it)
 202         appendCSSStyleSheet(*it);
 203
 204     m_pendingStyleSheets.clear();
 205     finishAppendAuthorStyleSheets();
 206 }
 207
 208 void StyleResolver::appendAuthorStyleSheets(const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet> >& styleSheets)
 209 {
 210     // This handles sheets added to the end of the stylesheet list only. In other cases the style resolver
 211     // needs to be reconstructed. To handle insertions too the rule order numbers would need to be updated.
 212     unsigned size = styleSheets.size();
 213     for (unsigned i = 0; i < size; ++i)
 214         appendCSSStyleSheet(styleSheets[i].get());
 215 }
 216
 217 void StyleResolver::finishAppendAuthorStyleSheets()
 218 {
 219     collectFeatures();
 220
 221     if (document().renderView() && document().renderView()->style())
 222         document().renderView()->style()->font().update(document().styleEngine()->fontSelector());
 223
 224     collectViewportRules();
 225
 226     document().styleEngine()->resetCSSFeatureFlags(m_features);
 227 }
 228
 229 void StyleResolver::resetRuleFeatures()
 230 {
 231     // Need to recreate RuleFeatureSet.
 232     m_features.clear();
 233     m_siblingRuleSet.clear();
 234     m_uncommonAttributeRuleSet.clear();
 235     m_needCollectFeatures = true;
 236 }
 237
 238 void StyleResolver::processScopedRules(const RuleSet& authorRules, CSSStyleSheet* parentStyleSheet, ContainerNode& scope)
 239 {
 240     const WillBeHeapVector<RawPtrWillBeMember<StyleRuleKeyframes> > keyframesRules = authorRules.keyframesRules();
 241     for (unsigned i = 0; i < keyframesRules.size(); ++i)
 242         ensureScopedStyleResolver(&scope)->addKeyframeStyle(keyframesRules[i]);
 243
 244     m_treeBoundaryCrossingRules.addTreeBoundaryCrossingRules(authorRules, scope, parentStyleSheet);
 245
 246     // FIXME(BUG 72461): We don't add @font-face rules of scoped style sheets for the moment.
 247     if (scope.isDocumentNode()) {
 248         const WillBeHeapVector<RawPtrWillBeMember<StyleRuleFontFace> > fontFaceRules = authorRules.fontFaceRules();
 249         for (unsigned i = 0; i < fontFaceRules.size(); ++i)
 250             addFontFaceRule(&m_document, document().styleEngine()->fontSelector(), fontFaceRules[i]);
 251         if (fontFaceRules.size())
 252             invalidateMatchedPropertiesCache();
 253     }
 254 }
 255
 256 void StyleResolver::resetAuthorStyle(const ContainerNode* scopingNode)
 257 {
 258     ScopedStyleResolver* resolver = scopingNode ? m_styleTree.lookupScopedStyleResolverFor(scopingNode) : m_styleTree.scopedStyleResolverForDocument();
 259     if (!resolver)
 260         return;
 261
 262     m_treeBoundaryCrossingRules.reset(scopingNode);
 263
 264     resolver->resetAuthorStyle();
 265     resetRuleFeatures();
 266     if (!scopingNode)
 267         return;
 268
 269     m_styleTree.remove(scopingNode);
 270 }
 271
 272 static PassOwnPtrWillBeRawPtr<RuleSet> makeRuleSet(const WillBeHeapVector<RuleFeature>& rules)
 273 {
 274     size_t size = rules.size();
 275     if (!size)
 276         return nullptr;
 277     OwnPtrWillBeRawPtr<RuleSet> ruleSet = RuleSet::create();
 278     for (size_t i = 0; i < size; ++i)
 279         ruleSet->addRule(rules[i].rule, rules[i].selectorIndex, rules[i].hasDocumentSecurityOrigin ? RuleHasDocumentSecurityOrigin : RuleHasNoSpecialState);
 280     return ruleSet.release();
 281 }
 282
 283 void StyleResolver::collectFeatures()
 284 {
 285     m_features.clear();
 286     // Collect all ids and rules using sibling selectors (:first-child and similar)
 287     // in the current set of stylesheets. Style sharing code uses this information to reject
 288     // sharing candidates.
 289     CSSDefaultStyleSheets& defaultStyleSheets = CSSDefaultStyleSheets::instance();
 290     if (defaultStyleSheets.defaultStyle())
 291         m_features.add(defaultStyleSheets.defaultStyle()->features());
 292
 293     if (document().isViewSource())
 294         m_features.add(defaultStyleSheets.defaultViewSourceStyle()->features());
 295
 296     if (document().isTransitionDocument())
 297         m_features.add(defaultStyleSheets.defaultTransitionStyle()->features());
 298
 299     if (m_watchedSelectorsRules)
 300         m_features.add(m_watchedSelectorsRules->features());
 301
 302     m_treeBoundaryCrossingRules.collectFeaturesTo(m_features);
 303
 304     m_styleTree.collectFeaturesTo(m_features);
 305
 306     m_siblingRuleSet = makeRuleSet(m_features.siblingRules);
 307     m_uncommonAttributeRuleSet = makeRuleSet(m_features.uncommonAttributeRules);
 308     m_needCollectFeatures = false;
 309 }
 310
 311 bool StyleResolver::hasRulesForId(const AtomicString& id) const
 312 {
 313     return m_features.hasSelectorForId(id);
 314 }
 315
 316 void StyleResolver::addToStyleSharingList(Element& element)
 317 {
 318     // Never add elements to the style sharing list if we're not in a recalcStyle,
 319     // otherwise we could leave stale pointers in there.
 320     if (!document().inStyleRecalc())
 321         return;
 322     INCREMENT_STYLE_STATS_COUNTER(*this, sharedStyleCandidates);
 323     StyleSharingList& list = styleSharingList();
 324     if (list.size() >= styleSharingListSize)
 325         list.remove(--list.end());
 326     list.prepend(&element);
 327 }
 328
 329 StyleSharingList& StyleResolver::styleSharingList()
 330 {
 331     m_styleSharingLists.resize(styleSharingMaxDepth);
 332
 333     // We never put things at depth 0 into the list since that's only the <html> element
 334     // and it has no siblings or cousins to share with.
 335     unsigned depth = std::max(std::min(m_styleSharingDepth, styleSharingMaxDepth), 1u) - 1u;
 336     ASSERT(depth >= 0);
 337
 338     if (!m_styleSharingLists[depth])
 339         m_styleSharingLists[depth] = adoptPtr(new StyleSharingList);
 340     return *m_styleSharingLists[depth];
 341 }
 342
 343 void StyleResolver::clearStyleSharingList()
 344 {
 345     m_styleSharingLists.resize(0);
 346 }
 347
 348 void StyleResolver::pushParentElement(Element& parent)
 349 {
 350     const ContainerNode* parentsParent = parent.parentOrShadowHostElement();
 351
 352     // We are not always invoked consistently. For example, script execution can cause us to enter
 353     // style recalc in the middle of tree building. We may also be invoked from somewhere within the tree.
 354     // Reset the stack in this case, or if we see a new root element.
 355     // Otherwise just push the new parent.
 356     if (!parentsParent || m_selectorFilter.parentStackIsEmpty())
 357         m_selectorFilter.setupParentStack(parent);
 358     else
 359         m_selectorFilter.pushParent(parent);
 360
 361     // Note: We mustn't skip ShadowRoot nodes for the scope stack.
 362     m_styleTree.pushStyleCache(parent, parent.parentOrShadowHostNode());
 363 }
 364
 365 void StyleResolver::popParentElement(Element& parent)
 366 {
 367     // Note that we may get invoked for some random elements in some wacky cases during style resolve.
 368     // Pause maintaining the stack in this case.
 369     if (m_selectorFilter.parentStackIsConsistent(&parent))
 370         m_selectorFilter.popParent();
 371
 372     m_styleTree.popStyleCache(parent);
 373 }
 374
 375 void StyleResolver::pushParentShadowRoot(const ShadowRoot& shadowRoot)
 376 {
 377     ASSERT(shadowRoot.host());
 378     m_styleTree.pushStyleCache(shadowRoot, shadowRoot.host());
 379 }
 380
 381 void StyleResolver::popParentShadowRoot(const ShadowRoot& shadowRoot)
 382 {
 383     ASSERT(shadowRoot.host());
 384     m_styleTree.popStyleCache(shadowRoot);
 385 }
 386
 387 StyleResolver::~StyleResolver()
 388 {
 389 }
 390
 391 static inline bool applyAuthorStylesOf(const Element* element)
 392 {
 393     return element->treeScope().applyAuthorStyles();
 394 }
 395
 396 void StyleResolver::matchAuthorRulesForShadowHost(Element* element, ElementRuleCollector& collector, bool includeEmptyRules, Vector<ScopedStyleResolver*, 8>& resolvers, Vector<ScopedStyleResolver*, 8>& resolversInShadowTree)
 397 {
 398     collector.clearMatchedRules();
 399     collector.matchedResult().ranges.lastAuthorRule = collector.matchedResult().matchedProperties.size() - 1;
 400
 401     CascadeScope cascadeScope = 0;
 402     CascadeOrder cascadeOrder = 0;
 403     bool applyAuthorStyles = applyAuthorStylesOf(element);
 404
 405     for (int j = resolversInShadowTree.size() - 1; j >= 0; --j)
 406         resolversInShadowTree.at(j)->collectMatchingAuthorRules(collector, includeEmptyRules, applyAuthorStyles, cascadeScope, cascadeOrder++);
 407
 408     if (resolvers.isEmpty() || resolvers.first()->treeScope() != element->treeScope())
 409         ++cascadeScope;
 410     cascadeOrder += resolvers.size();
 411     for (unsigned i = 0; i < resolvers.size(); ++i)
 412         resolvers.at(i)->collectMatchingAuthorRules(collector, includeEmptyRules, applyAuthorStyles, cascadeScope++, --cascadeOrder);
 413
 414     m_treeBoundaryCrossingRules.collectTreeBoundaryCrossingRules(element, collector, includeEmptyRules);
 415     collector.sortAndTransferMatchedRules();
 416 }
 417
 418 void StyleResolver::matchAuthorRules(Element* element, ElementRuleCollector& collector, bool includeEmptyRules)
 419 {
 420     collector.clearMatchedRules();
 421     collector.matchedResult().ranges.lastAuthorRule = collector.matchedResult().matchedProperties.size() - 1;
 422
 423     bool applyAuthorStyles = applyAuthorStylesOf(element);
 424     if (m_styleTree.hasOnlyScopedResolverForDocument()) {
 425         m_styleTree.scopedStyleResolverForDocument()->collectMatchingAuthorRules(collector, includeEmptyRules, applyAuthorStyles, ignoreCascadeScope);
 426         m_treeBoundaryCrossingRules.collectTreeBoundaryCrossingRules(element, collector, includeEmptyRules);
 427         collector.sortAndTransferMatchedRules();
 428         return;
 429     }
 430
 431     Vector<ScopedStyleResolver*, 8> resolvers;
 432     m_styleTree.resolveScopedStyles(element, resolvers);
 433
 434     Vector<ScopedStyleResolver*, 8> resolversInShadowTree;
 435     m_styleTree.collectScopedResolversForHostedShadowTrees(element, resolversInShadowTree);
 436     if (!resolversInShadowTree.isEmpty()) {
 437         matchAuthorRulesForShadowHost(element, collector, includeEmptyRules, resolvers, resolversInShadowTree);
 438         return;
 439     }
 440
 441     if (resolvers.isEmpty())
 442         return;
 443
 444     CascadeScope cascadeScope = 0;
 445     CascadeOrder cascadeOrder = resolvers.size();
 446     for (unsigned i = 0; i < resolvers.size(); ++i, --cascadeOrder) {
 447         ScopedStyleResolver* resolver = resolvers.at(i);
 448         // FIXME: Need to clarify how to treat style scoped.
 449         resolver->collectMatchingAuthorRules(collector, includeEmptyRules, applyAuthorStyles, cascadeScope++, resolver->treeScope() == element->treeScope() && resolver->scopingNode().isShadowRoot() ? 0 : cascadeOrder);
 450     }
 451
 452     m_treeBoundaryCrossingRules.collectTreeBoundaryCrossingRules(element, collector, includeEmptyRules);
 453     collector.sortAndTransferMatchedRules();
 454 }
 455
 456 void StyleResolver::matchWatchSelectorRules(ElementRuleCollector& collector)
 457 {
 458     if (!m_watchedSelectorsRules)
 459         return;
 460
 461     collector.clearMatchedRules();
 462     collector.matchedResult().ranges.lastUserRule = collector.matchedResult().matchedProperties.size() - 1;
 463
 464     MatchRequest matchRequest(m_watchedSelectorsRules.get());
 465     RuleRange ruleRange = collector.matchedResult().ranges.userRuleRange();
 466     collector.collectMatchingRules(matchRequest, ruleRange);
 467
 468     collector.sortAndTransferMatchedRules();
 469 }
 470
 471 void StyleResolver::matchUARules(ElementRuleCollector& collector)
 472 {
 473     collector.setMatchingUARules(true);
 474
 475     CSSDefaultStyleSheets& defaultStyleSheets = CSSDefaultStyleSheets::instance();
 476     RuleSet* userAgentStyleSheet = m_medium->mediaTypeMatchSpecific("print")
 477         ? defaultStyleSheets.defaultPrintStyle() : defaultStyleSheets.defaultStyle();
 478     matchUARules(collector, userAgentStyleSheet);
 479
 480     // In quirks mode, we match rules from the quirks user agent sheet.
 481     if (document().inQuirksMode())
 482         matchUARules(collector, defaultStyleSheets.defaultQuirksStyle());
 483
 484     // If document uses view source styles (in view source mode or in xml viewer mode), then we match rules from the view source style sheet.
 485     if (document().isViewSource())
 486         matchUARules(collector, defaultStyleSheets.defaultViewSourceStyle());
 487
 488     if (document().isTransitionDocument())
 489         matchUARules(collector, defaultStyleSheets.defaultTransitionStyle());
 490
 491     collector.setMatchingUARules(false);
 492
 493     matchWatchSelectorRules(collector);
 494 }
 495
 496 void StyleResolver::matchUARules(ElementRuleCollector& collector, RuleSet* rules)
 497 {
 498     collector.clearMatchedRules();
 499     collector.matchedResult().ranges.lastUARule = collector.matchedResult().matchedProperties.size() - 1;
 500
 501     RuleRange ruleRange = collector.matchedResult().ranges.UARuleRange();
 502     collector.collectMatchingRules(MatchRequest(rules), ruleRange);
 503
 504     collector.sortAndTransferMatchedRules();
 505 }
 506
 507 void StyleResolver::matchAllRules(StyleResolverState& state, ElementRuleCollector& collector, bool includeSMILProperties)
 508 {
 509     matchUARules(collector);
 510
 511     // Now check author rules, beginning first with presentational attributes mapped from HTML.
 512     if (state.element()->isStyledElement()) {
 513         collector.addElementStyleProperties(state.element()->presentationAttributeStyle());
 514
 515         // Now we check additional mapped declarations.
 516         // Tables and table cells share an additional mapped rule that must be applied
 517         // after all attributes, since their mapped style depends on the values of multiple attributes.
 518         collector.addElementStyleProperties(state.element()->additionalPresentationAttributeStyle());
 519
 520         if (state.element()->isHTMLElement()) {
 521             bool isAuto;
 522             TextDirection textDirection = toHTMLElement(state.element())->directionalityIfhasDirAutoAttribute(isAuto);
 523             if (isAuto)
 524                 collector.matchedResult().addMatchedProperties(textDirection == LTR ? leftToRightDeclaration() : rightToLeftDeclaration());
 525         }
 526     }
 527
 528     matchAuthorRules(state.element(), collector, false);
 529
 530     if (state.element()->isStyledElement()) {
 531         if (state.element()->inlineStyle()) {
 532             // Inline style is immutable as long as there is no CSSOM wrapper.
 533             bool isInlineStyleCacheable = !state.element()->inlineStyle()->isMutable();
 534             collector.addElementStyleProperties(state.element()->inlineStyle(), isInlineStyleCacheable);
 535         }
 536
 537         // Now check SMIL animation override style.
 538         if (includeSMILProperties && state.element()->isSVGElement())
 539             collector.addElementStyleProperties(toSVGElement(state.element())->animatedSMILStyleProperties(), false /* isCacheable */);
 540     }
 541 }
 542
 543 PassRefPtr<RenderStyle> StyleResolver::styleForDocument(Document& document)
 544 {
 545     const LocalFrame* frame = document.frame();
 546
 547     RefPtr<RenderStyle> documentStyle = RenderStyle::create();
 548     documentStyle->setDisplay(BLOCK);
 549     documentStyle->setRTLOrdering(document.visuallyOrdered() ? VisualOrder : LogicalOrder);
 550     documentStyle->setZoom(frame && !document.printing() ? frame->pageZoomFactor() : 1);
 551     documentStyle->setLocale(document.contentLanguage());
 552     documentStyle->setZIndex(0);
 553     documentStyle->setUserModify(document.inDesignMode() ? READ_WRITE : READ_ONLY);
 554
 555     document.setupFontBuilder(documentStyle.get());
 556
 557     return documentStyle.release();
 558 }
 559
 560 // FIXME: This is duplicated with StyleAdjuster.cpp
 561 // Perhaps this should move onto ElementResolveContext or even Element?
 562 static inline bool isAtShadowBoundary(const Element* element)
 563 {
 564     if (!element)
 565         return false;
 566     ContainerNode* parentNode = element->parentNode();
 567     return parentNode && parentNode->isShadowRoot();
 568 }
 569
 570 static inline void resetDirectionAndWritingModeOnDocument(Document& document)
 571 {
 572     document.setDirectionSetOnDocumentElement(false);
 573     document.setWritingModeSetOnDocumentElement(false);
 574 }
 575
 576 static void addContentAttrValuesToFeatures(const Vector<AtomicString>& contentAttrValues, RuleFeatureSet& features)
 577 {
 578     for (size_t i = 0; i < contentAttrValues.size(); ++i)
 579         features.addContentAttr(contentAttrValues[i]);
 580 }
 581
 582 void StyleResolver::adjustRenderStyle(StyleResolverState& state, Element* element)
 583 {
 584     StyleAdjuster adjuster(m_document.inQuirksMode());
 585     adjuster.adjustRenderStyle(state.style(), state.parentStyle(), element, state.cachedUAStyle());
 586 }
 587
 588 // Start loading resources referenced by this style.
 589 void StyleResolver::loadPendingResources(StyleResolverState& state)
 590 {
 591     m_styleResourceLoader.loadPendingResources(state.style(), state.elementStyleResources());
 592     document().styleEngine()->fontSelector()->fontLoader()->loadPendingFonts();
 593 }
 594
 595 PassRefPtr<RenderStyle> StyleResolver::styleForElement(Element* element, RenderStyle* defaultParent, StyleSharingBehavior sharingBehavior,
 596     RuleMatchingBehavior matchingBehavior)
 597 {
 598     ASSERT(document().frame());
 599     ASSERT(documentSettings());
 600     ASSERT(!hasPendingAuthorStyleSheets());
 601     ASSERT(!m_needCollectFeatures);
 602
 603     // Once an element has a renderer, we don't try to destroy it, since otherwise the renderer
 604     // will vanish if a style recalc happens during loading.
 605     if (sharingBehavior == AllowStyleSharing && !document().isRenderingReady() && !element->renderer()) {
 606         if (!s_styleNotYetAvailable) {
 607             s_styleNotYetAvailable = RenderStyle::create().leakRef();
 608             s_styleNotYetAvailable->setDisplay(NONE);
 609             s_styleNotYetAvailable->font().update(document().styleEngine()->fontSelector());
 610         }
 611
 612         document().setHasNodesWithPlaceholderStyle();
 613         return s_styleNotYetAvailable;
 614     }
 615
 616     didAccess();
 617
 618     StyleResolverParentScope::ensureParentStackIsPushed();
 619
 620     if (element == document().documentElement())
 621         resetDirectionAndWritingModeOnDocument(document());
 622     StyleResolverState state(document(), element, defaultParent);
 623
 624     if (sharingBehavior == AllowStyleSharing && state.parentStyle()) {
 625         SharedStyleFinder styleFinder(state.elementContext(), m_features, m_siblingRuleSet.get(), m_uncommonAttributeRuleSet.get(), *this);
 626         if (RefPtr<RenderStyle> sharedStyle = styleFinder.findSharedStyle())
 627             return sharedStyle.release();
 628     }
 629
 630     if (state.parentStyle()) {
 631         state.setStyle(RenderStyle::create());
 632         state.style()->inheritFrom(state.parentStyle(), isAtShadowBoundary(element) ? RenderStyle::AtShadowBoundary : RenderStyle::NotAtShadowBoundary);
 633     } else {
 634         state.setStyle(defaultStyleForElement());
 635         state.setParentStyle(RenderStyle::clone(state.style()));
 636     }
 637     // contenteditable attribute (implemented by -webkit-user-modify) should
 638     // be propagated from shadow host to distributed node.
 639     if (state.distributedToInsertionPoint()) {
 640         if (Element* parent = element->parentElement()) {
 641             if (RenderStyle* styleOfShadowHost = parent->renderStyle())
 642                 state.style()->setUserModify(styleOfShadowHost->userModify());
 643         }
 644     }
 645
 646     state.fontBuilder().initForStyleResolve(state.document(), state.style());
 647
 648     if (element->isLink()) {
 649         state.style()->setIsLink(true);
 650         EInsideLink linkState = state.elementLinkState();
 651         if (linkState != NotInsideLink) {
 652             bool forceVisited = InspectorInstrumentation::forcePseudoState(element, CSSSelector::PseudoVisited);
 653             if (forceVisited)
 654                 linkState = InsideVisitedLink;
 655         }
 656         state.style()->setInsideLink(linkState);
 657     }
 658
 659     bool needsCollection = false;
 660     CSSDefaultStyleSheets::instance().ensureDefaultStyleSheetsForElement(element, needsCollection);
 661     if (needsCollection)
 662         collectFeatures();
 663
 664     {
 665         ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
 666
 667         matchAllRules(state, collector, matchingBehavior != MatchAllRulesExcludingSMIL);
 668
 669         applyMatchedProperties(state, collector.matchedResult());
 670
 671         addContentAttrValuesToFeatures(state.contentAttrValues(), m_features);
 672     }
 673
 674     // Cache our original display.
 675     state.style()->setOriginalDisplay(state.style()->display());
 676
 677     adjustRenderStyle(state, element);
 678
 679     // FIXME: The CSSWG wants to specify that the effects of animations are applied before
 680     // important rules, but this currently happens here as we require adjustment to have happened
 681     // before deciding which properties to transition.
 682     if (applyAnimatedProperties(state, element))
 683         adjustRenderStyle(state, element);
 684
 685     // FIXME: Shouldn't this be on RenderBody::styleDidChange?
 686     if (isHTMLBodyElement(*element))
 687         document().textLinkColors().setTextColor(state.style()->color());
 688
 689     setAnimationUpdateIfNeeded(state, *element);
 690
 691     if (state.style()->hasViewportUnits())
 692         document().setHasViewportUnits();
 693
 694     // Now return the style.
 695     return state.takeStyle();
 696 }
 697
 698 PassRefPtr<RenderStyle> StyleResolver::styleForKeyframe(Element* element, const RenderStyle& elementStyle, RenderStyle* parentStyle, const StyleKeyframe* keyframe, const AtomicString& animationName)
 699 {
 700     ASSERT(document().frame());
 701     ASSERT(documentSettings());
 702     ASSERT(!hasPendingAuthorStyleSheets());
 703
 704     if (element == document().documentElement())
 705         resetDirectionAndWritingModeOnDocument(document());
 706     StyleResolverState state(document(), element, parentStyle);
 707
 708     MatchResult result;
 709     result.addMatchedProperties(&keyframe->properties());
 710
 711     ASSERT(!state.style());
 712
 713     // Create the style
 714     state.setStyle(RenderStyle::clone(&elementStyle));
 715     state.setLineHeightValue(0);
 716
 717     state.fontBuilder().initForStyleResolve(state.document(), state.style());
 718
 719     // We don't need to bother with !important. Since there is only ever one
 720     // decl, there's nothing to override. So just add the first properties.
 721     // We also don't need to bother with animation properties since the only
 722     // relevant one is animation-timing-function and we special-case that in
 723     // CSSAnimations.cpp
 724     bool inheritedOnly = false;
 725     applyMatchedProperties<HighPriorityProperties>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 726
 727     // If our font got dirtied, go ahead and update it now.
 728     updateFont(state);
 729
 730     // Line-height is set when we are sure we decided on the font-size
 731     if (state.lineHeightValue())
 732         StyleBuilder::applyProperty(CSSPropertyLineHeight, state, state.lineHeightValue());
 733
 734     // Now do rest of the properties.
 735     applyMatchedProperties<LowPriorityProperties>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 736
 737     // If our font got dirtied by one of the non-essential font props,
 738     // go ahead and update it a second time.
 739     updateFont(state);
 740
 741     loadPendingResources(state);
 742
 743     didAccess();
 744
 745     return state.takeStyle();
 746 }
 747
 748 // This function is used by the WebAnimations JavaScript API method animate().
 749 // FIXME: Remove this when animate() switches away from resolution-dependent parsing.
 750 PassRefPtrWillBeRawPtr<AnimatableValue> StyleResolver::createAnimatableValueSnapshot(Element& element, CSSPropertyID property, CSSValue& value)
 751 {
 752     RefPtr<RenderStyle> style;
 753     if (element.renderStyle())
 754         style = RenderStyle::clone(element.renderStyle());
 755     else
 756         style = RenderStyle::create();
 757     StyleResolverState state(element.document(), &element);
 758     state.setStyle(style);
 759     state.fontBuilder().initForStyleResolve(state.document(), state.style());
 760     return createAnimatableValueSnapshot(state, property, value);
 761 }
 762
 763 PassRefPtrWillBeRawPtr<AnimatableValue> StyleResolver::createAnimatableValueSnapshot(StyleResolverState& state, CSSPropertyID property, CSSValue& value)
 764 {
 765     StyleBuilder::applyProperty(property, state, &value);
 766     return CSSAnimatableValueFactory::create(property, *state.style());
 767 }
 768
 769 PassRefPtrWillBeRawPtr<PseudoElement> StyleResolver::createPseudoElementIfNeeded(Element& parent, PseudoId pseudoId)
 770 {
 771     RenderObject* parentRenderer = parent.renderer();
 772     if (!parentRenderer)
 773         return nullptr;
 774
 775     if (pseudoId < FIRST_INTERNAL_PSEUDOID && !parentRenderer->style()->hasPseudoStyle(pseudoId))
 776         return nullptr;
 777
 778     if (pseudoId == BACKDROP && !parent.isInTopLayer())
 779         return nullptr;
 780
 781     if (!parentRenderer->canHaveGeneratedChildren())
 782         return nullptr;
 783
 784     RenderStyle* parentStyle = parentRenderer->style();
 785     if (RenderStyle* cachedStyle = parentStyle->getCachedPseudoStyle(pseudoId)) {
 786         if (!pseudoElementRendererIsNeeded(cachedStyle))
 787             return nullptr;
 788         return PseudoElement::create(&parent, pseudoId);
 789     }
 790
 791     StyleResolverState state(document(), &parent, parentStyle);
 792     if (!pseudoStyleForElementInternal(parent, pseudoId, parentStyle, state))
 793         return nullptr;
 794     RefPtr<RenderStyle> style = state.takeStyle();
 795     ASSERT(style);
 796     parentStyle->addCachedPseudoStyle(style);
 797
 798     if (!pseudoElementRendererIsNeeded(style.get()))
 799         return nullptr;
 800
 801     RefPtrWillBeRawPtr<PseudoElement> pseudo = PseudoElement::create(&parent, pseudoId);
 802
 803     setAnimationUpdateIfNeeded(state, *pseudo);
 804     if (ActiveAnimations* activeAnimations = pseudo->activeAnimations())
 805         activeAnimations->cssAnimations().maybeApplyPendingUpdate(pseudo.get());
 806     return pseudo.release();
 807 }
 808
 809 bool StyleResolver::pseudoStyleForElementInternal(Element& element, const PseudoStyleRequest& pseudoStyleRequest, RenderStyle* parentStyle, StyleResolverState& state)
 810 {
 811     ASSERT(document().frame());
 812     ASSERT(documentSettings());
 813     ASSERT(pseudoStyleRequest.pseudoId != FIRST_LINE_INHERITED);
 814
 815     StyleResolverParentScope::ensureParentStackIsPushed();
 816
 817     if (pseudoStyleRequest.allowsInheritance(state.parentStyle())) {
 818         state.setStyle(RenderStyle::create());
 819         state.style()->inheritFrom(state.parentStyle());
 820     } else {
 821         state.setStyle(defaultStyleForElement());
 822         state.setParentStyle(RenderStyle::clone(state.style()));
 823     }
 824
 825     state.fontBuilder().initForStyleResolve(state.document(), state.style());
 826
 827     // Since we don't use pseudo-elements in any of our quirk/print
 828     // user agent rules, don't waste time walking those rules.
 829
 830     {
 831         // Check UA, user and author rules.
 832         ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
 833         collector.setPseudoStyleRequest(pseudoStyleRequest);
 834
 835         matchUARules(collector);
 836         matchAuthorRules(state.element(), collector, false);
 837
 838         if (collector.matchedResult().matchedProperties.isEmpty())
 839             return false;
 840
 841         state.style()->setStyleType(pseudoStyleRequest.pseudoId);
 842
 843         applyMatchedProperties(state, collector.matchedResult());
 844
 845         addContentAttrValuesToFeatures(state.contentAttrValues(), m_features);
 846     }
 847
 848     // Cache our original display.
 849     state.style()->setOriginalDisplay(state.style()->display());
 850
 851     // FIXME: Passing 0 as the Element* introduces a lot of complexity
 852     // in the adjustRenderStyle code.
 853     adjustRenderStyle(state, 0);
 854
 855     // FIXME: The CSSWG wants to specify that the effects of animations are applied before
 856     // important rules, but this currently happens here as we require adjustment to have happened
 857     // before deciding which properties to transition.
 858     if (applyAnimatedProperties(state, element.pseudoElement(pseudoStyleRequest.pseudoId)))
 859         adjustRenderStyle(state, 0);
 860
 861     didAccess();
 862
 863     if (state.style()->hasViewportUnits())
 864         document().setHasViewportUnits();
 865
 866     return true;
 867 }
 868
 869 PassRefPtr<RenderStyle> StyleResolver::pseudoStyleForElement(Element* element, const PseudoStyleRequest& pseudoStyleRequest, RenderStyle* parentStyle)
 870 {
 871     ASSERT(parentStyle);
 872     if (!element)
 873         return nullptr;
 874
 875     StyleResolverState state(document(), element, parentStyle);
 876     if (!pseudoStyleForElementInternal(*element, pseudoStyleRequest, parentStyle, state))
 877         return nullptr;
 878
 879     if (PseudoElement* pseudoElement = element->pseudoElement(pseudoStyleRequest.pseudoId))
 880         setAnimationUpdateIfNeeded(state, *pseudoElement);
 881
 882     // Now return the style.
 883     return state.takeStyle();
 884 }
 885
 886 PassRefPtr<RenderStyle> StyleResolver::styleForPage(int pageIndex)
 887 {
 888     ASSERT(!hasPendingAuthorStyleSheets());
 889     resetDirectionAndWritingModeOnDocument(document());
 890     StyleResolverState state(document(), document().documentElement()); // m_rootElementStyle will be set to the document style.
 891
 892     state.setStyle(RenderStyle::create());
 893     const RenderStyle* rootElementStyle = state.rootElementStyle() ? state.rootElementStyle() : document().renderStyle();
 894     ASSERT(rootElementStyle);
 895     state.style()->inheritFrom(rootElementStyle);
 896
 897     state.fontBuilder().initForStyleResolve(state.document(), state.style());
 898
 899     PageRuleCollector collector(rootElementStyle, pageIndex);
 900
 901     collector.matchPageRules(CSSDefaultStyleSheets::instance().defaultPrintStyle());
 902
 903     if (ScopedStyleResolver* scopedResolver = m_styleTree.scopedStyleResolverForDocument())
 904         scopedResolver->matchPageRules(collector);
 905
 906     state.setLineHeightValue(0);
 907     bool inheritedOnly = false;
 908
 909     MatchResult& result = collector.matchedResult();
 910     applyMatchedProperties<HighPriorityProperties>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 911
 912     // If our font got dirtied, go ahead and update it now.
 913     updateFont(state);
 914
 915     // Line-height is set when we are sure we decided on the font-size.
 916     if (state.lineHeightValue())
 917         StyleBuilder::applyProperty(CSSPropertyLineHeight, state, state.lineHeightValue());
 918
 919     applyMatchedProperties<LowPriorityProperties>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 920
 921     addContentAttrValuesToFeatures(state.contentAttrValues(), m_features);
 922
 923     loadPendingResources(state);
 924
 925     didAccess();
 926
 927     // Now return the style.
 928     return state.takeStyle();
 929 }
 930
 931 void StyleResolver::collectViewportRules()
 932 {
 933     CSSDefaultStyleSheets& defaultStyleSheets = CSSDefaultStyleSheets::instance();
 934     viewportStyleResolver()->collectViewportRules(defaultStyleSheets.defaultStyle(), ViewportStyleResolver::UserAgentOrigin);
 935
 936     if (!InspectorInstrumentation::applyViewportStyleOverride(&document(), this))
 937         viewportStyleResolver()->collectViewportRules(defaultStyleSheets.defaultViewportStyle(), ViewportStyleResolver::UserAgentOrigin);
 938
 939     if (document().isMobileDocument())
 940         viewportStyleResolver()->collectViewportRules(defaultStyleSheets.defaultXHTMLMobileProfileStyle(), ViewportStyleResolver::UserAgentOrigin);
 941
 942     if (ScopedStyleResolver* scopedResolver = m_styleTree.scopedStyleResolverForDocument())
 943         scopedResolver->collectViewportRulesTo(this);
 944
 945     viewportStyleResolver()->resolve();
 946 }
 947
 948 PassRefPtr<RenderStyle> StyleResolver::defaultStyleForElement()
 949 {
 950     StyleResolverState state(document(), 0);
 951     state.setStyle(RenderStyle::create());
 952     state.fontBuilder().initForStyleResolve(document(), state.style());
 953     state.style()->setLineHeight(RenderStyle::initialLineHeight());
 954     state.setLineHeightValue(0);
 955     state.fontBuilder().setInitial(state.style()->effectiveZoom());
 956     state.style()->font().update(document().styleEngine()->fontSelector());
 957     return state.takeStyle();
 958 }
 959
 960 PassRefPtr<RenderStyle> StyleResolver::styleForText(Text* textNode)
 961 {
 962     ASSERT(textNode);
 963
 964     NodeRenderingTraversal::ParentDetails parentDetails;
 965     Node* parentNode = NodeRenderingTraversal::parent(textNode, &parentDetails);
 966     if (!parentNode || !parentNode->renderStyle())
 967         return defaultStyleForElement();
 968     return parentNode->renderStyle();
 969 }
 970
 971 void StyleResolver::updateFont(StyleResolverState& state)
 972 {
 973     state.fontBuilder().createFont(document().styleEngine()->fontSelector(), state.parentStyle(), state.style());
 974     if (state.fontBuilder().fontSizeHasViewportUnits())
 975         state.style()->setHasViewportUnits();
 976 }
 977
 978 PassRefPtrWillBeRawPtr<StyleRuleList> StyleResolver::styleRulesForElement(Element* element, unsigned rulesToInclude)
 979 {
 980     ASSERT(element);
 981     StyleResolverState state(document(), element);
 982     ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
 983     collector.setMode(SelectorChecker::CollectingStyleRules);
 984     collectPseudoRulesForElement(element, collector, NOPSEUDO, rulesToInclude);
 985     return collector.matchedStyleRuleList();
 986 }
 987
 988 PassRefPtrWillBeRawPtr<CSSRuleList> StyleResolver::pseudoCSSRulesForElement(Element* element, PseudoId pseudoId, unsigned rulesToInclude)
 989 {
 990     ASSERT(element);
 991     StyleResolverState state(document(), element);
 992     ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
 993     collector.setMode(SelectorChecker::CollectingCSSRules);
 994     collectPseudoRulesForElement(element, collector, pseudoId, rulesToInclude);
 995     return collector.matchedCSSRuleList();
 996 }
 997
 998 PassRefPtrWillBeRawPtr<CSSRuleList> StyleResolver::cssRulesForElement(Element* element, unsigned rulesToInclude)
 999 {
1000     return pseudoCSSRulesForElement(element, NOPSEUDO, rulesToInclude);
1001 }
1002
1003 void StyleResolver::collectPseudoRulesForElement(Element* element, ElementRuleCollector& collector, PseudoId pseudoId, unsigned rulesToInclude)
1004 {
1005     collector.setPseudoStyleRequest(PseudoStyleRequest(pseudoId));
1006
1007     if (rulesToInclude & UAAndUserCSSRules)
1008         matchUARules(collector);
1009
1010     if (rulesToInclude & AuthorCSSRules) {
1011         collector.setSameOriginOnly(!(rulesToInclude & CrossOriginCSSRules));
1012         matchAuthorRules(element, collector, rulesToInclude & EmptyCSSRules);
1013     }
1014 }
1015
1016 // -------------------------------------------------------------------------------------
1017 // this is mostly boring stuff on how to apply a certain rule to the renderstyle...
1018
1019 bool StyleResolver::applyAnimatedProperties(StyleResolverState& state, Element* animatingElement)
1020 {
1021     const Element* element = state.element();
1022     ASSERT(element);
1023
1024     // The animating element may be this element, or its pseudo element. It is
1025     // null when calculating the style for a potential pseudo element that has
1026     // yet to be created.
1027     ASSERT(animatingElement == element || !animatingElement || animatingElement->parentOrShadowHostElement() == element);
1028
1029     if (!(animatingElement && animatingElement->hasActiveAnimations())
1030         && !state.style()->transitions() && !state.style()->animations())
1031         return false;
1032
1033     state.setAnimationUpdate(CSSAnimations::calculateUpdate(animatingElement, *element, *state.style(), state.parentStyle(), this));
1034     if (!state.animationUpdate())
1035         return false;
1036
1037     const WillBeHeapHashMap<CSSPropertyID, RefPtrWillBeMember<Interpolation> >& activeInterpolationsForAnimations = state.animationUpdate()->activeInterpolationsForAnimations();
1038     const WillBeHeapHashMap<CSSPropertyID, RefPtrWillBeMember<Interpolation> >& activeInterpolationsForTransitions = state.animationUpdate()->activeInterpolationsForTransitions();
1039     applyAnimatedProperties<HighPriorityProperties>(state, activeInterpolationsForAnimations);
1040     applyAnimatedProperties<HighPriorityProperties>(state, activeInterpolationsForTransitions);
1041
1042     updateFont(state);
1043
1044     applyAnimatedProperties<LowPriorityProperties>(state, activeInterpolationsForAnimations);
1045     applyAnimatedProperties<LowPriorityProperties>(state, activeInterpolationsForTransitions);
1046
1047     // Start loading resources used by animations.
1048     loadPendingResources(state);
1049
1050     ASSERT(!state.fontBuilder().fontDirty());
1051
1052     return true;
1053 }
1054
1055 template <StyleResolver::StyleApplicationPass pass>
1056 void StyleResolver::applyAnimatedProperties(StyleResolverState& state, const WillBeHeapHashMap<CSSPropertyID, RefPtrWillBeMember<Interpolation> >& activeInterpolations)
1057 {
1058     ASSERT(pass != AnimationProperties);
1059
1060     for (WillBeHeapHashMap<CSSPropertyID, RefPtrWillBeMember<Interpolation> >::const_iterator iter = activeInterpolations.begin(); iter != activeInterpolations.end(); ++iter) {
1061         CSSPropertyID property = iter->key;
1062         if (!isPropertyForPass<pass>(property))
1063             continue;
1064         const StyleInterpolation* interpolation = toStyleInterpolation(iter->value.get());
1065         interpolation->apply(state);
1066     }
1067 }
1068
1069 static inline bool isValidCueStyleProperty(CSSPropertyID id)
1070 {
1071     switch (id) {
1072     case CSSPropertyBackground:
1073     case CSSPropertyBackgroundAttachment:
1074     case CSSPropertyBackgroundClip:
1075     case CSSPropertyBackgroundColor:
1076     case CSSPropertyBackgroundImage:
1077     case CSSPropertyBackgroundOrigin:
1078     case CSSPropertyBackgroundPosition:
1079     case CSSPropertyBackgroundPositionX:
1080     case CSSPropertyBackgroundPositionY:
1081     case CSSPropertyBackgroundRepeat:
1082     case CSSPropertyBackgroundRepeatX:
1083     case CSSPropertyBackgroundRepeatY:
1084     case CSSPropertyBackgroundSize:
1085     case CSSPropertyColor:
1086     case CSSPropertyFont:
1087     case CSSPropertyFontFamily:
1088     case CSSPropertyFontSize:
1089     case CSSPropertyFontStyle:
1090     case CSSPropertyFontVariant:
1091     case CSSPropertyFontWeight:
1092     case CSSPropertyLineHeight:
1093     case CSSPropertyOpacity:
1094     case CSSPropertyOutline:
1095     case CSSPropertyOutlineColor:
1096     case CSSPropertyOutlineOffset:
1097     case CSSPropertyOutlineStyle:
1098     case CSSPropertyOutlineWidth:
1099     case CSSPropertyVisibility:
1100     case CSSPropertyWhiteSpace:
1101     // FIXME: 'text-decoration' shorthand to be handled when available.
1102     // See https://chromiumcodereview.appspot.com/19516002 for details.
1103     case CSSPropertyTextDecoration:
1104     case CSSPropertyTextShadow:
1105     case CSSPropertyBorderStyle:
1106         return true;
1107     case CSSPropertyTextDecorationLine:
1108     case CSSPropertyTextDecorationStyle:
1109     case CSSPropertyTextDecorationColor:
1110         return RuntimeEnabledFeatures::css3TextDecorationsEnabled();
1111     default:
1112         break;
1113     }
1114     return false;
1115 }
1116
1117 static inline bool isValidFirstLetterStyleProperty(CSSPropertyID id)
1118 {
1119     switch (id) {
1120     // Valid ::first-letter properties listed in spec:
1121     // http://www.w3.org/TR/css3-selectors/#application-in-css
1122     case CSSPropertyBackgroundAttachment:
1123     case CSSPropertyBackgroundBlendMode:
1124     case CSSPropertyBackgroundClip:
1125     case CSSPropertyBackgroundColor:
1126     case CSSPropertyBackgroundImage:
1127     case CSSPropertyBackgroundOrigin:
1128     case CSSPropertyBackgroundPosition:
1129     case CSSPropertyBackgroundPositionX:
1130     case CSSPropertyBackgroundPositionY:
1131     case CSSPropertyBackgroundRepeat:
1132     case CSSPropertyBackgroundRepeatX:
1133     case CSSPropertyBackgroundRepeatY:
1134     case CSSPropertyBackgroundSize:
1135     case CSSPropertyBorderBottomColor:
1136     case CSSPropertyBorderBottomLeftRadius:
1137     case CSSPropertyBorderBottomRightRadius:
1138     case CSSPropertyBorderBottomStyle:
1139     case CSSPropertyBorderBottomWidth:
1140     case CSSPropertyBorderImageOutset:
1141     case CSSPropertyBorderImageRepeat:
1142     case CSSPropertyBorderImageSlice:
1143     case CSSPropertyBorderImageSource:
1144     case CSSPropertyBorderImageWidth:
1145     case CSSPropertyBorderLeftColor:
1146     case CSSPropertyBorderLeftStyle:
1147     case CSSPropertyBorderLeftWidth:
1148     case CSSPropertyBorderRightColor:
1149     case CSSPropertyBorderRightStyle:
1150     case CSSPropertyBorderRightWidth:
1151     case CSSPropertyBorderTopColor:
1152     case CSSPropertyBorderTopLeftRadius:
1153     case CSSPropertyBorderTopRightRadius:
1154     case CSSPropertyBorderTopStyle:
1155     case CSSPropertyBorderTopWidth:
1156     case CSSPropertyColor:
1157     case CSSPropertyFloat:
1158     case CSSPropertyFont:
1159     case CSSPropertyFontFamily:
1160     case CSSPropertyFontKerning:
1161     case CSSPropertyFontSize:
1162     case CSSPropertyFontStretch:
1163     case CSSPropertyFontStyle:
1164     case CSSPropertyFontVariant:
1165     case CSSPropertyFontVariantLigatures:
1166     case CSSPropertyFontWeight:
1167     case CSSPropertyLetterSpacing:
1168     case CSSPropertyLineHeight:
1169     case CSSPropertyMarginBottom:
1170     case CSSPropertyMarginLeft:
1171     case CSSPropertyMarginRight:
1172     case CSSPropertyMarginTop:
1173     case CSSPropertyPaddingBottom:
1174     case CSSPropertyPaddingLeft:
1175     case CSSPropertyPaddingRight:
1176     case CSSPropertyPaddingTop:
1177     case CSSPropertyTextTransform:
1178     case CSSPropertyVerticalAlign:
1179     case CSSPropertyWebkitBackgroundClip:
1180     case CSSPropertyWebkitBackgroundComposite:
1181     case CSSPropertyWebkitBackgroundOrigin:
1182     case CSSPropertyWebkitBackgroundSize:
1183     case CSSPropertyWebkitBorderAfter:
1184     case CSSPropertyWebkitBorderAfterColor:
1185     case CSSPropertyWebkitBorderAfterStyle:
1186     case CSSPropertyWebkitBorderAfterWidth:
1187     case CSSPropertyWebkitBorderBefore:
1188     case CSSPropertyWebkitBorderBeforeColor:
1189     case CSSPropertyWebkitBorderBeforeStyle:
1190     case CSSPropertyWebkitBorderBeforeWidth:
1191     case CSSPropertyWebkitBorderEnd:
1192     case CSSPropertyWebkitBorderEndColor:
1193     case CSSPropertyWebkitBorderEndStyle:
1194     case CSSPropertyWebkitBorderEndWidth:
1195     case CSSPropertyWebkitBorderFit:
1196     case CSSPropertyWebkitBorderHorizontalSpacing:
1197     case CSSPropertyWebkitBorderImage:
1198     case CSSPropertyWebkitBorderRadius:
1199     case CSSPropertyWebkitBorderStart:
1200     case CSSPropertyWebkitBorderStartColor:
1201     case CSSPropertyWebkitBorderStartStyle:
1202     case CSSPropertyWebkitBorderStartWidth:
1203     case CSSPropertyWebkitBorderVerticalSpacing:
1204     case CSSPropertyWebkitFontSmoothing:
1205     case CSSPropertyWebkitMarginAfter:
1206     case CSSPropertyWebkitMarginAfterCollapse:
1207     case CSSPropertyWebkitMarginBefore:
1208     case CSSPropertyWebkitMarginBeforeCollapse:
1209     case CSSPropertyWebkitMarginBottomCollapse:
1210     case CSSPropertyWebkitMarginCollapse:
1211     case CSSPropertyWebkitMarginEnd:
1212     case CSSPropertyWebkitMarginStart:
1213     case CSSPropertyWebkitMarginTopCollapse:
1214     case CSSPropertyWordSpacing:
1215         return true;
1216     case CSSPropertyTextDecorationColor:
1217     case CSSPropertyTextDecorationLine:
1218     case CSSPropertyTextDecorationStyle:
1219         return RuntimeEnabledFeatures::css3TextDecorationsEnabled();
1220
1221     // text-shadow added in text decoration spec:
1222     // http://www.w3.org/TR/css-text-decor-3/#text-shadow-property
1223     case CSSPropertyTextShadow:
1224     // box-shadox added in CSS3 backgrounds spec:
1225     // http://www.w3.org/TR/css3-background/#placement
1226     case CSSPropertyBoxShadow:
1227     case CSSPropertyWebkitBoxShadow:
1228     // Properties that we currently support outside of spec.
1229     case CSSPropertyWebkitLineBoxContain:
1230     case CSSPropertyVisibility:
1231         return true;
1232
1233     default:
1234         return false;
1235     }
1236 }
1237
1238 // FIXME: Consider refactoring to create a new class which owns the following
1239 // first/last/range properties.
1240 // This method returns the first CSSPropertyId of properties which generate
1241 // animations. All animation properties are obtained by using
1242 // firstCSSPropertyId<AnimationProperties> and
1243 // lastCSSPropertyId<AnimationProperties>.
1244 // c.f. //src/third_party/WebKit/Source/core/css/CSSPropertyNames.in.
1245 template<> CSSPropertyID StyleResolver::firstCSSPropertyId<StyleResolver::AnimationProperties>()
1246 {
1247     COMPILE_ASSERT(firstCSSProperty == CSSPropertyDisplay, CSS_first_animation_property_should_be_first_property);
1248     return CSSPropertyDisplay;
1249 }
1250
1251 // This method returns the first CSSPropertyId of properties which generate
1252 // animations.
1253 template<> CSSPropertyID StyleResolver::lastCSSPropertyId<StyleResolver::AnimationProperties>()
1254 {
1255     COMPILE_ASSERT(CSSPropertyTransitionTimingFunction == CSSPropertyColor - 1, CSS_transition_timing_is_last_animation_property);
1256     return CSSPropertyTransitionTimingFunction;
1257 }
1258
1259 // This method returns the first CSSPropertyId of high priority properties.
1260 // Other properties can depend on high priority properties. For example,
1261 // border-color property with currentColor value depends on color property.
1262 // All high priority properties are obtained by using
1263 // firstCSSPropertyId<HighPriorityProperties> and
1264 // lastCSSPropertyId<HighPriorityProperties>.
1265 template<> CSSPropertyID StyleResolver::firstCSSPropertyId<StyleResolver::HighPriorityProperties>()
1266 {
1267     COMPILE_ASSERT(CSSPropertyTransitionTimingFunction + 1 == CSSPropertyColor, CSS_color_is_first_high_priority_property);
1268     return CSSPropertyColor;
1269 }
1270
1271 // This method returns the last CSSPropertyId of high priority properties.
1272 template<> CSSPropertyID StyleResolver::lastCSSPropertyId<StyleResolver::HighPriorityProperties>()
1273 {
1274     COMPILE_ASSERT(CSSPropertyLineHeight == CSSPropertyColor + 17, CSS_line_height_is_end_of_high_prioity_property_range);
1275     COMPILE_ASSERT(CSSPropertyZoom == CSSPropertyLineHeight - 1, CSS_zoom_is_before_line_height);
1276     return CSSPropertyLineHeight;
1277 }
1278
1279 // This method returns the first CSSPropertyId of remaining properties,
1280 // i.e. low priority properties. No properties depend on low priority
1281 // properties. So we don't need to resolve such properties quickly.
1282 // All low priority properties are obtained by using
1283 // firstCSSPropertyId<LowPriorityProperties> and
1284 // lastCSSPropertyId<LowPriorityProperties>.
1285 template<> CSSPropertyID StyleResolver::firstCSSPropertyId<StyleResolver::LowPriorityProperties>()
1286 {
1287     COMPILE_ASSERT(CSSPropertyBackground == CSSPropertyLineHeight + 1, CSS_background_is_first_low_priority_property);
1288     return CSSPropertyBackground;
1289 }
1290
1291 // This method returns the last CSSPropertyId of low priority properties.
1292 template<> CSSPropertyID StyleResolver::lastCSSPropertyId<StyleResolver::LowPriorityProperties>()
1293 {
1294     return static_cast<CSSPropertyID>(lastCSSProperty);
1295 }
1296
1297 template <StyleResolver::StyleApplicationPass pass>
1298 bool StyleResolver::isPropertyForPass(CSSPropertyID property)
1299 {
1300     return firstCSSPropertyId<pass>() <= property && property <= lastCSSPropertyId<pass>();
1301 }
1302
1303 // This method expands all shorthand property to longhand properties
1304 // considering StyleApplicationPass, and apply each expanded longhand property.
1305 // For example, if StyleApplicationPass is AnimationProperties, all shorthand
1306 // is expaneded to display, -webkit-animation, -webkit-animation-delay, ...,
1307 // transition-timing-function. So each property's value will be applied
1308 // according to all's value (initial, inherit or unset).
1309 template <StyleResolver::StyleApplicationPass pass>
1310 void StyleResolver::applyAllProperty(StyleResolverState& state, CSSValue* allValue)
1311 {
1312     bool isUnsetValue = !allValue->isInitialValue() && !allValue->isInheritedValue();
1313     unsigned startCSSProperty = firstCSSPropertyId<pass>();
1314     unsigned endCSSProperty = lastCSSPropertyId<pass>();
1315
1316     for (unsigned i = startCSSProperty; i <= endCSSProperty; ++i) {
1317         CSSPropertyID propertyId = static_cast<CSSPropertyID>(i);
1318
1319         // StyleBuilder does not allow any expanded shorthands.
1320         if (isExpandedShorthandForAll(propertyId))
1321             continue;
1322
1323         // all shorthand spec says:
1324         // The all property is a shorthand that resets all CSS properties
1325         // except direction and unicode-bidi.
1326         // c.f. http://dev.w3.org/csswg/css-cascade/#all-shorthand
1327         // We skip applyProperty when a given property is unicode-bidi or
1328         // direction.
1329         if (!CSSProperty::isAffectedByAllProperty(propertyId))
1330             continue;
1331
1332         CSSValue* value;
1333         if (!isUnsetValue) {
1334             value = allValue;
1335         } else {
1336             if (CSSProperty::isInheritedProperty(propertyId))
1337                 value = cssValuePool().createInheritedValue().get();
1338             else
1339                 value = cssValuePool().createExplicitInitialValue().get();
1340         }
1341         StyleBuilder::applyProperty(propertyId, state, value);
1342     }
1343 }
1344
1345 template <StyleResolver::StyleApplicationPass pass>
1346 void StyleResolver::applyProperties(StyleResolverState& state, const StylePropertySet* properties, StyleRule* rule, bool isImportant, bool inheritedOnly, PropertyWhitelistType propertyWhitelistType)
1347 {
1348     state.setCurrentRule(rule);
1349
1350     unsigned propertyCount = properties->propertyCount();
1351     for (unsigned i = 0; i < propertyCount; ++i) {
1352         StylePropertySet::PropertyReference current = properties->propertyAt(i);
1353         if (isImportant != current.isImportant())
1354             continue;
1355
1356         CSSPropertyID property = current.id();
1357         if (property == CSSPropertyAll) {
1358             applyAllProperty<pass>(state, current.value());
1359             continue;
1360         }
1361
1362         if (inheritedOnly && !current.isInherited()) {
1363             // If the property value is explicitly inherited, we need to apply further non-inherited properties
1364             // as they might override the value inherited here. For this reason we don't allow declarations with
1365             // explicitly inherited properties to be cached.
1366             ASSERT(!current.value()->isInheritedValue());
1367             continue;
1368         }
1369
1370         if (propertyWhitelistType == PropertyWhitelistCue && !isValidCueStyleProperty(property))
1371             continue;
1372         if (propertyWhitelistType == PropertyWhitelistFirstLetter && !isValidFirstLetterStyleProperty(property))
1373             continue;
1374         if (!isPropertyForPass<pass>(property))
1375             continue;
1376         if (pass == HighPriorityProperties && property == CSSPropertyLineHeight)
1377             state.setLineHeightValue(current.value());
1378         else
1379             StyleBuilder::applyProperty(current.id(), state, current.value());
1380     }
1381 }
1382
1383 template <StyleResolver::StyleApplicationPass pass>
1384 void StyleResolver::applyMatchedProperties(StyleResolverState& state, const MatchResult& matchResult, bool isImportant, int startIndex, int endIndex, bool inheritedOnly)
1385 {
1386     if (startIndex == -1)
1387         return;
1388
1389     if (state.style()->insideLink() != NotInsideLink) {
1390         for (int i = startIndex; i <= endIndex; ++i) {
1391             const MatchedProperties& matchedProperties = matchResult.matchedProperties[i];
1392             unsigned linkMatchType = matchedProperties.linkMatchType;
1393             // FIXME: It would be nicer to pass these as arguments but that requires changes in many places.
1394             state.setApplyPropertyToRegularStyle(linkMatchType & SelectorChecker::MatchLink);
1395             state.setApplyPropertyToVisitedLinkStyle(linkMatchType & SelectorChecker::MatchVisited);
1396
1397             applyProperties<pass>(state, matchedProperties.properties.get(), matchResult.matchedRules[i], isImportant, inheritedOnly, static_cast<PropertyWhitelistType>(matchedProperties.whitelistType));
1398         }
1399         state.setApplyPropertyToRegularStyle(true);
1400         state.setApplyPropertyToVisitedLinkStyle(false);
1401         return;
1402     }
1403     for (int i = startIndex; i <= endIndex; ++i) {
1404         const MatchedProperties& matchedProperties = matchResult.matchedProperties[i];
1405         applyProperties<pass>(state, matchedProperties.properties.get(), matchResult.matchedRules[i], isImportant, inheritedOnly, static_cast<PropertyWhitelistType>(matchedProperties.whitelistType));
1406     }
1407 }
1408
1409 static unsigned computeMatchedPropertiesHash(const MatchedProperties* properties, unsigned size)
1410 {
1411     return StringHasher::hashMemory(properties, sizeof(MatchedProperties) * size);
1412 }
1413
1414 void StyleResolver::invalidateMatchedPropertiesCache()
1415 {
1416     m_matchedPropertiesCache.clear();
1417 }
1418
1419 void StyleResolver::notifyResizeForViewportUnits()
1420 {
1421     collectViewportRules();
1422     m_matchedPropertiesCache.clearViewportDependent();
1423 }
1424
1425 void StyleResolver::applyMatchedProperties(StyleResolverState& state, const MatchResult& matchResult)
1426 {
1427     const Element* element = state.element();
1428     ASSERT(element);
1429
1430     INCREMENT_STYLE_STATS_COUNTER(*this, matchedPropertyApply);
1431
1432     unsigned cacheHash = matchResult.isCacheable ? computeMatchedPropertiesHash(matchResult.matchedProperties.data(), matchResult.matchedProperties.size()) : 0;
1433     bool applyInheritedOnly = false;
1434     const CachedMatchedProperties* cachedMatchedProperties = 0;
1435
1436     if (cacheHash && (cachedMatchedProperties = m_matchedPropertiesCache.find(cacheHash, state, matchResult))
1437         && MatchedPropertiesCache::isCacheable(element, state.style(), state.parentStyle())) {
1438         INCREMENT_STYLE_STATS_COUNTER(*this, matchedPropertyCacheHit);
1439         // We can build up the style by copying non-inherited properties from an earlier style object built using the same exact
1440         // style declarations. We then only need to apply the inherited properties, if any, as their values can depend on the
1441         // element context. This is fast and saves memory by reusing the style data structures.
1442         state.style()->copyNonInheritedFrom(cachedMatchedProperties->renderStyle.get());
1443         if (state.parentStyle()->inheritedDataShared(cachedMatchedProperties->parentRenderStyle.get()) && !isAtShadowBoundary(element)
1444             && (!state.distributedToInsertionPoint() || state.style()->userModify() == READ_ONLY)) {
1445             INCREMENT_STYLE_STATS_COUNTER(*this, matchedPropertyCacheInheritedHit);
1446
1447             EInsideLink linkStatus = state.style()->insideLink();
1448             // If the cache item parent style has identical inherited properties to the current parent style then the
1449             // resulting style will be identical too. We copy the inherited properties over from the cache and are done.
1450             state.style()->inheritFrom(cachedMatchedProperties->renderStyle.get());
1451
1452             // Unfortunately the link status is treated like an inherited property. We need to explicitly restore it.
1453             state.style()->setInsideLink(linkStatus);
1454             return;
1455         }
1456         applyInheritedOnly = true;
1457     }
1458
1459     // Apply animation properties in order to apply animation results and trigger transitions below.
1460     applyMatchedProperties<AnimationProperties>(state, matchResult, false, 0, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
1461     applyMatchedProperties<AnimationProperties>(state, matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
1462     applyMatchedProperties<AnimationProperties>(state, matchResult, true, matchResult.ranges.firstUserRule, matchResult.ranges.lastUserRule, applyInheritedOnly);
1463     applyMatchedProperties<AnimationProperties>(state, matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
1464
1465     // Now we have all of the matched rules in the appropriate order. Walk the rules and apply
1466     // high-priority properties first, i.e., those properties that other properties depend on.
1467     // The order is (1) high-priority not important, (2) high-priority important, (3) normal not important
1468     // and (4) normal important.
1469     state.setLineHeightValue(0);
1470     applyMatchedProperties<HighPriorityProperties>(state, matchResult, false, 0, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
1471     applyMatchedProperties<HighPriorityProperties>(state, matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
1472     applyMatchedProperties<HighPriorityProperties>(state, matchResult, true, matchResult.ranges.firstUserRule, matchResult.ranges.lastUserRule, applyInheritedOnly);
1473     applyMatchedProperties<HighPriorityProperties>(state, matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
1474
1475     if (UNLIKELY(isSVGForeignObjectElement(element))) {
1476         // RenderSVGRoot handles zooming for the whole SVG subtree, so foreignObject content should not be scaled again.
1477         //
1478         // FIXME: The following hijacks the zoom property for foreignObject so that children of foreignObject get the
1479         // correct font-size in case of zooming. 'zoom' is part of HighPriorityProperties, along with other font-related
1480         // properties used as input to the FontBuilder, so resetting it here may cause the FontBuilder to recompute the
1481         // font used as inheritable font for foreignObject content. If we want to support zoom on foreignObject we'll
1482         // need to find another way of handling the SVG zoom model.
1483         state.setEffectiveZoom(RenderStyle::initialZoom());
1484     }
1485
1486     if (cachedMatchedProperties && cachedMatchedProperties->renderStyle->effectiveZoom() != state.style()->effectiveZoom()) {
1487         state.fontBuilder().setFontDirty(true);
1488         applyInheritedOnly = false;
1489     }
1490
1491     // If our font got dirtied, go ahead and update it now.
1492     updateFont(state);
1493
1494     // Line-height is set when we are sure we decided on the font-size.
1495     if (state.lineHeightValue())
1496         StyleBuilder::applyProperty(CSSPropertyLineHeight, state, state.lineHeightValue());
1497
1498     // Many properties depend on the font. If it changes we just apply all properties.
1499     if (cachedMatchedProperties && cachedMatchedProperties->renderStyle->fontDescription() != state.style()->fontDescription())
1500         applyInheritedOnly = false;
1501
1502     // Now do the normal priority UA properties.
1503     applyMatchedProperties<LowPriorityProperties>(state, matchResult, false, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
1504
1505     // Cache the UA properties to pass them to RenderTheme in adjustRenderStyle.
1506     state.cacheUserAgentBorderAndBackground();
1507
1508     // Now do the author and user normal priority properties and all the !important properties.
1509     applyMatchedProperties<LowPriorityProperties>(state, matchResult, false, matchResult.ranges.lastUARule + 1, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
1510     applyMatchedProperties<LowPriorityProperties>(state, matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
1511     applyMatchedProperties<LowPriorityProperties>(state, matchResult, true, matchResult.ranges.firstUserRule, matchResult.ranges.lastUserRule, applyInheritedOnly);
1512     applyMatchedProperties<LowPriorityProperties>(state, matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
1513
1514     loadPendingResources(state);
1515
1516     if (!cachedMatchedProperties && cacheHash && MatchedPropertiesCache::isCacheable(element, state.style(), state.parentStyle())) {
1517         INCREMENT_STYLE_STATS_COUNTER(*this, matchedPropertyCacheAdded);
1518         m_matchedPropertiesCache.add(state.style(), state.parentStyle(), cacheHash, matchResult);
1519     }
1520
1521     ASSERT(!state.fontBuilder().fontDirty());
1522 }
1523
1524 CSSPropertyValue::CSSPropertyValue(CSSPropertyID id, const StylePropertySet& propertySet)
1525     : property(id), value(propertySet.getPropertyCSSValue(id).get())
1526 { }
1527
1528 void StyleResolver::enableStats(StatsReportType reportType)
1529 {
1530     if (m_styleResolverStats)
1531         return;
1532     m_styleResolverStats = StyleResolverStats::create();
1533     m_styleResolverStatsTotals = StyleResolverStats::create();
1534     if (reportType == ReportSlowStats) {
1535         m_styleResolverStats->printMissedCandidateCount = true;
1536         m_styleResolverStatsTotals->printMissedCandidateCount = true;
1537     }
1538 }
1539
1540 void StyleResolver::disableStats()
1541 {
1542     m_styleResolverStatsSequence = 0;
1543     m_styleResolverStats.clear();
1544     m_styleResolverStatsTotals.clear();
1545 }
1546
1547 void StyleResolver::printStats()
1548 {
1549     if (!m_styleResolverStats)
1550         return;
1551     fprintf(stderr, "=== Style Resolver Stats (resolve #%u) (%s) ===\n", ++m_styleResolverStatsSequence, m_document.url().string().utf8().data());
1552     fprintf(stderr, "%s\n", m_styleResolverStats->report().utf8().data());
1553     fprintf(stderr, "== Totals ==\n");
1554     fprintf(stderr, "%s\n", m_styleResolverStatsTotals->report().utf8().data());
1555 }
1556
1557 void StyleResolver::applyPropertiesToStyle(const CSSPropertyValue* properties, size_t count, RenderStyle* style)
1558 {
1559     StyleResolverState state(document(), document().documentElement(), style);
1560     state.setStyle(style);
1561
1562     state.fontBuilder().initForStyleResolve(document(), style);
1563
1564     for (size_t i = 0; i < count; ++i) {
1565         if (properties[i].value) {
1566             // As described in BUG66291, setting font-size and line-height on a font may entail a CSSPrimitiveValue::computeLengthDouble call,
1567             // which assumes the fontMetrics are available for the affected font, otherwise a crash occurs (see http://trac.webkit.org/changeset/96122).
1568             // The updateFont() call below updates the fontMetrics and ensure the proper setting of font-size and line-height.
1569             switch (properties[i].property) {
1570             case CSSPropertyFontSize:
1571             case CSSPropertyLineHeight:
1572                 updateFont(state);
1573                 break;
1574             default:
1575                 break;
1576             }
1577             StyleBuilder::applyProperty(properties[i].property, state, properties[i].value);
1578         }
1579     }
1580 }
1581
1582 void StyleResolver::addMediaQueryResults(const MediaQueryResultList& list)
1583 {
1584     for (size_t i = 0; i < list.size(); ++i)
1585         m_viewportDependentMediaQueryResults.append(list[i]);
1586 }
1587
1588 bool StyleResolver::mediaQueryAffectedByViewportChange() const
1589 {
1590     for (unsigned i = 0; i < m_viewportDependentMediaQueryResults.size(); ++i) {
1591         if (m_medium->eval(m_viewportDependentMediaQueryResults[i]->expression()) != m_viewportDependentMediaQueryResults[i]->result())
1592             return true;
1593     }
1594     return false;
1595 }
1596
1597 void StyleResolver::trace(Visitor* visitor)
1598 {
1599     visitor->trace(m_keyframesRuleMap);
1600     visitor->trace(m_viewportDependentMediaQueryResults);
1601     visitor->trace(m_viewportStyleResolver);
1602     visitor->trace(m_features);
1603     visitor->trace(m_siblingRuleSet);
1604     visitor->trace(m_uncommonAttributeRuleSet);
1605     visitor->trace(m_watchedSelectorsRules);
1606     visitor->trace(m_treeBoundaryCrossingRules);
1607     visitor->trace(m_pendingStyleSheets);
1608 }
1609
1610 } // namespace WebCore