#include "config.h"
#include "RuleFeature.h"
#include "CSSSelector.h"
#include "CSSSelectorList.h"
#include "RuleSet.h"
namespace WebCore {
void RuleFeatureSet::recursivelyCollectFeaturesFromSelector(SelectorFeatures& selectorFeatures, const CSSSelector& firstSelector, bool matchesAncestor)
{
const CSSSelector* selector = &firstSelector;
do {
if (selector->match() == CSSSelector::Id) {
idsInRules.add(selector->value().impl());
if (matchesAncestor)
idsMatchingAncestorsInRules.add(selector->value().impl());
} else if (selector->match() == CSSSelector::Class) {
classesInRules.add(selector->value().impl());
if (matchesAncestor)
selectorFeatures.classesMatchingAncestors.append(selector->value().impl());
} else if (selector->isAttributeSelector()) {
auto* canonicalLocalName = selector->attributeCanonicalLocalName().impl();
auto* localName = selector->attribute().localName().impl();
attributeCanonicalLocalNamesInRules.add(canonicalLocalName);
attributeLocalNamesInRules.add(localName);
if (matchesAncestor)
selectorFeatures.attributeSelectorsMatchingAncestors.append(selector);
} else if (selector->match() == CSSSelector::PseudoElement) {
switch (selector->pseudoElementType()) {
case CSSSelector::PseudoElementFirstLine:
usesFirstLineRules = true;
break;
case CSSSelector::PseudoElementFirstLetter:
usesFirstLetterRules = true;
break;
default:
break;
}
}
if (!selectorFeatures.hasSiblingSelector && selector->isSiblingSelector())
selectorFeatures.hasSiblingSelector = true;
if (const CSSSelectorList* selectorList = selector->selectorList()) {
for (const CSSSelector* subSelector = selectorList->first(); subSelector; subSelector = CSSSelectorList::next(subSelector)) {
if (!selectorFeatures.hasSiblingSelector && selector->isSiblingSelector())
selectorFeatures.hasSiblingSelector = true;
recursivelyCollectFeaturesFromSelector(selectorFeatures, *subSelector, matchesAncestor);
}
}
if (selector->hasDescendantOrChildRelation())
matchesAncestor = true;
selector = selector->tagHistory();
} while (selector);
}
static RuleFeatureSet::AttributeRules::SelectorKey makeAttributeSelectorKey(const CSSSelector& selector)
{
bool caseInsensitive = selector.attributeValueMatchingIsCaseInsensitive();
unsigned matchAndCase = static_cast<unsigned>(selector.match()) << 1 | (caseInsensitive ? 1 : 0);
return std::make_pair(selector.attributeCanonicalLocalName().impl(), std::make_pair(selector.value().impl(), matchAndCase));
}
void RuleFeatureSet::collectFeatures(const RuleData& ruleData)
{
SelectorFeatures selectorFeatures;
recursivelyCollectFeaturesFromSelector(selectorFeatures, *ruleData.selector());
if (selectorFeatures.hasSiblingSelector)
siblingRules.append(RuleFeature(ruleData.rule(), ruleData.selectorIndex(), ruleData.hasDocumentSecurityOrigin()));
if (ruleData.containsUncommonAttributeSelector())
uncommonAttributeRules.append(RuleFeature(ruleData.rule(), ruleData.selectorIndex(), ruleData.hasDocumentSecurityOrigin()));
for (auto* className : selectorFeatures.classesMatchingAncestors) {
auto addResult = ancestorClassRules.ensure(className, [] {
return std::make_unique<Vector<RuleFeature>>();
});
addResult.iterator->value->append(RuleFeature(ruleData.rule(), ruleData.selectorIndex(), ruleData.hasDocumentSecurityOrigin()));
}
for (auto* selector : selectorFeatures.attributeSelectorsMatchingAncestors) {
auto addResult = ancestorAttributeRulesForHTML.ensure(selector->attributeCanonicalLocalName().impl(), [] {
return std::make_unique<AttributeRules>();
});
auto& rules = *addResult.iterator->value;
rules.features.append(RuleFeature(ruleData.rule(), ruleData.selectorIndex(), ruleData.hasDocumentSecurityOrigin()));
rules.selectors.add(makeAttributeSelectorKey(*selector), selector);
}
}
void RuleFeatureSet::add(const RuleFeatureSet& other)
{
idsInRules.add(other.idsInRules.begin(), other.idsInRules.end());
idsMatchingAncestorsInRules.add(other.idsMatchingAncestorsInRules.begin(), other.idsMatchingAncestorsInRules.end());
classesInRules.add(other.classesInRules.begin(), other.classesInRules.end());
attributeCanonicalLocalNamesInRules.add(other.attributeCanonicalLocalNamesInRules.begin(), other.attributeCanonicalLocalNamesInRules.end());
attributeLocalNamesInRules.add(other.attributeLocalNamesInRules.begin(), other.attributeLocalNamesInRules.end());
siblingRules.appendVector(other.siblingRules);
uncommonAttributeRules.appendVector(other.uncommonAttributeRules);
for (auto& keyValuePair : other.ancestorClassRules) {
auto addResult = ancestorClassRules.ensure(keyValuePair.key, [] {
return std::make_unique<Vector<RuleFeature>>();
});
addResult.iterator->value->appendVector(*keyValuePair.value);
}
for (auto& keyValuePair : other.ancestorAttributeRulesForHTML) {
auto addResult = ancestorAttributeRulesForHTML.ensure(keyValuePair.key, [] {
return std::make_unique<AttributeRules>();
});
auto& rules = *addResult.iterator->value;
rules.features.appendVector(keyValuePair.value->features);
for (auto& selectorPair : keyValuePair.value->selectors)
rules.selectors.add(selectorPair.key, selectorPair.value);
}
usesFirstLineRules = usesFirstLineRules || other.usesFirstLineRules;
usesFirstLetterRules = usesFirstLetterRules || other.usesFirstLetterRules;
}
void RuleFeatureSet::clear()
{
idsInRules.clear();
idsMatchingAncestorsInRules.clear();
classesInRules.clear();
attributeCanonicalLocalNamesInRules.clear();
attributeLocalNamesInRules.clear();
siblingRules.clear();
uncommonAttributeRules.clear();
ancestorClassRules.clear();
ancestorAttributeRulesForHTML.clear();
usesFirstLineRules = false;
usesFirstLetterRules = false;
}
void RuleFeatureSet::shrinkToFit()
{
siblingRules.shrinkToFit();
uncommonAttributeRules.shrinkToFit();
for (auto& rules : ancestorClassRules.values())
rules->shrinkToFit();
for (auto& rules : ancestorAttributeRulesForHTML.values())
rules->features.shrinkToFit();
}
}