Use template parameter to reduce branching in style resolve apply passes

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 1003 matching lines @@
   collector.matchPageRules(
       CSSDefaultStyleSheets::instance().defaultPrintStyle());
 
   if (ScopedStyleResolver* scopedResolver = document().scopedStyleResolver())
     scopedResolver->matchPageRules(collector);
 
   bool inheritedOnly = false;
 
   NeedsApplyPass needsApplyPass;
   const MatchResult& result = collector.matchedResult();
-  applyMatchedProperties<HighPropertyPriority>(state, result.allRules(), false,
-                                               inheritedOnly, needsApplyPass);
+  applyMatchedProperties<HighPropertyPriority, UpdateNeedsApplyPass>(
+      state, result.allRules(), false, inheritedOnly, needsApplyPass);
 
   // If our font got dirtied, go ahead and update it now.
   updateFont(state);
 
-  applyMatchedProperties<LowPropertyPriority>(state, result.allRules(), false,
-                                              inheritedOnly, needsApplyPass);
+  applyMatchedProperties<LowPropertyPriority, CheckNeedsApplyPass>(
+      state, result.allRules(), false, inheritedOnly, needsApplyPass);
 
   loadPendingResources(state);
 
   // Now return the style.
   return state.takeStyle();
 }
 
 PassRefPtr<ComputedStyle> StyleResolver::initialStyleForElement() {
   RefPtr<ComputedStyle> style = ComputedStyle::create();
   FontBuilder fontBuilder(document());
@@ skipping 417 matching lines @@
 
     // When hitting matched properties' cache, only inherited properties will be
     // applied.
     if (inheritedOnly && !CSSPropertyMetadata::isInheritedProperty(propertyId))
       continue;
 
     StyleBuilder::applyProperty(propertyId, state, allValue);
   }
 }
 
-template <CSSPropertyPriority priority>
+template <CSSPropertyPriority priority,
+          StyleResolver::ShouldUpdateNeedsApplyPass shouldUpdateNeedsApplyPass>
 void StyleResolver::applyPropertiesForApplyAtRule(
     StyleResolverState& state,
     const CSSValue& value,
     bool isImportant,
     NeedsApplyPass& needsApplyPass,
     PropertyWhitelistType propertyWhitelistType) {
   state.style()->setHasVariableReferenceFromNonInheritedProperty();
   if (!state.style()->inheritedVariables())
     return;
   const String& name = toCSSCustomIdentValue(value).value();
   const StylePropertySet* propertySet =
       state.customPropertySetForApplyAtRule(name);
   bool inheritedOnly = false;
   if (propertySet) {
-    applyProperties<priority>(state, propertySet, isImportant, inheritedOnly,
-                              needsApplyPass, propertyWhitelistType);
+    applyProperties<priority, shouldUpdateNeedsApplyPass>(
+        state, propertySet, isImportant, inheritedOnly, needsApplyPass,
+        propertyWhitelistType);
   }
 }
 
-template <CSSPropertyPriority priority>
+template <CSSPropertyPriority priority,
+          StyleResolver::ShouldUpdateNeedsApplyPass shouldUpdateNeedsApplyPass>
 void StyleResolver::applyProperties(
     StyleResolverState& state,
     const StylePropertySet* properties,
     bool isImportant,
     bool inheritedOnly,
     NeedsApplyPass& needsApplyPass,
     PropertyWhitelistType propertyWhitelistType) {
   unsigned propertyCount = properties->propertyCount();
   for (unsigned i = 0; i < propertyCount; ++i) {
     StylePropertySet::PropertyReference current = properties->propertyAt(i);
     CSSPropertyID property = current.id();
 
     if (property == CSSPropertyApplyAtRule) {
       DCHECK(!inheritedOnly);
-      applyPropertiesForApplyAtRule<priority>(state, current.value(),
-                                              isImportant, needsApplyPass,
-                                              propertyWhitelistType);
+      applyPropertiesForApplyAtRule<priority, shouldUpdateNeedsApplyPass>(
+          state, current.value(), isImportant, needsApplyPass,
+          propertyWhitelistType);
       continue;
     }
 
     if (property == CSSPropertyAll && isImportant == current.isImportant()) {
-      if (needsApplyPass.needsUpdate()) {
+      if (shouldUpdateNeedsApplyPass) {
         needsApplyPass.set(HighPropertyPriority, isImportant);
         needsApplyPass.set(LowPropertyPriority, isImportant);
       }
       applyAllProperty<priority>(state, current.value(), inheritedOnly,
                                  propertyWhitelistType);
       continue;
     }
 
-    if (needsApplyPass.needsUpdate())
+    if (shouldUpdateNeedsApplyPass)
       needsApplyPass.set(priorityForProperty(property), current.isImportant());
 
     if (isImportant != current.isImportant())
       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.
       DCHECK(!current.value().isInheritedValue());
       continue;
     }
 
     if (!CSSPropertyPriorityData<priority>::propertyHasPriority(property))
       continue;
 
     StyleBuilder::applyProperty(current.id(), state, current.value());
   }
 }
 
-template <CSSPropertyPriority priority>
+template <CSSPropertyPriority priority,
+          StyleResolver::ShouldUpdateNeedsApplyPass shouldUpdateNeedsApplyPass>
 void StyleResolver::applyMatchedProperties(StyleResolverState& state,
                                            const MatchedPropertiesRange& range,
                                            bool isImportant,
                                            bool inheritedOnly,
                                            NeedsApplyPass& needsApplyPass) {
   if (range.isEmpty())
     return;
 
-  if (!needsApplyPass.needsUpdate() &&
-      !needsApplyPass.get(priority, isImportant))
+  if (!shouldUpdateNeedsApplyPass && !needsApplyPass.get(priority, isImportant))
     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.
       state.setApplyPropertyToRegularStyle(linkMatchType &
                                            CSSSelector::MatchLink);
       state.setApplyPropertyToVisitedLinkStyle(linkMatchType &
                                                CSSSelector::MatchVisited);
 
-      applyProperties<priority>(state, matchedProperties.properties.get(),
-                                isImportant, inheritedOnly, needsApplyPass,
-                                static_cast<PropertyWhitelistType>(
-                                    matchedProperties.m_types.whitelistType));
+      applyProperties<priority, shouldUpdateNeedsApplyPass>(
+          state, matchedProperties.properties.get(), isImportant, inheritedOnly,
+          needsApplyPass, static_cast<PropertyWhitelistType>(
+                              matchedProperties.m_types.whitelistType));
     }
     state.setApplyPropertyToRegularStyle(true);
     state.setApplyPropertyToVisitedLinkStyle(false);
     return;
   }
   for (const auto& matchedProperties : range) {
-    applyProperties<priority>(state, matchedProperties.properties.get(),
-                              isImportant, inheritedOnly, needsApplyPass,
-                              static_cast<PropertyWhitelistType>(
-                                  matchedProperties.m_types.whitelistType));
+    applyProperties<priority, shouldUpdateNeedsApplyPass>(
+        state, matchedProperties.properties.get(), isImportant, inheritedOnly,
+        needsApplyPass, static_cast<PropertyWhitelistType>(
+                            matchedProperties.m_types.whitelistType));
   }
 }
 
 static unsigned computeMatchedPropertiesHash(
     const MatchedProperties* properties,
     unsigned size) {
   return StringHasher::hashMemory(properties, sizeof(MatchedProperties) * size);
 }
 
 void StyleResolver::invalidateMatchedPropertiesCache() {
@@ skipping 57 matching lines @@
 
       return;
     }
     applyInheritedOnly = true;
   }
 
   NeedsApplyPass needsApplyPass;
 
   // TODO(leviw): We need the proper bit for tracking whether we need to do this
   // work.
-  applyMatchedProperties<ResolveVariables>(state, matchResult.authorRules(),
-                                           false, applyInheritedOnly,
-                                           needsApplyPass);
-  applyMatchedProperties<ResolveVariables>(state, matchResult.authorRules(),
-                                           true, applyInheritedOnly,
-                                           needsApplyPass);
+  applyMatchedProperties<ResolveVariables, UpdateNeedsApplyPass>(
+      state, matchResult.authorRules(), false, applyInheritedOnly,
+      needsApplyPass);
+  applyMatchedProperties<ResolveVariables, CheckNeedsApplyPass>(
+      state, matchResult.authorRules(), true, applyInheritedOnly,
+      needsApplyPass);
   // TODO(leviw): stop recalculating every time
   CSSVariableResolver::resolveVariableDefinitions(state);
 
   if (RuntimeEnabledFeatures::cssApplyAtRulesEnabled()) {
     if (cacheCustomPropertiesForApplyAtRules(state,
                                              matchResult.authorRules())) {
-      needsApplyPass.setNeedsUpdate(true);
-      applyMatchedProperties<ResolveVariables>(state, matchResult.authorRules(),
-                                               false, applyInheritedOnly,
-                                               needsApplyPass);
-      applyMatchedProperties<ResolveVariables>(state, matchResult.authorRules(),
-                                               true, applyInheritedOnly,
-                                               needsApplyPass);
+      applyMatchedProperties<ResolveVariables, UpdateNeedsApplyPass>(
+          state, matchResult.authorRules(), false, applyInheritedOnly,
+          needsApplyPass);
+      applyMatchedProperties<ResolveVariables, CheckNeedsApplyPass>(
+          state, matchResult.authorRules(), true, applyInheritedOnly,
+          needsApplyPass);
       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.
-  needsApplyPass.setNeedsUpdate(true);
-  applyMatchedProperties<HighPropertyPriority>(
+  applyMatchedProperties<HighPropertyPriority, UpdateNeedsApplyPass>(
       state, matchResult.allRules(), false, applyInheritedOnly, needsApplyPass);
   for (auto range : ImportantAuthorRanges(matchResult)) {
-    applyMatchedProperties<HighPropertyPriority>(
+    applyMatchedProperties<HighPropertyPriority, CheckNeedsApplyPass>(
         state, range, true, applyInheritedOnly, needsApplyPass);
   }
-  applyMatchedProperties<HighPropertyPriority>(
+  applyMatchedProperties<HighPropertyPriority, CheckNeedsApplyPass>(
       state, matchResult.uaRules(), true, applyInheritedOnly, needsApplyPass);
 
   if (UNLIKELY(isSVGForeignObjectElement(element))) {
     // 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
@@ skipping 17 matching lines @@
   // properties.
   if (cachedMatchedProperties &&
       cachedMatchedProperties->computedStyle->getFontDescription() !=
           state.style()->getFontDescription())
     applyInheritedOnly = false;
 
   // Registered custom properties are computed after high priority properties.
   CSSVariableResolver::computeRegisteredVariables(state);
 
   // Now do the normal priority UA properties.
-  applyMatchedProperties<LowPropertyPriority>(
+  applyMatchedProperties<LowPropertyPriority, CheckNeedsApplyPass>(
       state, matchResult.uaRules(), false, applyInheritedOnly, needsApplyPass);
 
   // 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.
-  applyMatchedProperties<LowPropertyPriority>(state, matchResult.authorRules(),
-                                              false, applyInheritedOnly,
-                                              needsApplyPass);
+  applyMatchedProperties<LowPropertyPriority, CheckNeedsApplyPass>(
+      state, matchResult.authorRules(), false, applyInheritedOnly,
+      needsApplyPass);
   for (auto range : ImportantAuthorRanges(matchResult)) {
-    applyMatchedProperties<LowPropertyPriority>(
+    applyMatchedProperties<LowPropertyPriority, CheckNeedsApplyPass>(
         state, range, true, applyInheritedOnly, needsApplyPass);
   }
-  applyMatchedProperties<LowPropertyPriority>(
+  applyMatchedProperties<LowPropertyPriority, CheckNeedsApplyPass>(
       state, matchResult.uaRules(), true, applyInheritedOnly, needsApplyPass);
 
   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
     // would give the wrong answer.
     state.style()->setHasAuthorBackground(hasAuthorBackground(state));
     state.style()->setHasAuthorBorder(hasAuthorBorder(state));
@@ skipping 117 matching lines @@
   visitor->trace(m_viewportDependentMediaQueryResults);
   visitor->trace(m_deviceDependentMediaQueryResults);
   visitor->trace(m_selectorFilter);
   visitor->trace(m_styleSharingLists);
   visitor->trace(m_pendingStyleSheets);
   visitor->trace(m_document);
   visitor->trace(m_tracker);
 }
 
 }  // namespace blink