Move Document global rule data to CSSGlobalRuleSet.

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) 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/)
@@ skipping 69 matching lines @@
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLIFrameElement.h"
 #include "core/html/HTMLSlotElement.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/layout/GeneratedChildren.h"
-#include "core/layout/api/LayoutViewItem.h"
 #include "core/style/StyleInheritedVariables.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "core/svg/SVGElement.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "wtf/StdLibExtras.h"
 
 namespace {
 
 using namespace blink;
 
@@ skipping 73 matching lines @@
        shadowRoot = shadowRoot->olderShadowRoot()) {
     if (shadowRoot->numberOfStyles() > 0) {
       if (ScopedStyleResolver* resolver = shadowRoot->scopedStyleResolver())
         resolvers.append(resolver);
     }
   }
 }
 
 StyleResolver::StyleResolver(Document& document)
     : m_document(document),
-      m_needCollectFeatures(false),
       m_printMediaType(false),
       m_styleSharingDepth(0) {
   FrameView* view = document.view();
   DCHECK(view);
   m_medium = new MediaQueryEvaluator(&view->frame());
   m_printMediaType =
       equalIgnoringCase(view->mediaType(), MediaTypeNames::print);
-
-  initWatchedSelectorRules();
 }
 
 StyleResolver::~StyleResolver() {}
 
 void StyleResolver::dispose() {
   m_matchedPropertiesCache.clear();
 }
 
-void StyleResolver::initWatchedSelectorRules() {
-  m_watchedSelectorsRules = nullptr;
-  CSSSelectorWatch* watch = CSSSelectorWatch::fromIfExists(*m_document);
-  if (!watch)
-    return;
-  const HeapVector<Member<StyleRule>>& watchedSelectors =
-      watch->watchedCallbackSelectors();
-  if (!watchedSelectors.size())
-    return;
-  m_watchedSelectorsRules = RuleSet::create();
-  for (unsigned i = 0; i < watchedSelectors.size(); ++i)
-    m_watchedSelectorsRules->addStyleRule(watchedSelectors[i].get(),
-                                          RuleHasNoSpecialState);
-}
-
 void StyleResolver::lazyAppendAuthorStyleSheets(
     unsigned firstNew,
     const HeapVector<Member<CSSStyleSheet>>& styleSheets) {
   unsigned size = styleSheets.size();
   for (unsigned i = firstNew; i < size; ++i)
     m_pendingStyleSheets.add(styleSheets[i].get());
 }
 
 void StyleResolver::removePendingAuthorStyleSheets(
     const HeapVector<Member<CSSStyleSheet>>& styleSheets) {
@@ skipping 32 matching lines @@
     treeScope = m_document;
   treeScope->ensureScopedStyleResolver().appendCSSStyleSheet(cssSheet,
                                                              *m_medium);
 }
 
 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.
   for (const auto& styleSheet : styleSheets)
     appendCSSStyleSheet(*styleSheet);
 }
 
-void StyleResolver::finishAppendAuthorStyleSheets() {
-  collectFeatures();
-
-  if (!document().layoutViewItem().isNull() &&
-      document().layoutViewItem().style())
-    document().layoutViewItem().style()->font().update(
-        document().styleEngine().fontSelector());
-
-  document().styleEngine().resetCSSFeatureFlags(m_features);
-}
-
-void StyleResolver::resetRuleFeatures() {
-  // Need to recreate RuleFeatureSet.
-  m_features.clear();
-  m_siblingRuleSet.clear();
-  m_uncommonAttributeRuleSet.clear();
-  m_needCollectFeatures = true;
-}
-
-static RuleSet* makeRuleSet(const HeapVector<RuleFeature>& rules) {
-  size_t size = rules.size();
-  if (!size)
-    return nullptr;
-  RuleSet* ruleSet = RuleSet::create();
-  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.
-  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)
-    m_features.add(m_watchedSelectorsRules->features());
-
-  document().styleEngine().collectScopedStyleFeaturesTo(m_features);
-
-  m_siblingRuleSet = makeRuleSet(m_features.siblingRules);
-  m_uncommonAttributeRuleSet = makeRuleSet(m_features.uncommonAttributeRules);
-  m_needCollectFeatures = false;
-}
-
-bool StyleResolver::hasRulesForId(const AtomicString& id) const {
-  return m_features.hasSelectorForId(id);
-}
-
 void StyleResolver::addToStyleSharingList(Element& element) {
-  ASSERT(RuntimeEnabledFeatures::styleSharingEnabled());
+  DCHECK(RuntimeEnabledFeatures::styleSharingEnabled());
   // Never add elements to the style sharing list if we're not in a recalcStyle,
   // otherwise we could leave stale pointers in there.
   if (!document().inStyleRecalc())
     return;
   INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), sharedStyleCandidates,
                                 1);
   StyleSharingList& list = styleSharingList();
   if (list.size() >= styleSharingListSize)
     list.removeLast();
   list.prepend(&element);
@@ skipping 145 matching lines @@
   }
 
   bool matchElementScopeDone = !elementScopeResolver && !element.inlineStyle();
 
   const auto& treeBoundaryCrossingScopes =
       document().styleEngine().treeBoundaryCrossingScopes();
   for (auto it = treeBoundaryCrossingScopes.rbegin();
        it != treeBoundaryCrossingScopes.rend(); ++it) {
     const TreeScope& scope = (*it)->containingTreeScope();
     ScopedStyleResolver* resolver = scope.scopedStyleResolver();
-    ASSERT(resolver);
+    DCHECK(resolver);
 
     bool isInnerTreeScope =
         element.containingTreeScope().isInclusiveAncestorOf(scope);
     if (!shouldCheckScope(element, **it, isInnerTreeScope))
       continue;
 
     if (!matchElementScopeDone &&
         scope.isInclusiveAncestorOf(element.containingTreeScope())) {
       matchElementScopeDone = true;
 
@@ skipping 20 matching lines @@
     matchElementScopeRules(element, elementScopeResolver, collector);
 }
 
 void StyleResolver::matchAuthorRules(const Element& element,
                                      ElementRuleCollector& collector) {
   if (document().shadowCascadeOrder() != ShadowCascadeOrder::ShadowCascadeV1) {
     matchAuthorRulesV0(element, collector);
     return;
   }
 
-  ASSERT(RuntimeEnabledFeatures::shadowDOMV1Enabled());
+  DCHECK(RuntimeEnabledFeatures::shadowDOMV1Enabled());
   matchHostRules(element, collector);
   matchScopedRules(element, collector);
 }
 
 void StyleResolver::matchAuthorRulesV0(const Element& element,
                                        ElementRuleCollector& collector) {
   collector.clearMatchedRules();
 
   CascadeOrder cascadeOrder = 0;
   HeapVector<Member<ScopedStyleResolver>, 8> resolversInShadowTree;
@@ skipping 169 matching lines @@
 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);
+  DCHECK(document().settings());
+  DCHECK(!hasPendingAuthorStyleSheets());
 
   // 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();
     return s_styleNotYetAvailable;
   }
 
   document().styleEngine().incStyleForElementCount();
   INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), elementsStyled, 1);
 
   SelectorFilterParentScope::ensureParentStackIsPushed();
 
   ElementResolveContext elementContext(*element);
 
   if (RuntimeEnabledFeatures::styleSharingEnabled() &&
       sharingBehavior == AllowStyleSharing &&
       (defaultParent || elementContext.parentStyle())) {
-    SharedStyleFinder styleFinder(elementContext, m_features,
-                                  m_siblingRuleSet.get(),
-                                  m_uncommonAttributeRuleSet.get(), *this);
-    if (RefPtr<ComputedStyle> sharedStyle = styleFinder.findSharedStyle())
+    if (RefPtr<ComputedStyle> sharedStyle =
+            document().styleEngine().findSharedStyle(elementContext))
       return sharedStyle.release();
   }
 
   StyleResolverState state(document(), elementContext, defaultParent);
 
   ElementAnimations* elementAnimations = element->elementAnimations();
   const ComputedStyle* baseComputedStyle =
       elementAnimations ? elementAnimations->baseComputedStyle() : nullptr;
 
   if (baseComputedStyle) {
@@ skipping 29 matching lines @@
     if (linkState != NotInsideLink) {
       bool forceVisited = InspectorInstrumentation::forcePseudoState(
           element, CSSSelector::PseudoVisited);
       if (forceVisited)
         linkState = InsideVisitedLink;
     }
     state.style()->setInsideLink(linkState);
   }
 
   if (!baseComputedStyle) {
-    bool needsCollection = false;
-    CSSDefaultStyleSheets::instance().ensureDefaultStyleSheetsForElement(
-        *element, needsCollection);
-    if (needsCollection)
-      collectFeatures();
+    document().styleEngine().ensureUAStyleForElement(*element);
 
     ElementRuleCollector collector(state.elementContext(), m_selectorFilter,
                                    state.style());
 
     matchAllRules(state, collector,
                   matchingBehavior != MatchAllRulesExcludingSMIL);
 
     // TODO(dominicc): Remove this counter when Issue 590014 is fixed.
     if (element->hasTagName(HTMLNames::summaryTag)) {
       MatchedPropertiesRange properties =
@@ skipping 117 matching lines @@
           parentStyle->getCachedPseudoStyle(pseudoId)) {
     if (!pseudoElementLayoutObjectIsNeeded(cachedStyle))
       return nullptr;
     return createPseudoElement(&parent, pseudoId);
   }
 
   StyleResolverState state(document(), &parent, parentStyle);
   if (!pseudoStyleForElementInternal(parent, pseudoId, parentStyle, state))
     return nullptr;
   RefPtr<ComputedStyle> style = state.takeStyle();
-  ASSERT(style);
+  DCHECK(style);
   parentStyle->addCachedPseudoStyle(style);
 
   if (!pseudoElementLayoutObjectIsNeeded(style.get()))
     return nullptr;
 
   PseudoElement* pseudo = createPseudoElement(&parent, pseudoId);
 
   setAnimationUpdateIfNeeded(state, *pseudo);
   if (ElementAnimations* elementAnimations = pseudo->elementAnimations())
     elementAnimations->cssAnimations().maybeApplyPendingUpdate(pseudo);
   return pseudo;
 }
 
 bool StyleResolver::pseudoStyleForElementInternal(
     Element& element,
     const PseudoStyleRequest& pseudoStyleRequest,
     const ComputedStyle* parentStyle,
     StyleResolverState& state) {
-  ASSERT(document().frame());
-  ASSERT(document().settings());
-  ASSERT(pseudoStyleRequest.pseudoId != PseudoIdFirstLineInherited);
-  ASSERT(state.parentStyle());
+  DCHECK(document().frame());
+  DCHECK(document().settings());
+  DCHECK(pseudoStyleRequest.pseudoId != PseudoIdFirstLineInherited);
+  DCHECK(state.parentStyle());
 
   SelectorFilterParentScope::ensureParentStackIsPushed();
 
   Element* pseudoElement = element.pseudoElement(pseudoStyleRequest.pseudoId);
 
   ElementAnimations* elementAnimations =
       pseudoElement ? pseudoElement->elementAnimations() : nullptr;
   const ComputedStyle* baseComputedStyle =
       elementAnimations ? elementAnimations->baseComputedStyle() : nullptr;
 
@@ skipping 54 matching lines @@
   if (state.style()->hasViewportUnits())
     document().setHasViewportUnits();
 
   return true;
 }
 
 PassRefPtr<ComputedStyle> StyleResolver::pseudoStyleForElement(
     Element* element,
     const PseudoStyleRequest& pseudoStyleRequest,
     const ComputedStyle* parentStyle) {
-  ASSERT(parentStyle);
+  DCHECK(parentStyle);
   if (!element)
     return nullptr;
 
   StyleResolverState state(document(), element, parentStyle);
   if (!pseudoStyleForElementInternal(*element, pseudoStyleRequest, parentStyle,
                                      state)) {
     if (pseudoStyleRequest.type == PseudoStyleRequest::ForRenderer)
       return nullptr;
     return state.takeStyle();
   }
 
   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());
+  DCHECK(!hasPendingAuthorStyleSheets());
   // 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);
+  DCHECK(rootElementStyle);
   style->inheritFrom(*rootElementStyle);
   state.setStyle(style.release());
 
   PageRuleCollector collector(rootElementStyle, pageIndex);
 
   collector.matchPageRules(
       CSSDefaultStyleSheets::instance().defaultPrintStyle());
 
   if (ScopedStyleResolver* scopedResolver = document().scopedStyleResolver())
     scopedResolver->matchPageRules(collector);
@@ skipping 18 matching lines @@
 
 PassRefPtr<ComputedStyle> StyleResolver::initialStyleForElement() {
   RefPtr<ComputedStyle> style = ComputedStyle::create();
   FontBuilder fontBuilder(document());
   fontBuilder.setInitial(style->effectiveZoom());
   fontBuilder.createFont(document().styleEngine().fontSelector(), *style);
   return style.release();
 }
 
 PassRefPtr<ComputedStyle> StyleResolver::styleForText(Text* textNode) {
-  ASSERT(textNode);
+  DCHECK(textNode);
 
   Node* parentNode = LayoutTreeBuilderTraversal::parent(*textNode);
   if (!parentNode || !parentNode->computedStyle())
     return initialStyleForElement();
   return parentNode->mutableComputedStyle();
 }
 
 void StyleResolver::updateFont(StyleResolverState& state) {
   state.fontBuilder().createFont(document().styleEngine().fontSelector(),
                                  state.mutableStyleRef());
   state.setConversionFontSizes(CSSToLengthConversionData::FontSizes(
       state.style(), state.rootElementStyle()));
   state.setConversionZoom(state.style()->effectiveZoom());
 }
 
 StyleRuleList* StyleResolver::styleRulesForElement(Element* element,
                                                    unsigned rulesToInclude) {
-  ASSERT(element);
+  DCHECK(element);
   StyleResolverState state(document(), element);
   ElementRuleCollector collector(state.elementContext(), m_selectorFilter,
                                  state.style());
   collector.setMode(SelectorChecker::CollectingStyleRules);
   collectPseudoRulesForElement(*element, collector, PseudoIdNone,
                                rulesToInclude);
   return collector.matchedStyleRuleList();
 }
 
 CSSRuleList* StyleResolver::pseudoCSSRulesForElement(Element* element,
                                                      PseudoId pseudoId,
                                                      unsigned rulesToInclude) {
-  ASSERT(element);
+  DCHECK(element);
   StyleResolverState state(document(), element);
   ElementRuleCollector collector(state.elementContext(), m_selectorFilter,
                                  state.style());
   collector.setMode(SelectorChecker::CollectingCSSRules);
   collectPseudoRulesForElement(*element, collector, pseudoId, rulesToInclude);
   return collector.matchedCSSRuleList();
 }
 
 CSSRuleList* StyleResolver::cssRulesForElement(Element* element,
                                                unsigned rulesToInclude) {
@@ skipping 13 matching lines @@
   if (rulesToInclude & AuthorCSSRules) {
     collector.setSameOriginOnly(!(rulesToInclude & CrossOriginCSSRules));
     collector.setIncludeEmptyRules(rulesToInclude & EmptyCSSRules);
     matchAuthorRules(element, collector);
   }
 }
 
 bool StyleResolver::applyAnimatedProperties(StyleResolverState& state,
                                             const Element* animatingElement) {
   Element* element = state.element();
-  ASSERT(element);
+  DCHECK(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 ||
+  DCHECK(animatingElement == element || !animatingElement ||
          animatingElement->parentOrShadowHostElement() == element);
 
   if (!(animatingElement && animatingElement->hasAnimations()) &&
       !state.style()->transitions() && !state.style()->animations())
     return false;
 
   CSSAnimations::calculateUpdate(animatingElement, *element, *state.style(),
                                  state.parentStyle(), state.animationUpdate(),
                                  this);
 
   CSSAnimations::snapshotCompositorKeyframes(
       *element, state.animationUpdate(), *state.style(), state.parentStyle());
 
   if (state.animationUpdate().isEmpty())
     return false;
 
   if (state.style()->insideLink() != NotInsideLink) {
-    ASSERT(state.applyPropertyToRegularStyle());
+    DCHECK(state.applyPropertyToRegularStyle());
     state.setApplyPropertyToVisitedLinkStyle(true);
   }
 
   const ActiveInterpolationsMap& activeInterpolationsMapForAnimations =
       state.animationUpdate().activeInterpolationsForAnimations();
   const ActiveInterpolationsMap& activeInterpolationsMapForTransitions =
       state.animationUpdate().activeInterpolationsForTransitions();
   // TODO(crbug.com/644148): Apply animations on custom properties.
   applyAnimatedProperties<HighPropertyPriority>(
       state, activeInterpolationsMapForAnimations);
   applyAnimatedProperties<HighPropertyPriority>(
       state, activeInterpolationsMapForTransitions);
 
   updateFont(state);
 
   applyAnimatedProperties<LowPropertyPriority>(
       state, activeInterpolationsMapForAnimations);
   applyAnimatedProperties<LowPropertyPriority>(
       state, activeInterpolationsMapForTransitions);
 
   // Start loading resources used by animations.
   loadPendingResources(state);
 
-  ASSERT(!state.fontBuilder().fontDirty());
+  DCHECK(!state.fontBuilder().fontDirty());
 
   state.setApplyPropertyToVisitedLinkStyle(false);
 
   return true;
 }
 
 StyleRuleKeyframes* StyleResolver::findKeyframesRule(
     const Element* element,
     const AtomicString& animationName) {
   HeapVector<Member<ScopedStyleResolver>, 8> resolvers;
@@ skipping 177 matching lines @@
     case CSSPropertyWebkitMarginBefore:
     case CSSPropertyWebkitMarginBeforeCollapse:
     case CSSPropertyWebkitMarginBottomCollapse:
     case CSSPropertyWebkitMarginCollapse:
     case CSSPropertyWebkitMarginEnd:
     case CSSPropertyWebkitMarginStart:
     case CSSPropertyWebkitMarginTopCollapse:
     case CSSPropertyWordSpacing:
       return true;
     case CSSPropertyTextDecoration:
-      ASSERT(!RuntimeEnabledFeatures::css3TextDecorationsEnabled());
+      DCHECK(!RuntimeEnabledFeatures::css3TextDecorationsEnabled());
       return true;
     case CSSPropertyTextDecorationColor:
     case CSSPropertyTextDecorationLine:
     case CSSPropertyTextDecorationStyle:
     case CSSPropertyTextDecorationSkip:
-      ASSERT(RuntimeEnabledFeatures::css3TextDecorationsEnabled());
+      DCHECK(RuntimeEnabledFeatures::css3TextDecorationsEnabled());
       return true;
 
     // text-shadow added in text decoration spec:
     // http://www.w3.org/TR/css-text-decor-3/#text-shadow-property
     case CSSPropertyTextShadow:
     // box-shadox added in CSS3 backgrounds spec:
     // http://www.w3.org/TR/css3-background/#placement
     case CSSPropertyBoxShadow:
     // Properties that we currently support outside of spec.
     case CSSPropertyVisibility:
@@ skipping 28 matching lines @@
   if (propertyWhitelistType == PropertyWhitelistNone)
     return true;  // Early bail for the by far most common case.
 
   if (propertyWhitelistType == PropertyWhitelistFirstLetter)
     return isValidFirstLetterStyleProperty(property);
 
   if (propertyWhitelistType == PropertyWhitelistCue)
     return isValidCueStyleProperty(property) &&
            !shouldIgnoreTextTrackAuthorStyle(document);
 
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return true;
 }
 
 // This method expands the 'all' shorthand property to longhand properties
 // and applies the expanded longhand properties.
 template <CSSPropertyPriority priority>
 void StyleResolver::applyAllProperty(
     StyleResolverState& state,
     const CSSValue& allValue,
     bool inheritedOnly,
@@ skipping 143 matching lines @@
   m_matchedPropertiesCache.clear();
 }
 
 void StyleResolver::notifyResizeForViewportUnits() {
   m_matchedPropertiesCache.clearViewportDependent();
 }
 
 void StyleResolver::applyMatchedProperties(StyleResolverState& state,
                                            const MatchResult& matchResult) {
   const Element* element = state.element();
-  ASSERT(element);
+  DCHECK(element);
 
   INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), matchedPropertyApply,
                                 1);
 
   unsigned cacheHash =
       RuntimeEnabledFeatures::styleMatchedPropertiesCacheEnabled() &&
               matchResult.isCacheable()
           ? computeMatchedPropertiesHash(matchResult.matchedProperties().data(),
                                          matchResult.matchedProperties().size())
           : 0;
@@ skipping 130 matching lines @@
     // 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());
+    DCHECK(RuntimeEnabledFeatures::styleMatchedPropertiesCacheEnabled());
     INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(),
                                   matchedPropertyCacheAdded, 1);
     m_matchedPropertiesCache.add(*state.style(), *state.parentStyle(),
                                  cacheHash, matchResult.matchedProperties());
   }
 
-  ASSERT(!state.fontBuilder().fontDirty());
+  DCHECK(!state.fontBuilder().fontDirty());
 }
 
 bool StyleResolver::hasAuthorBackground(const StyleResolverState& state) {
   const CachedUAStyle* cachedUAStyle = state.cachedUAStyle();
   if (!cachedUAStyle)
     return false;
 
   FillLayer oldFill = cachedUAStyle->backgroundLayers;
   FillLayer newFill = state.style()->backgroundLayers();
   // Exclude background-repeat from comparison by resetting it.
   oldFill.setRepeatX(NoRepeatFill);
   oldFill.setRepeatY(NoRepeatFill);
   newFill.setRepeatX(NoRepeatFill);
   newFill.setRepeatY(NoRepeatFill);
 
   return (oldFill != newFill ||
           cachedUAStyle->backgroundColor != state.style()->backgroundColor());
 }
 
 bool StyleResolver::hasAuthorBorder(const StyleResolverState& state) {
   const CachedUAStyle* cachedUAStyle = state.cachedUAStyle();
   return cachedUAStyle && (cachedUAStyle->border != state.style()->border());
 }
 
 void StyleResolver::applyCallbackSelectors(StyleResolverState& state) {
-  if (!m_watchedSelectorsRules)
+  RuleSet* watchedSelectorsRuleSet =
+      document().styleEngine().watchedSelectorsRuleSet();
+  if (!watchedSelectorsRuleSet)
     return;
 
   ElementRuleCollector collector(state.elementContext(), m_selectorFilter,
                                  state.style());
   collector.setMode(SelectorChecker::CollectingStyleRules);
   collector.setIncludeEmptyRules(true);
 
-  MatchRequest matchRequest(m_watchedSelectorsRules.get());
+  MatchRequest matchRequest(watchedSelectorsRuleSet);
   collector.collectMatchingRules(matchRequest);
   collector.sortAndTransferMatchedRules();
 
   StyleRuleList* rules = collector.matchedStyleRuleList();
   if (!rules)
     return;
   for (size_t i = 0; i < rules->size(); i++)
     state.style()->addCallbackSelector(
         rules->at(i)->selectorList().selectorsText());
 }
@@ skipping 47 matching lines @@
   }
   return false;
 }
 
 DEFINE_TRACE(StyleResolver) {
   visitor->trace(m_matchedPropertiesCache);
   visitor->trace(m_medium);
   visitor->trace(m_viewportDependentMediaQueryResults);
   visitor->trace(m_deviceDependentMediaQueryResults);
   visitor->trace(m_selectorFilter);
-  visitor->trace(m_features);
-  visitor->trace(m_siblingRuleSet);
-  visitor->trace(m_uncommonAttributeRuleSet);
-  visitor->trace(m_watchedSelectorsRules);
   visitor->trace(m_styleSharingLists);
   visitor->trace(m_pendingStyleSheets);
   visitor->trace(m_document);
 }
 
 }  // namespace blink