SelectorFilter.cpp [plain text]
#include "config.h"
#include "SelectorFilter.h"
#include "CSSSelector.h"
#include "ShadowRoot.h"
#include "StyledElement.h"
namespace WebCore {
enum { TagNameSalt = 13, IdAttributeSalt = 17, ClassAttributeSalt = 19 };
static inline void collectElementIdentifierHashes(const Element* element, Vector<unsigned, 4>& identifierHashes)
{
AtomicString tagLowercaseLocalName = element->localName().convertToASCIILowercase();
identifierHashes.append(tagLowercaseLocalName.impl()->existingHash() * TagNameSalt);
auto& id = element->idForStyleResolution();
if (!id.isNull())
identifierHashes.append(id.impl()->existingHash() * IdAttributeSalt);
const StyledElement* styledElement = element->isStyledElement() ? static_cast<const StyledElement*>(element) : 0;
if (styledElement && styledElement->hasClass()) {
const SpaceSplitString& classNames = styledElement->classNames();
size_t count = classNames.size();
for (size_t i = 0; i < count; ++i)
identifierHashes.append(classNames[i].impl()->existingHash() * ClassAttributeSalt);
}
}
bool SelectorFilter::parentStackIsConsistent(const ContainerNode* parentNode) const
{
if (!parentNode || is<Document>(parentNode) || is<ShadowRoot>(parentNode))
return m_parentStack.isEmpty();
return !m_parentStack.isEmpty() && m_parentStack.last().element == parentNode;
}
void SelectorFilter::pushParentStackFrame(Element* parent)
{
ASSERT(m_parentStack.isEmpty() || m_parentStack.last().element == parent->parentElement());
ASSERT(!m_parentStack.isEmpty() || !parent->parentElement());
m_parentStack.append(ParentStackFrame(parent));
ParentStackFrame& parentFrame = m_parentStack.last();
collectElementIdentifierHashes(parent, parentFrame.identifierHashes);
size_t count = parentFrame.identifierHashes.size();
for (size_t i = 0; i < count; ++i)
m_ancestorIdentifierFilter.add(parentFrame.identifierHashes[i]);
}
void SelectorFilter::popParentStackFrame()
{
ASSERT(!m_parentStack.isEmpty());
const ParentStackFrame& parentFrame = m_parentStack.last();
size_t count = parentFrame.identifierHashes.size();
for (size_t i = 0; i < count; ++i)
m_ancestorIdentifierFilter.remove(parentFrame.identifierHashes[i]);
m_parentStack.removeLast();
if (m_parentStack.isEmpty()) {
ASSERT(m_ancestorIdentifierFilter.likelyEmpty());
m_ancestorIdentifierFilter.clear();
}
}
void SelectorFilter::pushParent(Element* parent)
{
pushParentStackFrame(parent);
}
struct CollectedSelectorHashes {
using HashVector = Vector<unsigned, 8>;
HashVector ids;
HashVector classes;
HashVector tags;
};
static inline void collectSimpleSelectorHash(CollectedSelectorHashes& collectedHashes, const CSSSelector& selector)
{
switch (selector.match()) {
case CSSSelector::Id:
if (!selector.value().isEmpty())
collectedHashes.ids.append(selector.value().impl()->existingHash() * IdAttributeSalt);
break;
case CSSSelector::Class:
if (!selector.value().isEmpty())
collectedHashes.classes.append(selector.value().impl()->existingHash() * ClassAttributeSalt);
break;
case CSSSelector::Tag: {
auto& tagLowercaseLocalName = selector.tagLowercaseLocalName();
if (tagLowercaseLocalName != starAtom())
collectedHashes.tags.append(tagLowercaseLocalName.impl()->existingHash() * TagNameSalt);
break;
}
default:
break;
}
}
static CollectedSelectorHashes collectSelectorHashes(const CSSSelector& rightmostSelector)
{
CollectedSelectorHashes collectedHashes;
auto* selector = &rightmostSelector;
auto relation = selector->relation();
bool skipOverSubselectors = true;
for (selector = selector->tagHistory(); selector; selector = selector->tagHistory()) {
switch (relation) {
case CSSSelector::Subselector:
if (!skipOverSubselectors)
collectSimpleSelectorHash(collectedHashes, *selector);
break;
case CSSSelector::DirectAdjacent:
case CSSSelector::IndirectAdjacent:
case CSSSelector::ShadowDescendant:
skipOverSubselectors = true;
break;
case CSSSelector::DescendantSpace:
case CSSSelector::Child:
skipOverSubselectors = false;
collectSimpleSelectorHash(collectedHashes, *selector);
break;
}
relation = selector->relation();
}
return collectedHashes;
}
static SelectorFilter::Hashes chooseSelectorHashesForFilter(const CollectedSelectorHashes& collectedSelectorHashes)
{
SelectorFilter::Hashes resultHashes;
unsigned index = 0;
auto addIfNew = [&] (unsigned hash) {
for (unsigned i = 0; i < index; ++i) {
if (resultHashes[i] == hash)
return;
}
resultHashes[index++] = hash;
};
auto copyHashes = [&] (auto& hashes) {
for (auto& hash : hashes) {
addIfNew(hash);
if (index == resultHashes.size())
return true;
}
return false;
};
if (copyHashes(collectedSelectorHashes.ids))
return resultHashes;
if (copyHashes(collectedSelectorHashes.classes))
return resultHashes;
if (copyHashes(collectedSelectorHashes.tags))
return resultHashes;
resultHashes[index] = 0;
return resultHashes;
}
SelectorFilter::Hashes SelectorFilter::collectHashes(const CSSSelector& selector)
{
auto hashes = collectSelectorHashes(selector);
return chooseSelectorHashesForFilter(hashes);
}
}