bool Element::classChangeNeedsStyleRecalc(const SpaceSplitString& oldClasses, const SpaceSplitString& newClasses) { // Class vectors tend to be very short. This is faster than using a hash table. BitVector remainingClassBits; remainingClassBits.ensureSize(oldClasses.size()); for (unsigned i = 0; i < newClasses.size(); ++i) { bool found = false; for (unsigned j = 0; j < oldClasses.size(); ++j) { if (newClasses[i] == oldClasses[j]) { // Mark each class that is still in the newClasses so we can skip doing // an n^2 search below when looking for removals. We can't break from // this loop early since a class can appear more than once. remainingClassBits.quickSet(j); found = true; } } // Class was added. if (!found && affectedByClassSelector(newClasses[i])) return true; } for (unsigned i = 0; i < oldClasses.size(); ++i) { if (remainingClassBits.quickGet(i)) continue; // Class was removed. if (affectedByClassSelector(oldClasses[i])) return true; } return false; }
void RuleFeatureSet::scheduleStyleInvalidationForClassChange(const SpaceSplitString& oldClasses, const SpaceSplitString& newClasses, Element& element) { if (!oldClasses.size()) scheduleStyleInvalidationForClassChange(newClasses, element); // Class vectors tend to be very short. This is faster than using a hash table. BitVector remainingClassBits; remainingClassBits.ensureSize(oldClasses.size()); for (unsigned i = 0; i < newClasses.size(); ++i) { bool found = false; for (unsigned j = 0; j < oldClasses.size(); ++j) { if (newClasses[i] == oldClasses[j]) { // Mark each class that is still in the newClasses so we can skip doing // an n^2 search below when looking for removals. We can't break from // this loop early since a class can appear more than once. remainingClassBits.quickSet(j); found = true; } } // Class was added. if (!found) addClassToInvalidationSet(newClasses[i], element); } for (unsigned i = 0; i < oldClasses.size(); ++i) { if (remainingClassBits.quickGet(i)) continue; // Class was removed. addClassToInvalidationSet(oldClasses[i], element); } }
void RuleFeatureSet::scheduleStyleInvalidationForClassChange(const SpaceSplitString& changedClasses, Element& element) { unsigned changedSize = changedClasses.size(); for (unsigned i = 0; i < changedSize; ++i) { addClassToInvalidationSet(changedClasses[i], element); } }
void GraphicsContextAnnotator::annotate(const PaintInfo& paintInfo, const LayoutObject* object) { ASSERT(!m_context); ASSERT(paintInfo.context); ASSERT(object); AnnotationList annotations; AnnotationModeFlags mode = paintInfo.context->annotationMode(); Element* element = object->node() && object->node()->isElementNode() ? toElement(object->node()) : 0; if (mode & AnnotateLayoutObjectName) annotations.append(std::make_pair(AnnotationKeyLayoutObjectName, object->decoratedName())); if (mode & AnnotatePaintPhase) annotations.append(std::make_pair(AnnotationKeyPaintPhase, paintPhaseName(paintInfo.phase))); if ((mode & AnnotateElementId) && element && element->hasID()) annotations.append(std::make_pair(AnnotationKeyElementId, element->getIdAttribute().string())); if ((mode & AnnotateElementClass) && element && element->hasClass()) { SpaceSplitString classes = element->classNames(); if (!classes.isNull() && classes.size() > 0) { StringBuilder classBuilder; for (size_t i = 0; i < classes.size(); ++i) { if (i > 0) classBuilder.append(' '); classBuilder.append(classes[i]); } annotations.append(std::make_pair(AnnotationKeyElementClass, classBuilder.toString())); } } if ((mode & AnnotateElementTag) && element) annotations.append(std::make_pair(AnnotationKeyElementTag, element->tagName())); if (mode & AnnotateInspectorId) { if (Node* ownerNode = object->generatingNode()) { annotations.append(std::make_pair(AnnotationKeyInspectorNodeId, String::number(DOMNodeIds::idForNode(ownerNode)))); } } m_context = paintInfo.context; m_context->beginAnnotation(annotations); }
bool SharedStyleFinder::classNamesAffectedByRules(const SpaceSplitString& classNames) const { unsigned count = classNames.size(); for (unsigned i = 0; i < count; ++i) { if (m_features.hasSelectorForClass(classNames[i])) return true; } return false; }
bool SelectRuleFeatureSet::checkSelectorsForClassChange( const SpaceSplitString& changedClasses) const { unsigned changedSize = changedClasses.size(); for (unsigned i = 0; i < changedSize; ++i) { if (hasSelectorForClass(changedClasses[i])) return true; } return false; }
void StyleEngine::classChangedForElement(const SpaceSplitString& changedClasses, Element& element) { ASSERT(isMaster()); InvalidationSetVector invalidationSets; unsigned changedSize = changedClasses.size(); RuleFeatureSet& ruleFeatureSet = ensureResolver().ensureUpdatedRuleFeatureSet(); for (unsigned i = 0; i < changedSize; ++i) ruleFeatureSet.collectInvalidationSetsForClass(invalidationSets, element, changedClasses[i]); scheduleInvalidationSetsForElement(invalidationSets, element); }
bool RuleFeatureSet::computeInvalidationSetsForClassChange(const SpaceSplitString& changedClasses, Element* element) { unsigned changedSize = changedClasses.size(); for (unsigned i = 0; i < changedSize; ++i) { if (classInvalidationRequiresSubtreeRecalc(changedClasses[i])) return true; addClassToInvalidationSet(changedClasses[i], element); } return false; }
void StyleEngine::classChangedForElement(const SpaceSplitString& oldClasses, const SpaceSplitString& newClasses, Element& element) { ASSERT(isMaster()); InvalidationSetVector invalidationSets; if (!oldClasses.size()) { classChangedForElement(newClasses, element); return; } // Class vectors tend to be very short. This is faster than using a hash table. BitVector remainingClassBits; remainingClassBits.ensureSize(oldClasses.size()); RuleFeatureSet& ruleFeatureSet = ensureResolver().ensureUpdatedRuleFeatureSet(); for (unsigned i = 0; i < newClasses.size(); ++i) { bool found = false; for (unsigned j = 0; j < oldClasses.size(); ++j) { if (newClasses[i] == oldClasses[j]) { // Mark each class that is still in the newClasses so we can skip doing // an n^2 search below when looking for removals. We can't break from // this loop early since a class can appear more than once. remainingClassBits.quickSet(j); found = true; } } // Class was added. if (!found) ruleFeatureSet.collectInvalidationSetsForClass(invalidationSets, element, newClasses[i]); } for (unsigned i = 0; i < oldClasses.size(); ++i) { if (remainingClassBits.quickGet(i)) continue; // Class was removed. ruleFeatureSet.collectInvalidationSetsForClass(invalidationSets, element, oldClasses[i]); } scheduleInvalidationSetsForElement(invalidationSets, element); }
SandboxFlags parseSandboxPolicy(const SpaceSplitString& policy, String& invalidTokensErrorMessage) { // http://www.w3.org/TR/html5/the-iframe-element.html#attr-iframe-sandbox // Parse the unordered set of unique space-separated tokens. SandboxFlags flags = SandboxAll; unsigned length = policy.size(); unsigned numberOfTokenErrors = 0; StringBuilder tokenErrors; for (unsigned index = 0; index < length; index++) { // Turn off the corresponding sandbox flag if it's set as "allowed". String sandboxToken(policy[index]); if (equalIgnoringCase(sandboxToken, "allow-same-origin")) { flags &= ~SandboxOrigin; } else if (equalIgnoringCase(sandboxToken, "allow-forms")) { flags &= ~SandboxForms; } else if (equalIgnoringCase(sandboxToken, "allow-scripts")) { flags &= ~SandboxScripts; flags &= ~SandboxAutomaticFeatures; } else if (equalIgnoringCase(sandboxToken, "allow-top-navigation")) { flags &= ~SandboxTopNavigation; } else if (equalIgnoringCase(sandboxToken, "allow-popups")) { flags &= ~SandboxPopups; } else if (equalIgnoringCase(sandboxToken, "allow-pointer-lock")) { flags &= ~SandboxPointerLock; } else if (equalIgnoringCase(sandboxToken, "allow-orientation-lock")) { flags &= ~SandboxOrientationLock; } else if (equalIgnoringCase(sandboxToken, "allow-popups-to-escape-sandbox") && RuntimeEnabledFeatures::unsandboxedAuxiliaryEnabled()) { flags &= ~SandboxPropagatesToAuxiliaryBrowsingContexts; } else if (equalIgnoringCase(sandboxToken, "allow-modals") && RuntimeEnabledFeatures::sandboxBlocksModalsEnabled()) { flags &= ~SandboxModals; } else { if (numberOfTokenErrors) tokenErrors.appendLiteral(", '"); else tokenErrors.append('\''); tokenErrors.append(sandboxToken); tokenErrors.append('\''); numberOfTokenErrors++; } } if (numberOfTokenErrors) { if (numberOfTokenErrors > 1) tokenErrors.appendLiteral(" are invalid sandbox flags."); else tokenErrors.appendLiteral(" is an invalid sandbox flag."); invalidTokensErrorMessage = tokenErrors.toString(); } return flags; }