reflow comments in core/css/resolver

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
- * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc.
+ * All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
- * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
+ * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
+ * (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 72 matching lines @@
 #include "core/svg/SVGDocumentExtensions.h"
 #include "core/svg/SVGElement.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "wtf/StdLibExtras.h"
 
 namespace {
 
 using namespace blink;
 
 void setAnimationUpdateIfNeeded(StyleResolverState& state, Element& element) {
-  // If any changes to CSS Animations were detected, stash the update away for application after the
-  // layout object is updated if we're in the appropriate scope.
+  // If any changes to CSS Animations were detected, stash the update away for
+  // application after the layout object is updated if we're in the appropriate
+  // scope.
   if (!state.animationUpdate().isEmpty())
     element.ensureElementAnimations().cssAnimations().setPendingUpdate(
         state.animationUpdate());
 }
 
 // Returns whether any @apply rule sets a custom property
 bool cacheCustomPropertiesForApplyAtRules(StyleResolverState& state,
                                           const MatchedPropertiesRange& range) {
   bool ruleSetsCustomProperty = false;
-  // TODO(timloh): @apply should also work with properties registered as non-inherited.
+  // TODO(timloh): @apply should also work with properties registered as
+  // non-inherited.
   if (!state.style()->inheritedVariables())
     return false;
   for (const auto& matchedProperties : range) {
     const StylePropertySet& properties = *matchedProperties.properties;
     unsigned propertyCount = properties.propertyCount();
     for (unsigned i = 0; i < propertyCount; ++i) {
       StylePropertySet::PropertyReference current = properties.propertyAt(i);
       if (current.id() != CSSPropertyApplyAtRule)
         continue;
       AtomicString name(toCSSCustomIdentValue(current.value()).value());
@@ skipping 142 matching lines @@
 void StyleResolver::appendPendingAuthorStyleSheets() {
   for (const auto& styleSheet : m_pendingStyleSheets)
     appendCSSStyleSheet(*styleSheet);
 
   m_pendingStyleSheets.clear();
   finishAppendAuthorStyleSheets();
 }
 
 void StyleResolver::appendAuthorStyleSheets(
     const HeapVector<Member<CSSStyleSheet>>& styleSheets) {
-  // This handles sheets added to the end of the stylesheet list only. In other cases the style resolver
-  // needs to be reconstructed. To handle insertions too the rule order numbers would need to be updated.
+  // This handles sheets added to the end of the stylesheet list only. In other
+  // cases the style resolver needs to be reconstructed. To handle insertions
+  // too the rule order numbers would need to be updated.
   for (const auto& styleSheet : styleSheets)
     appendCSSStyleSheet(*styleSheet);
 }
 
 void StyleResolver::finishAppendAuthorStyleSheets() {
   collectFeatures();
 
   if (!document().layoutViewItem().isNull() &&
       document().layoutViewItem().style())
     document().layoutViewItem().style()->font().update(
@@ skipping 42 matching lines @@
   for (size_t i = 0; i < size; ++i)
     ruleSet->addRule(rules[i].rule, rules[i].selectorIndex,
                      rules[i].hasDocumentSecurityOrigin
                          ? RuleHasDocumentSecurityOrigin
                          : RuleHasNoSpecialState);
   return ruleSet;
 }
 
 void StyleResolver::collectFeatures() {
   m_features.clear();
-  // Collect all ids and rules using sibling selectors (:first-child and similar)
-  // in the current set of stylesheets. Style sharing code uses this information to reject
-  // sharing candidates.
+  // Collect all ids and rules using sibling selectors (:first-child and
+  // similar) in the current set of stylesheets. Style sharing code uses this
+  // information to reject sharing candidates.
   CSSDefaultStyleSheets& defaultStyleSheets = CSSDefaultStyleSheets::instance();
   if (defaultStyleSheets.defaultStyle()) {
     m_features.add(defaultStyleSheets.defaultStyle()->features());
     m_hasFullscreenUAStyle = defaultStyleSheets.fullscreenStyleSheet();
   }
 
   if (document().isViewSource())
     m_features.add(defaultStyleSheets.defaultViewSourceStyle()->features());
 
   if (m_watchedSelectorsRules)
@@ skipping 20 matching lines @@
                                 1);
   StyleSharingList& list = styleSharingList();
   if (list.size() >= styleSharingListSize)
     list.removeLast();
   list.prepend(&element);
 }
 
 StyleSharingList& StyleResolver::styleSharingList() {
   m_styleSharingLists.resize(styleSharingMaxDepth);
 
-  // We never put things at depth 0 into the list since that's only the <html> element
-  // and it has no siblings or cousins to share with.
+  // We never put things at depth 0 into the list since that's only the <html>
+  // element and it has no siblings or cousins to share with.
   unsigned depth =
       std::max(std::min(m_styleSharingDepth, styleSharingMaxDepth), 1u) - 1u;
 
   if (!m_styleSharingLists[depth])
     m_styleSharingLists[depth] = new StyleSharingList;
   return *m_styleSharingLists[depth];
 }
 
 void StyleResolver::clearStyleSharingList() {
   m_styleSharingLists.resize(0);
 }
 
 static inline ScopedStyleResolver* scopedResolverFor(const Element& element) {
   // Ideally, returning element->treeScope().scopedStyleResolver() should be
-  // enough, but ::cue and custom pseudo elements like ::-webkit-meter-bar pierce
-  // through a shadow dom boundary, yet they are not part of m_treeBoundaryCrossingScopes.
-  // The assumption here is that these rules only pierce through one boundary and
-  // that the scope of these elements do not have a style resolver due to the fact
-  // that VTT scopes and UA shadow trees don't have <style> elements. This is
-  // backed up by the ASSERTs below.
+  // enough, but ::cue and custom pseudo elements like ::-webkit-meter-bar
+  // pierce through a shadow dom boundary, yet they are not part of
+  // m_treeBoundaryCrossingScopes.  The assumption here is that these rules only
+  // pierce through one boundary and that the scope of these elements do not
+  // have a style resolver due to the fact that VTT scopes and UA shadow trees
+  // don't have <style> elements. This is backed up by the ASSERTs below.
   //
-  // FIXME: Make ::cue and custom pseudo elements part of boundary crossing rules
-  // when moving those rules to ScopedStyleResolver as part of issue 401359.
+  // FIXME: Make ::cue and custom pseudo elements part of boundary crossing
+  // rules when moving those rules to ScopedStyleResolver as part of issue
+  // 401359.
 
   TreeScope* treeScope = &element.treeScope();
   if (ScopedStyleResolver* resolver = treeScope->scopedStyleResolver()) {
     ASSERT(element.shadowPseudoId().isEmpty());
     ASSERT(!element.isVTTElement());
     return resolver;
   }
 
   treeScope = treeScope->parentTreeScope();
   if (!treeScope)
@@ skipping 59 matching lines @@
                                         isInlineStyleCacheable);
   }
 
   collector.finishAddingAuthorRulesForTreeScope();
 }
 
 static bool shouldCheckScope(const Element& element,
                              const Node& scopingNode,
                              bool isInnerTreeScope) {
   if (isInnerTreeScope && element.treeScope() != scopingNode.treeScope()) {
-    // Check if |element| may be affected by a ::content rule in |scopingNode|'s style.
-    // If |element| is a descendant of a shadow host which is ancestral to |scopingNode|,
-    // the |element| should be included for rule collection.
+    // Check if |element| may be affected by a ::content rule in |scopingNode|'s
+    // style.  If |element| is a descendant of a shadow host which is ancestral
+    // to |scopingNode|, the |element| should be included for rule collection.
     // Skip otherwise.
     const TreeScope* scope = &scopingNode.treeScope();
     while (scope && scope->parentTreeScope() != &element.treeScope())
       scope = scope->parentTreeScope();
     Element* shadowHost = scope ? scope->rootNode().ownerShadowHost() : nullptr;
     return shadowHost && element.isDescendantOf(shadowHost);
   }
 
-  // When |element| can be distributed to |scopingNode| via <shadow>, ::content rule can match,
-  // thus the case should be included.
+  // When |element| can be distributed to |scopingNode| via <shadow>, ::content
+  // rule can match, thus the case should be included.
   if (!isInnerTreeScope &&
       scopingNode.parentOrShadowHostNode() ==
           element.treeScope().rootNode().parentOrShadowHostNode())
     return true;
 
-  // Obviously cases when ancestor scope has /deep/ or ::shadow rule should be included.
-  // Skip otherwise.
+  // Obviously cases when ancestor scope has /deep/ or ::shadow rule should be
+  // included.  Skip otherwise.
   return scopingNode.treeScope()
       .scopedStyleResolver()
       ->hasDeepOrShadowSelector();
 }
 
 void StyleResolver::matchScopedRules(const Element& element,
                                      ElementRuleCollector& collector) {
   // Match rules from treeScopes in the reverse tree-of-trees order, since the
   // cascading order for normal rules is such that when comparing rules from
   // different shadow trees, the rule from the tree which comes first in the
@@ skipping 18 matching lines @@
 
     bool isInnerTreeScope =
         element.containingTreeScope().isInclusiveAncestorOf(scope);
     if (!shouldCheckScope(element, **it, isInnerTreeScope))
       continue;
 
     if (!matchElementScopeDone &&
         scope.isInclusiveAncestorOf(element.containingTreeScope())) {
       matchElementScopeDone = true;
 
-      // At this point, the iterator has either encountered the scope for the element
-      // itself (if that scope has boundary-crossing rules), or the iterator has moved
-      // to a scope which appears before the element's scope in the tree-of-trees order.
-      // Try to match all rules from the element's scope.
+      // At this point, the iterator has either encountered the scope for the
+      // element itself (if that scope has boundary-crossing rules), or the
+      // iterator has moved to a scope which appears before the element's scope
+      // in the tree-of-trees order.  Try to match all rules from the element's
+      // scope.
 
       matchElementScopeRules(element, elementScopeResolver, collector);
       if (resolver == elementScopeResolver) {
         // Boundary-crossing rules already collected in matchElementScopeRules.
         continue;
       }
     }
 
     collector.clearMatchedRules();
     resolver->collectMatchingTreeBoundaryCrossingRules(collector);
@@ skipping 27 matching lines @@
 
   // Apply :host and :host-context rules from inner scopes.
   for (int j = resolversInShadowTree.size() - 1; j >= 0; --j)
     resolversInShadowTree.at(j)->collectMatchingShadowHostRules(collector,
                                                                 ++cascadeOrder);
 
   // Apply normal rules from element scope.
   if (ScopedStyleResolver* resolver = scopedResolverFor(element))
     resolver->collectMatchingAuthorRules(collector, ++cascadeOrder);
 
-  // Apply /deep/ and ::shadow rules from outer scopes, and ::content from inner.
+  // Apply /deep/ and ::shadow rules from outer scopes, and ::content from
+  // inner.
   collectTreeBoundaryCrossingRules(element, collector);
   collector.sortAndTransferMatchedRules();
 }
 
 void StyleResolver::matchUARules(ElementRuleCollector& collector) {
   collector.setMatchingUARules(true);
 
   CSSDefaultStyleSheets& defaultStyleSheets = CSSDefaultStyleSheets::instance();
   RuleSet* userAgentStyleSheet = m_printMediaType
                                      ? defaultStyleSheets.defaultPrintStyle()
                                      : defaultStyleSheets.defaultStyle();
   matchRuleSet(collector, userAgentStyleSheet);
 
   // In quirks mode, we match rules from the quirks user agent sheet.
   if (document().inQuirksMode())
     matchRuleSet(collector, defaultStyleSheets.defaultQuirksStyle());
 
-  // 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.
+  // 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.
   if (document().isViewSource())
     matchRuleSet(collector, defaultStyleSheets.defaultViewSourceStyle());
 
   collector.finishAddingUARules();
   collector.setMatchingUARules(false);
 }
 
 void StyleResolver::matchRuleSet(ElementRuleCollector& collector,
                                  RuleSet* rules) {
   collector.clearMatchedRules();
   collector.collectMatchingRules(MatchRequest(rules));
   collector.sortAndTransferMatchedRules();
 }
 
 void StyleResolver::matchAllRules(StyleResolverState& state,
                                   ElementRuleCollector& collector,
                                   bool includeSMILProperties) {
   matchUARules(collector);
 
-  // Now check author rules, beginning first with presentational attributes mapped from HTML.
+  // Now check author rules, beginning first with presentational attributes
+  // mapped from HTML.
   if (state.element()->isStyledElement()) {
     collector.addElementStyleProperties(
         state.element()->presentationAttributeStyle());
 
     // Now we check additional mapped declarations.
-    // Tables and table cells share an additional mapped rule that must be applied
-    // after all attributes, since their mapped style depends on the values of multiple attributes.
+    // Tables and table cells share an additional mapped rule that must be
+    // applied after all attributes, since their mapped style depends on the
+    // values of multiple attributes.
     collector.addElementStyleProperties(
         state.element()->additionalPresentationAttributeStyle());
 
     if (state.element()->isHTMLElement()) {
       bool isAuto;
       TextDirection textDirection =
           toHTMLElement(state.element())
               ->directionalityIfhasDirAutoAttribute(isAuto);
       if (isAuto) {
         state.setHasDirAutoAttribute(true);
         collector.addElementStyleProperties(textDirection == LTR
                                                 ? leftToRightDeclaration()
                                                 : rightToLeftDeclaration());
       }
     }
   }
 
   matchAuthorRules(*state.element(), collector);
 
   if (state.element()->isStyledElement()) {
-    // For Shadow DOM V1, inline style is already collected in matchScopedRules().
+    // For Shadow DOM V1, inline style is already collected in
+    // matchScopedRules().
     if (document().shadowCascadeOrder() !=
             ShadowCascadeOrder::ShadowCascadeV1 &&
         state.element()->inlineStyle()) {
       // Inline style is immutable as long as there is no CSSOM wrapper.
       bool isInlineStyleCacheable =
           !state.element()->inlineStyle()->isMutable();
       collector.addElementStyleProperties(state.element()->inlineStyle(),
                                           isInlineStyleCacheable);
     }
 
@@ skipping 12 matching lines @@
     ElementRuleCollector& collector) {
   if (m_treeBoundaryCrossingScopes.isEmpty())
     return;
 
   // When comparing rules declared in outer treescopes, outer's rules win.
   CascadeOrder outerCascadeOrder = m_treeBoundaryCrossingScopes.size() * 2;
   // When comparing rules declared in inner treescopes, inner's rules win.
   CascadeOrder innerCascadeOrder = m_treeBoundaryCrossingScopes.size();
 
   for (const auto& scopingNode : m_treeBoundaryCrossingScopes) {
-    // Skip rule collection for element when tree boundary crossing rules of scopingNode's
-    // scope can never apply to it.
+    // Skip rule collection for element when tree boundary crossing rules of
+    // scopingNode's scope can never apply to it.
     bool isInnerTreeScope = element.containingTreeScope().isInclusiveAncestorOf(
         scopingNode->containingTreeScope());
     if (!shouldCheckScope(element, *scopingNode, isInnerTreeScope))
       continue;
 
     CascadeOrder cascadeOrder =
         isInnerTreeScope ? innerCascadeOrder : outerCascadeOrder;
     scopingNode->treeScope()
         .scopedStyleResolver()
         ->collectMatchingTreeBoundaryCrossingRules(collector, cascadeOrder);
@@ skipping 12 matching lines @@
   documentStyle->setZoom(frame && !document.printing() ? frame->pageZoomFactor()
                                                        : 1);
   FontDescription documentFontDescription = documentStyle->getFontDescription();
   documentFontDescription.setLocale(
       LayoutLocale::get(document.contentLanguage()));
   documentStyle->setFontDescription(documentFontDescription);
   documentStyle->setZIndex(0);
   documentStyle->setIsStackingContext(true);
   documentStyle->setUserModify(document.inDesignMode() ? READ_WRITE
                                                        : READ_ONLY);
-  // These are designed to match the user-agent stylesheet values for the document element
-  // so that the common case doesn't need to create a new ComputedStyle in
-  // Document::inheritHtmlAndBodyElementStyles.
+  // These are designed to match the user-agent stylesheet values for the
+  // document element so that the common case doesn't need to create a new
+  // ComputedStyle in Document::inheritHtmlAndBodyElementStyles.
   documentStyle->setDisplay(EDisplay::Block);
   documentStyle->setPosition(AbsolutePosition);
 
   document.setupFontBuilder(*documentStyle);
 
   return documentStyle.release();
 }
 
 void StyleResolver::adjustComputedStyle(StyleResolverState& state,
                                         Element* element) {
   StyleAdjuster::adjustComputedStyle(state.mutableStyleRef(),
                                      *state.parentStyle(), element);
 }
 
 // Start loading resources referenced by this style.
 void StyleResolver::loadPendingResources(StyleResolverState& state) {
   state.elementStyleResources().loadPendingResources(state.style());
 }
 
 PassRefPtr<ComputedStyle> StyleResolver::styleForElement(
     Element* element,
     const ComputedStyle* defaultParent,
     StyleSharingBehavior sharingBehavior,
     RuleMatchingBehavior matchingBehavior) {
   DCHECK(document().frame());
   ASSERT(document().settings());
   ASSERT(!hasPendingAuthorStyleSheets());
   ASSERT(!m_needCollectFeatures);
 
-  // Once an element has a layoutObject, we don't try to destroy it, since otherwise the layoutObject
-  // will vanish if a style recalc happens during loading.
+  // Once an element has a layoutObject, we don't try to destroy it, since
+  // otherwise the layoutObject will vanish if a style recalc happens during
+  // loading.
   if (sharingBehavior == AllowStyleSharing && !document().isRenderingReady() &&
       !element->layoutObject()) {
     if (!s_styleNotYetAvailable) {
       s_styleNotYetAvailable = ComputedStyle::create().leakRef();
       s_styleNotYetAvailable->setDisplay(EDisplay::None);
       s_styleNotYetAvailable->font().update(
           document().styleEngine().fontSelector());
     }
 
     document().setHasNodesWithPlaceholderStyle();
@@ skipping 86 matching lines @@
             toCSSIdentifierValue(*value).getValueID() == CSSValueBlock)
           UseCounter::count(
               element->document(),
               UseCounter::SummaryElementWithDisplayBlockAuthorRule);
       }
     }
 
     if (element->computedStyle() &&
         element->computedStyle()->textAutosizingMultiplier() !=
             state.style()->textAutosizingMultiplier()) {
-      // Preserve the text autosizing multiplier on style recalc. Autosizer will update it during layout if needed.
-      // NOTE: this must occur before applyMatchedProperties for correct computation of font-relative lengths.
+      // Preserve the text autosizing multiplier on style recalc. Autosizer will
+      // update it during layout if needed.
+      // NOTE: this must occur before applyMatchedProperties for correct
+      // computation of font-relative lengths.
       state.style()->setTextAutosizingMultiplier(
           element->computedStyle()->textAutosizingMultiplier());
       state.style()->setUnique();
     }
 
     if (state.hasDirAutoAttribute())
       state.style()->setSelfOrAncestorHasDirAutoAttribute(true);
 
     applyMatchedProperties(state, collector.matchedResult());
     applyCallbackSelectors(state);
 
     // Cache our original display.
     state.style()->setOriginalDisplay(state.style()->display());
 
     adjustComputedStyle(state, element);
 
     if (elementAnimations)
       elementAnimations->updateBaseComputedStyle(state.style());
   } else {
     INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), baseStylesUsed, 1);
   }
 
-  // FIXME: The CSSWG wants to specify that the effects of animations are applied before
-  // important rules, but this currently happens here as we require adjustment to have happened
-  // before deciding which properties to transition.
+  // FIXME: The CSSWG wants to specify that the effects of animations are
+  // applied before important rules, but this currently happens here as we
+  // require adjustment to have happened before deciding which properties to
+  // transition.
   if (applyAnimatedProperties(state, element)) {
     INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), stylesAnimated, 1);
     adjustComputedStyle(state, element);
   }
 
   if (isHTMLBodyElement(*element))
     document().textLinkColors().setTextColor(state.style()->color());
 
   setAnimationUpdateIfNeeded(state, *element);
 
   if (state.style()->hasViewportUnits())
     document().setHasViewportUnits();
 
   if (state.style()->hasRemUnits())
     document().styleEngine().setUsesRemUnit(true);
 
   // Now return the style.
   return state.takeStyle();
 }
 
-// TODO(alancutter): Create compositor keyframe values directly instead of intermediate AnimatableValues.
+// TODO(alancutter): Create compositor keyframe values directly instead of
+// intermediate AnimatableValues.
 PassRefPtr<AnimatableValue> StyleResolver::createAnimatableValueSnapshot(
     Element& element,
     const ComputedStyle& baseStyle,
     const ComputedStyle* parentStyle,
     CSSPropertyID property,
     const CSSValue* value) {
-  // TODO(alancutter): Avoid creating a StyleResolverState just to apply a single value on a ComputedStyle.
+  // TODO(alancutter): Avoid creating a StyleResolverState just to apply a
+  // single value on a ComputedStyle.
   StyleResolverState state(element.document(), &element, parentStyle);
   state.setStyle(ComputedStyle::clone(baseStyle));
   if (value) {
     StyleBuilder::applyProperty(property, state, *value);
     state.fontBuilder().createFont(
         state.document().styleEngine().fontSelector(), state.mutableStyleRef());
   }
   return CSSAnimatableValueFactory::create(property, *state.style());
 }
 
@@ skipping 108 matching lines @@
     state.style()->setOriginalDisplay(state.style()->display());
 
     // FIXME: Passing 0 as the Element* introduces a lot of complexity
     // in the adjustComputedStyle code.
     adjustComputedStyle(state, 0);
 
     if (elementAnimations)
       elementAnimations->updateBaseComputedStyle(state.style());
   }
 
-  // FIXME: The CSSWG wants to specify that the effects of animations are applied before
-  // important rules, but this currently happens here as we require adjustment to have happened
-  // before deciding which properties to transition.
+  // FIXME: The CSSWG wants to specify that the effects of animations are
+  // applied before important rules, but this currently happens here as we
+  // require adjustment to have happened before deciding which properties to
+  // transition.
   if (applyAnimatedProperties(state, pseudoElement))
     adjustComputedStyle(state, 0);
 
   document().styleEngine().incStyleForElementCount();
   INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), pseudoElementsStyled,
                                 1);
 
   if (state.style()->hasViewportUnits())
     document().setHasViewportUnits();
 
@@ skipping 19 matching lines @@
   if (PseudoElement* pseudoElement =
           element->pseudoElement(pseudoStyleRequest.pseudoId))
     setAnimationUpdateIfNeeded(state, *pseudoElement);
 
   // Now return the style.
   return state.takeStyle();
 }
 
 PassRefPtr<ComputedStyle> StyleResolver::styleForPage(int pageIndex) {
   ASSERT(!hasPendingAuthorStyleSheets());
-  StyleResolverState state(
-      document(),
-      document()
-          .documentElement());  // m_rootElementStyle will be set to the document style.
+  // m_rootElementStyle will be set to the document style.
+  StyleResolverState state(document(), document().documentElement());
 
   RefPtr<ComputedStyle> style = ComputedStyle::create();
   const ComputedStyle* rootElementStyle = state.rootElementStyle()
                                               ? state.rootElementStyle()
                                               : document().computedStyle();
   ASSERT(rootElementStyle);
   style->inheritFrom(*rootElementStyle);
   state.setStyle(style.release());
 
   PageRuleCollector collector(rootElementStyle, pageIndex);
@@ skipping 87 matching lines @@
     matchUARules(collector);
 
   if (rulesToInclude & AuthorCSSRules) {
     collector.setSameOriginOnly(!(rulesToInclude & CrossOriginCSSRules));
     collector.setIncludeEmptyRules(rulesToInclude & EmptyCSSRules);
     matchAuthorRules(element, collector);
   }
 }
 
 // -------------------------------------------------------------------------------------
-// this is mostly boring stuff on how to apply a certain rule to the Computedstyle...
+// this is mostly boring stuff on how to apply a certain rule to the
+// Computedstyle...
 
 bool StyleResolver::applyAnimatedProperties(StyleResolverState& state,
                                             const Element* animatingElement) {
   Element* element = state.element();
   ASSERT(element);
 
   // The animating element may be this element, or its pseudo element. It is
   // null when calculating the style for a potential pseudo element that has
   // yet to be created.
   ASSERT(animatingElement == element || !animatingElement ||
@@ skipping 62 matching lines @@
   for (auto& resolver : resolvers)
     resolver->setHasUnresolvedKeyframesRule();
   return nullptr;
 }
 
 template <CSSPropertyPriority priority>
 void StyleResolver::applyAnimatedProperties(
     StyleResolverState& state,
     const ActiveInterpolationsMap& activeInterpolationsMap) {
   // TODO(alancutter): Don't apply presentation attribute animations here,
-  // they should instead apply in SVGElement::collectStyleForPresentationAttribute().
+  // they should instead apply in
+  // SVGElement::collectStyleForPresentationAttribute().
   for (const auto& entry : activeInterpolationsMap) {
     CSSPropertyID property = entry.key.isCSSProperty()
                                  ? entry.key.cssProperty()
                                  : entry.key.presentationAttribute();
     if (!CSSPropertyPriorityData<priority>::propertyHasPriority(property))
       continue;
     const Interpolation& interpolation = *entry.value.first();
     if (interpolation.isInvalidatableInterpolation()) {
       InterpolationEnvironment environment(state);
       InvalidatableInterpolation::applyStack(entry.value, environment);
     } else {
-      // TODO(alancutter): Remove this old code path once animations have completely migrated to InterpolationTypes.
+      // TODO(alancutter): Remove this old code path once animations have
+      // completely migrated to InterpolationTypes.
       toStyleInterpolation(interpolation).apply(state);
     }
   }
 }
 
 static inline bool isValidCueStyleProperty(CSSPropertyID id) {
   switch (id) {
     case CSSPropertyBackground:
     case CSSPropertyBackgroundAttachment:
     case CSSPropertyBackgroundClip:
@@ skipping 157 matching lines @@
 
     default:
       return false;
   }
 }
 
 static bool shouldIgnoreTextTrackAuthorStyle(const Document& document) {
   Settings* settings = document.settings();
   if (!settings)
     return false;
-  // Ignore author specified settings for text tracks when any of the user settings are present.
+  // Ignore author specified settings for text tracks when any of the user
+  // settings are present.
   if (!settings->textTrackBackgroundColor().isEmpty() ||
       !settings->textTrackFontFamily().isEmpty() ||
       !settings->textTrackFontStyle().isEmpty() ||
       !settings->textTrackFontVariant().isEmpty() ||
       !settings->textTrackTextColor().isEmpty() ||
       !settings->textTrackTextShadow().isEmpty() ||
       !settings->textTrackTextSize().isEmpty())
     return true;
   return false;
 }
@@ skipping 103 matching lines @@
     if (property == CSSPropertyAll) {
       applyAllProperty<priority>(state, current.value(), inheritedOnly,
                                  propertyWhitelistType);
       continue;
     }
 
     if (!isPropertyInWhitelist(propertyWhitelistType, property, document()))
       continue;
 
     if (inheritedOnly && !current.isInherited()) {
-      // If the property value is explicitly inherited, we need to apply further non-inherited properties
-      // as they might override the value inherited here. For this reason we don't allow declarations with
-      // explicitly inherited properties to be cached.
+      // If the property value is explicitly inherited, we need to apply further
+      // non-inherited properties as they might override the value inherited
+      // here. For this reason we don't allow declarations with explicitly
+      // inherited properties to be cached.
       DCHECK(!current.value().isInheritedValue());
       continue;
     }
 
     if (!CSSPropertyPriorityData<priority>::propertyHasPriority(property))
       continue;
 
     StyleBuilder::applyProperty(current.id(), state, current.value());
   }
 }
 
 template <CSSPropertyPriority priority>
 void StyleResolver::applyMatchedProperties(StyleResolverState& state,
                                            const MatchedPropertiesRange& range,
                                            bool isImportant,
                                            bool inheritedOnly) {
   if (range.isEmpty())
     return;
 
   if (state.style()->insideLink() != NotInsideLink) {
     for (const auto& matchedProperties : range) {
       unsigned linkMatchType = matchedProperties.m_types.linkMatchType;
-      // FIXME: It would be nicer to pass these as arguments but that requires changes in many places.
+      // FIXME: It would be nicer to pass these as arguments but that requires
+      // changes in many places.
       state.setApplyPropertyToRegularStyle(linkMatchType &
                                            CSSSelector::MatchLink);
       state.setApplyPropertyToVisitedLinkStyle(linkMatchType &
                                                CSSSelector::MatchVisited);
 
       applyProperties<priority>(state, matchedProperties.properties.get(),
                                 isImportant, inheritedOnly,
                                 static_cast<PropertyWhitelistType>(
                                     matchedProperties.m_types.whitelistType));
     }
@@ skipping 40 matching lines @@
   bool applyInheritedOnly = false;
   const CachedMatchedProperties* cachedMatchedProperties =
       cacheHash
           ? m_matchedPropertiesCache.find(cacheHash, state,
                                           matchResult.matchedProperties())
           : nullptr;
 
   if (cachedMatchedProperties && MatchedPropertiesCache::isCacheable(state)) {
     INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(),
                                   matchedPropertyCacheHit, 1);
-    // We can build up the style by copying non-inherited properties from an earlier style object built using the same exact
-    // style declarations. We then only need to apply the inherited properties, if any, as their values can depend on the
-    // element context. This is fast and saves memory by reusing the style data structures.
+    // We can build up the style by copying non-inherited properties from an
+    // earlier style object built using the same exact style declarations. We
+    // then only need to apply the inherited properties, if any, as their values
+    // can depend on the element context. This is fast and saves memory by
+    // reusing the style data structures.
     state.style()->copyNonInheritedFromCached(
         *cachedMatchedProperties->computedStyle);
     if (state.parentStyle()->inheritedDataShared(
             *cachedMatchedProperties->parentComputedStyle) &&
         !isAtShadowBoundary(element) &&
         (!state.distributedToInsertionPoint() ||
          state.style()->userModify() == READ_ONLY)) {
       INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(),
                                     matchedPropertyCacheInheritedHit, 1);
 
       EInsideLink linkStatus = state.style()->insideLink();
-      // If the cache item parent style has identical inherited properties to the current parent style then the
-      // resulting style will be identical too. We copy the inherited properties over from the cache and are done.
+      // If the cache item parent style has identical inherited properties to
+      // the current parent style then the resulting style will be identical
+      // too. We copy the inherited properties over from the cache and are done.
       state.style()->inheritFrom(*cachedMatchedProperties->computedStyle);
 
-      // Unfortunately the link status is treated like an inherited property. We need to explicitly restore it.
+      // Unfortunately the link status is treated like an inherited property. We
+      // need to explicitly restore it.
       state.style()->setInsideLink(linkStatus);
 
       updateFont(state);
 
       return;
     }
     applyInheritedOnly = true;
   }
 
-  // TODO(leviw): We need the proper bit for tracking whether we need to do this work.
+  // TODO(leviw): We need the proper bit for tracking whether we need to do this
+  // work.
   applyMatchedProperties<ResolveVariables>(state, matchResult.authorRules(),
                                            false, applyInheritedOnly);
   applyMatchedProperties<ResolveVariables>(state, matchResult.authorRules(),
                                            true, applyInheritedOnly);
   // TODO(leviw): stop recalculating every time
   CSSVariableResolver::resolveVariableDefinitions(state);
 
   if (RuntimeEnabledFeatures::cssApplyAtRulesEnabled()) {
     if (cacheCustomPropertiesForApplyAtRules(state,
                                              matchResult.authorRules())) {
       applyMatchedProperties<ResolveVariables>(state, matchResult.authorRules(),
                                                false, applyInheritedOnly);
       applyMatchedProperties<ResolveVariables>(state, matchResult.authorRules(),
                                                true, applyInheritedOnly);
       CSSVariableResolver::resolveVariableDefinitions(state);
     }
   }
 
-  // Now we have all of the matched rules in the appropriate order. Walk the rules and apply
-  // high-priority properties first, i.e., those properties that other properties depend on.
-  // The order is (1) high-priority not important, (2) high-priority important, (3) normal not important
-  // and (4) normal important.
+  // Now we have all of the matched rules in the appropriate order. Walk the
+  // rules and apply high-priority properties first, i.e., those properties that
+  // other properties depend on.  The order is (1) high-priority not important,
+  // (2) high-priority important, (3) normal not important and (4) normal
+  // important.
   applyMatchedProperties<HighPropertyPriority>(state, matchResult.allRules(),
                                                false, applyInheritedOnly);
   for (auto range : ImportantAuthorRanges(matchResult))
     applyMatchedProperties<HighPropertyPriority>(state, range, true,
                                                  applyInheritedOnly);
   applyMatchedProperties<HighPropertyPriority>(state, matchResult.uaRules(),
                                                true, applyInheritedOnly);
 
   if (UNLIKELY(isSVGForeignObjectElement(element))) {
-    // LayoutSVGRoot handles zooming for the whole SVG subtree, so foreignObject content should not be scaled again.
+    // LayoutSVGRoot handles zooming for the whole SVG subtree, so foreignObject
+    // content should not be scaled again.
     //
-    // FIXME: The following hijacks the zoom property for foreignObject so that children of foreignObject get the
-    // correct font-size in case of zooming. 'zoom' has HighPropertyPriority, along with other font-related
-    // properties used as input to the FontBuilder, so resetting it here may cause the FontBuilder to recompute the
-    // font used as inheritable font for foreignObject content. If we want to support zoom on foreignObject we'll
+    // FIXME: The following hijacks the zoom property for foreignObject so that
+    // children of foreignObject get the correct font-size in case of zooming.
+    // 'zoom' has HighPropertyPriority, along with other font-related properties
+    // used as input to the FontBuilder, so resetting it here may cause the
+    // FontBuilder to recompute the font used as inheritable font for
+    // foreignObject content. If we want to support zoom on foreignObject we'll
     // need to find another way of handling the SVG zoom model.
     state.setEffectiveZoom(ComputedStyle::initialZoom());
   }
 
   if (cachedMatchedProperties &&
       cachedMatchedProperties->computedStyle->effectiveZoom() !=
           state.style()->effectiveZoom()) {
     state.fontBuilder().didChangeEffectiveZoom();
     applyInheritedOnly = false;
   }
 
   // If our font got dirtied, go ahead and update it now.
   updateFont(state);
 
-  // Many properties depend on the font. If it changes we just apply all properties.
+  // Many properties depend on the font. If it changes we just apply all
+  // properties.
   if (cachedMatchedProperties &&
       cachedMatchedProperties->computedStyle->getFontDescription() !=
           state.style()->getFontDescription())
     applyInheritedOnly = false;
 
   // Now do the normal priority UA properties.
   applyMatchedProperties<LowPropertyPriority>(state, matchResult.uaRules(),
                                               false, applyInheritedOnly);
 
   // Cache the UA properties to pass them to LayoutTheme in adjustComputedStyle.
   state.cacheUserAgentBorderAndBackground();
 
-  // Now do the author and user normal priority properties and all the !important properties.
+  // Now do the author and user normal priority properties and all the
+  // !important properties.
   applyMatchedProperties<LowPropertyPriority>(state, matchResult.authorRules(),
                                               false, applyInheritedOnly);
   for (auto range : ImportantAuthorRanges(matchResult))
     applyMatchedProperties<LowPropertyPriority>(state, range, true,
                                                 applyInheritedOnly);
   applyMatchedProperties<LowPropertyPriority>(state, matchResult.uaRules(),
                                               true, applyInheritedOnly);
 
   if (state.style()->hasAppearance() && !applyInheritedOnly) {
-    // Check whether the final border and background differs from the cached UA ones.
-    // When there is a partial match in the MatchedPropertiesCache, these flags will already be set correctly
-    // and the value stored in cacheUserAgentBorderAndBackground is incorrect, so doing this check again
+    // Check whether the final border and background differs from the cached UA
+    // ones.  When there is a partial match in the MatchedPropertiesCache, these
+    // flags will already be set correctly and the value stored in
+    // cacheUserAgentBorderAndBackground is incorrect, so doing this check again
     // would give the wrong answer.
     state.style()->setHasAuthorBackground(hasAuthorBackground(state));
     state.style()->setHasAuthorBorder(hasAuthorBorder(state));
   }
 
   loadPendingResources(state);
 
   if (!cachedMatchedProperties && cacheHash &&
       MatchedPropertiesCache::isCacheable(state)) {
     ASSERT(RuntimeEnabledFeatures::styleMatchedPropertiesCacheEnabled());
@@ skipping 110 matching lines @@
   visitor->trace(m_siblingRuleSet);
   visitor->trace(m_uncommonAttributeRuleSet);
   visitor->trace(m_watchedSelectorsRules);
   visitor->trace(m_treeBoundaryCrossingScopes);
   visitor->trace(m_styleSharingLists);
   visitor->trace(m_pendingStyleSheets);
   visitor->trace(m_document);
 }
 
 }  // namespace blink