{

RefPtr spanElement = dynamicDowncast<HTMLSpanElement>(node);

return spanElement && spanElement->attributeWithoutSynchronization(classAttr) == styleSpanClassString();

{

if (!element.hasAttributes())

return true;

unsigned matchedAttributes = 0;

if (element.attributeWithoutSynchronization(classAttr) == styleSpanClassString())

matchedAttributes++;

if (element.hasAttribute(styleAttr) && (shouldStyleAttributeBeEmpty == AllowNonEmptyStyleAttribute

|| !element.inlineStyle() || element.inlineStyle()->isEmpty()))

matchedAttributes++;

ASSERT(matchedAttributes <= element.attributeCount());

return matchedAttributes == element.attributeCount();

{

RefPtr spanElement = dynamicDowncast<HTMLSpanElement>(element);

return spanElement && hasNoAttributeOrOnlyStyleAttribute(*spanElement, AllowNonEmptyStyleAttribute);

{

RefPtr spanElement = dynamicDowncast<HTMLSpanElement>(element);

return spanElement && hasNoAttributeOrOnlyStyleAttribute(*spanElement, StyleAttributeShouldBeEmpty);

{

RefPtr fontElement = dynamicDowncast<HTMLFontElement>(element);

return fontElement && hasNoAttributeOrOnlyStyleAttribute(*fontElement, shouldStyleAttributeBeEmpty);

: CompositeEditCommand(WTF::move(document), editingAction)

, m_style(style->copy())

, m_propertyLevel(propertyLevel)

, m_start(endingSelection().start().downstream())

, m_end(endingSelection().end().upstream())

, m_useEndingSelection(true)

, m_removeOnly(false)

{

: CompositeEditCommand(WTF::move(document), editingAction)

, m_style(style->copy())

, m_propertyLevel(propertyLevel)

, m_start(start)

, m_end(end)

, m_useEndingSelection(false)

, m_removeOnly(false)

{

: CompositeEditCommand(element->document(), editingAction)

, m_style(EditingStyle::create())

, m_start(endingSelection().start().downstream())

, m_end(endingSelection().end().upstream())

, m_useEndingSelection(true)

, m_styledInlineElement(WTF::move(element))

, m_removeOnly(removeOnly)

{

: CompositeEditCommand(WTF::move(document), editingAction)

, m_style(style->copy())

, m_start(endingSelection().start().downstream())

, m_end(endingSelection().end().upstream())

, m_useEndingSelection(true)

, m_removeOnly(true)

, m_isInlineElementToRemoveFunction(isInlineElementToRemoveFunction)

{

{

ASSERT(!is_gt(treeOrder<ShadowIncludingTree>(newStart, newEnd)));

if (!m_useEndingSelection && (newStart != m_start || newEnd != m_end))

m_useEndingSelection = true;

bool wasBaseFirst = startingSelection().isBaseFirst() || startingSelection().directionality() != Directionality::Strong;

setEndingSelection(VisibleSelection(VisiblePosition(wasBaseFirst ? newStart : newEnd), VisiblePosition(wasBaseFirst ? newEnd : newStart),

endingSelection().directionality()));

m_start = newStart;

m_end = newEnd;

{

if (m_useEndingSelection)

return endingSelection().start();

return m_start;

{

if (m_useEndingSelection)

return endingSelection().end();

return m_end;

{

switch (m_propertyLevel) {

case ApplyStylePropertyLevel::Default: {

// Apply the block-centric properties of the style.

auto blockStyle = m_style->extractAndRemoveBlockProperties();

if (!blockStyle->isEmpty())

applyBlockStyle(blockStyle);

// Apply any remaining styles to the inline elements.

if (!m_style->isEmpty() || m_styledInlineElement || m_isInlineElementToRemoveFunction) {

applyRelativeFontStyleChange(m_style.get());

applyInlineStyle(*m_style);

}

break;

}

case ApplyStylePropertyLevel::ForceBlock:

// Force all properties to be applied as block styles.

applyBlockStyle(*m_style);

break;

}

{

// Update document layout once before removing styles so that we avoid the expense of

// updating before each and every call to check a computed style.

document().updateLayoutIgnorePendingStylesheets();

auto start = startPosition();

auto end = endPosition();

if (end < start)

std::swap(start, end);

VisiblePosition visibleStart(start);

VisiblePosition visibleEnd(end);

if (visibleStart.isNull() || visibleStart.isOrphan() || visibleEnd.isNull() || visibleEnd.isOrphan())

return;

// Save and restore the selection endpoints using their indices in the editable root, since

// addBlockStyleIfNeeded may moveParagraphs, which can remove these endpoints.

// Calculate start and end indices from the start of the tree that they're in.

RefPtr scopeRoot { highestEditableRoot(visibleStart.deepEquivalent()) };

if (!scopeRoot)

return;

auto scope = makeRangeSelectingNodeContents(*scopeRoot);

auto range = *makeSimpleRange(visibleStart, visibleEnd);

auto startIndex = characterCount({ scope.start, range.start }, TextIteratorBehavior::EmitsCharactersBetweenAllVisiblePositions);

auto endIndex = characterCount({ scope.start, range.end }, TextIteratorBehavior::EmitsCharactersBetweenAllVisiblePositions);

VisiblePosition paragraphStart(startOfParagraph(visibleStart));

VisiblePosition nextParagraphStart(endOfParagraph(paragraphStart).next());

if (visibleEnd != visibleStart && isStartOfParagraph(visibleEnd))

visibleEnd = visibleEnd.previous(CannotCrossEditingBoundary);

VisiblePosition beyondEnd(endOfParagraph(visibleEnd).next());

while (paragraphStart.isNotNull() && paragraphStart != beyondEnd) {

StyleChange styleChange(&style, paragraphStart.deepEquivalent());

if (styleChange.cssStyle() || m_removeOnly) {

RefPtr<Node> block = enclosingBlock(protect(paragraphStart.deepEquivalent().deprecatedNode()));

if (!m_removeOnly) {

RefPtr<Node> newBlock = moveParagraphContentsToNewBlockIfNecessary(paragraphStart.deepEquivalent());

if (newBlock)

block = newBlock;

}

ASSERT(!block || is<Element>(*block));

if (RefPtr htmlBlock = dynamicDowncast<HTMLElement>(block.get())) {

removeCSSStyle(style, *htmlBlock);

if (!m_removeOnly)

addBlockStyle(styleChange, *htmlBlock);

}

if (nextParagraphStart.isOrphan())

nextParagraphStart = endOfParagraph(paragraphStart).next();

}

paragraphStart = nextParagraphStart;

nextParagraphStart = endOfParagraph(paragraphStart).next();

}

auto startPosition = makeDeprecatedLegacyPosition(resolveCharacterLocation(scope, startIndex, TextIteratorBehavior::EmitsCharactersBetweenAllVisiblePositions));

auto endPosition = makeDeprecatedLegacyPosition(resolveCharacterLocation(scope, endIndex, TextIteratorBehavior::EmitsCharactersBetweenAllVisiblePositions));

updateStartEnd(startPosition, endPosition);

{

if (!style)

return MutableStyleProperties::create();

return style->mutableCopy();

{

static const float MinimumFontSize = 0.1f;

if (!style || !style->hasFontSizeDelta())

return;

auto start = startPosition();

auto end = endPosition();

if (end < start)

std::swap(start, end);

if (start.treeScope() != end.treeScope())

return;

// Join up any adjacent text nodes.

if (is<Text>(start.deprecatedNode())) {

joinChildTextNodes(start.deprecatedNode()->parentNode(), start, end);

start = startPosition();

end = endPosition();

}

if (start.isNull() || end.isNull())

return;

if (is<Text>(*end.deprecatedNode()) && start.deprecatedNode()->parentNode() != end.deprecatedNode()->parentNode()) {

joinChildTextNodes(end.deprecatedNode()->parentNode(), start, end);

start = startPosition();

end = endPosition();

}

if (start.isNull() || end.isNull())

return;

// Split the start text nodes if needed to apply style.

if (isValidCaretPositionInTextNode(start)) {

splitTextAtStart(start, end);

start = startPosition();

end = endPosition();

}

if (start.isNull() || end.isNull())

return;

if (isValidCaretPositionInTextNode(end)) {

splitTextAtEnd(start, end);

start = startPosition();

end = endPosition();

}

if (start.isNull() || end.isNull())

return;

// Calculate loop end point.

// If the end node is before the start node (can only happen if the end node is

// an ancestor of the start node), we gather nodes up to the next sibling of the end node.

RefPtr<Node> beyondEnd;

ASSERT(start.deprecatedNode());

ASSERT(end.deprecatedNode());

if (end.deprecatedNode()->contains(*start.deprecatedNode()))

beyondEnd = NodeTraversal::nextSkippingChildren(*end.deprecatedNode());

else

beyondEnd = NodeTraversal::next(*end.deprecatedNode());

start = start.upstream(); // Move upstream to ensure we do not add redundant spans.

RefPtr startNode = start.deprecatedNode();

if (!startNode)

return;

// Ensure the startNode is not at or past the beyondEnd when node traversal

// is performed in the following loops below.

if (beyondEnd) {

auto treeOrderPos = treeOrder(*startNode, *beyondEnd);

if (is_gteq(treeOrderPos))

return;

}

if (is<Text>(*startNode) && start.deprecatedEditingOffset() >= caretMaxOffset(*startNode)) {

// Move out of text node if range does not include its characters.

startNode = NodeTraversal::next(*startNode);

if (!startNode)

return;

}

// Store away font size before making any changes to the document.

// This ensures that changes to one node won't effect another.

HashMap<Ref<Node>, float> startingFontSizes;

for (auto node = startNode; node != beyondEnd; node = NodeTraversal::next(*node)) {

RELEASE_ASSERT(node);

startingFontSizes.set(*node, computedFontSize(node.get()));

}

// These spans were added by us. If empty after font size changes, they can be removed.

Vector<Ref<HTMLElement>> unstyledSpans;

RefPtr<Node> lastStyledNode;

bool reachedEnd = false;

for (auto node = startNode; node != beyondEnd && !reachedEnd; node = NodeTraversal::next(*node)) {

RELEASE_ASSERT(node);

RefPtr<HTMLElement> element;

if (auto* htmlElement = dynamicDowncast<HTMLElement>(*node)) {

// Only work on fully selected nodes.

if (!nodeFullySelected(*htmlElement, start, end)) {

if (!node->isConnected())

break;

continue;

}

element = htmlElement;

} else if (is<Text>(*node) && node->renderer() && node->parentNode() != lastStyledNode) {

// Last styled node was not parent node of this text node, but we wish to style this

// text node. To make this possible, add a style span to surround this text node.

auto span = createStyleSpanElement(document());

if (!surroundNodeRangeWithElement(*node, *node, span))

continue;

reachedEnd = node->isDescendantOf(beyondEnd.get()) || !node->parentElement();

element = WTF::move(span);

} else {

// Only handle HTML elements and text nodes.

continue;

}

lastStyledNode = node;

RefPtr<MutableStyleProperties> inlineStyle = copyStyleOrCreateEmpty(element->inlineStyle());

float currentFontSize = computedFontSize(node.get());

float desiredFontSize = std::max(MinimumFontSize, startingFontSizes.get(node.get()) + style->fontSizeDelta());

RefPtr<CSSValue> value = inlineStyle->getPropertyCSSValue(CSSPropertyFontSize);

if (value) {

element->removeInlineStyleProperty(CSSPropertyFontSize);

currentFontSize = computedFontSize(node.get());

}

if (currentFontSize != desiredFontSize) {

inlineStyle->setProperty(CSSPropertyFontSize, CSSPrimitiveValue::create(desiredFontSize, CSSUnitType::CSS_PX));

setNodeAttribute(*element, styleAttr, inlineStyle->asTextAtom(CSS::defaultSerializationContext()));

}

if (inlineStyle->isEmpty()) {

removeNodeAttribute(*element, styleAttr);

if (isSpanWithoutAttributesOrUnstyledStyleSpan(*element))

unstyledSpans.append(element.releaseNonNull());

}

}

for (auto& unstyledSpan : unstyledSpans)

removeNodePreservingChildren(unstyledSpan);

{

if (!dummySpanAncestor)

return;

// Dummy spans are created when text node is split, so that style information

// can be propagated, which can result in more splitting. If a dummy span gets

// cloned/split, the new node is always a sibling of it. Therefore, we scan

// all the children of the dummy's parent

Vector<Ref<Element>> toRemove;

for (Ref child : childrenOfType<Element>(*dummySpanAncestor)) {

if (isSpanWithoutAttributesOrUnstyledStyleSpan(child))

toRemove.append(child);

}

for (Ref element : toRemove)

removeNodePreservingChildren(element.get());

{

// We are allowed to leave the highest ancestor with unicode-bidi unsplit if it is unicode-bidi: embed and direction: allowedDirection.

// In that case, we return the unsplit ancestor. Otherwise, we return 0.

RefPtr block { enclosingBlock(node) };

if (!block || block == node)

return nullptr;

RefPtr<Node> highestAncestorWithUnicodeBidi;

RefPtr<Node> nextHighestAncestorWithUnicodeBidi;

int highestAncestorUnicodeBidi = 0;

for (auto ancestor = RefPtr { node->parentNode() }; ancestor != block; ancestor = ancestor->parentNode()) {

int unicodeBidi = valueID(Style::Extractor(ancestor.get()).propertyValue(CSSPropertyUnicodeBidi).get());

if (unicodeBidi && unicodeBidi != CSSValueNormal) {

highestAncestorUnicodeBidi = unicodeBidi;

nextHighestAncestorWithUnicodeBidi = highestAncestorWithUnicodeBidi;

highestAncestorWithUnicodeBidi = ancestor;

}

}

if (!highestAncestorWithUnicodeBidi)

return nullptr;

RefPtr<HTMLElement> unsplitAncestor;

if (allowedDirection != WritingDirection::Natural && highestAncestorUnicodeBidi != CSSValueBidiOverride) {

if (RefPtr highestAncestorElementWithUnicodeBidi = dynamicDowncast<HTMLElement>(*highestAncestorWithUnicodeBidi)) {

auto highestAncestorDirection = EditingStyle::create(highestAncestorElementWithUnicodeBidi.get(), EditingStyle::PropertiesToInclude::AllProperties)->textDirection();

if (highestAncestorDirection && *highestAncestorDirection == allowedDirection) {

if (!nextHighestAncestorWithUnicodeBidi)

return highestAncestorElementWithUnicodeBidi;

unsplitAncestor = WTF::move(highestAncestorElementWithUnicodeBidi);

highestAncestorWithUnicodeBidi = nextHighestAncestorWithUnicodeBidi;

}

}

}

// Split every ancestor through highest ancestor with embedding.

RefPtr<Node> currentNode = node;

while (currentNode) {

RefPtr parent = downcast<Element>(currentNode->parentNode());

if (before ? currentNode->previousSibling() : currentNode->nextSibling())

splitElement(*parent, before ? *currentNode : *protect(currentNode->nextSibling()));

if (parent == highestAncestorWithUnicodeBidi)

break;

currentNode = parent;

}

return unsplitAncestor;

{

RefPtr block { enclosingBlock(node) };

if (!block || block == node)

return;

for (RefPtr<Node> ancestor = node->parentNode(), parent; ancestor != block && ancestor != unsplitAncestor; ancestor = parent) {

parent = ancestor->parentNode();

RefPtr element = dynamicDowncast<StyledElement>(*ancestor);

if (!element)

continue;

int unicodeBidi = valueID(Style::Extractor(element.get()).propertyValue(CSSPropertyUnicodeBidi).get());

if (!unicodeBidi || unicodeBidi == CSSValueNormal)

continue;

// FIXME: This code should really consider the mapped attribute 'dir', the inline style declaration,

// and all matching style rules in order to determine how to best set the unicode-bidi property to 'normal'.

// For now, it assumes that if the 'dir' attribute is present, then removing it will suffice, and

// otherwise it sets the property in the inline style declaration.

if (element->hasAttributeWithoutSynchronization(dirAttr)) {

// FIXME: If this is a BDO element, we should probably just remove it if it has no

// other attributes, like we (should) do with B and I elements.

removeNodeAttribute(*element, dirAttr);

} else {

auto inlineStyle = copyStyleOrCreateEmpty(element->inlineStyle());

inlineStyle->setProperty(CSSPropertyUnicodeBidi, CSSValueNormal);

inlineStyle->removeProperty(CSSPropertyDirection);

setNodeAttribute(*element, styleAttr, inlineStyle->asTextAtom(CSS::defaultSerializationContext()));

if (isSpanWithoutAttributesOrUnstyledStyleSpan(*element))

removeNodePreservingChildren(*element);

}

}

{

for (RefPtr currentNode = startNode; currentNode && currentNode != enclosingNode; currentNode = currentNode->parentNode()) {

if (currentNode->isHTMLElement() && valueID(Style::Extractor(currentNode.get()).propertyValue(CSSPropertyUnicodeBidi).get()) == CSSValueEmbed)

return currentNode;

}

return nullptr;

{

RefPtr<ContainerNode> startDummySpanAncestor;

RefPtr<ContainerNode> endDummySpanAncestor;

// update document layout once before removing styles

// so that we avoid the expense of updating before each and every call

// to check a computed style

document().updateLayoutIgnorePendingStylesheets();

// adjust to the positions we want to use for applying style

auto start = startPosition();

auto end = endPosition();

if (end < start)

std::swap(start, end);

// split the start node and containing element if the selection starts inside of it

bool splitStart = isValidCaretPositionInTextNode(start);

if (splitStart) {

if (shouldSplitTextElement(start.deprecatedNode()->parentElement(), style))

splitTextElementAtStart(start, end);

else

splitTextAtStart(start, end);

start = startPosition();

end = endPosition();

if (start.isNull() || end.isNull())

return;

startDummySpanAncestor = dummySpanAncestorForNode(start.deprecatedNode());

}

// split the end node and containing element if the selection ends inside of it

bool splitEnd = isValidCaretPositionInTextNode(end);

if (splitEnd) {

if (shouldSplitTextElement(end.deprecatedNode()->parentElement(), style))

splitTextElementAtEnd(start, end);

else

splitTextAtEnd(start, end);

start = startPosition();

end = endPosition();

if (start.isNull() || end.isNull())

return;

endDummySpanAncestor = dummySpanAncestorForNode(end.deprecatedNode());

}

if (start.isNull() || start.isOrphan() || end.isNull() || end.isOrphan())

return;

// Remove style from the selection.

// Use the upstream position of the start for removing style.

// This will ensure we remove all traces of the relevant styles from the selection

// and prevent us from adding redundant ones, as described in:

// <rdar://problem/3724344> Bolding and unbolding creates extraneous tags

Position removeStart = start.upstream();

auto textDirection = style.textDirection();

RefPtr<EditingStyle> styleWithoutEmbedding;

RefPtr<EditingStyle> embeddingStyle;

if (textDirection) {

// Leave alone an ancestor that provides the desired single level embedding, if there is one.

auto startUnsplitAncestor = splitAncestorsWithUnicodeBidi(start.deprecatedNode(), true, *textDirection);

auto endUnsplitAncestor = splitAncestorsWithUnicodeBidi(end.deprecatedNode(), false, *textDirection);

removeEmbeddingUpToEnclosingBlock(start.deprecatedNode(), startUnsplitAncestor.get());

removeEmbeddingUpToEnclosingBlock(end.deprecatedNode(), endUnsplitAncestor.get());

// Avoid removing the dir attribute and the unicode-bidi and direction properties from the unsplit ancestors.

Position embeddingRemoveStart = removeStart;

if (startUnsplitAncestor && nodeFullySelected(*startUnsplitAncestor, removeStart, end))

embeddingRemoveStart = positionInParentAfterNode(*startUnsplitAncestor);

Position embeddingRemoveEnd = end;

if (endUnsplitAncestor && nodeFullySelected(*endUnsplitAncestor, removeStart, end))

embeddingRemoveEnd = positionInParentBeforeNode(*endUnsplitAncestor).downstream();

if (embeddingRemoveEnd != removeStart || embeddingRemoveEnd != end) {

styleWithoutEmbedding = style.copy();

embeddingStyle = styleWithoutEmbedding->extractAndRemoveTextDirection();

if (embeddingRemoveStart <= embeddingRemoveEnd)

removeInlineStyle(*embeddingStyle, embeddingRemoveStart, embeddingRemoveEnd);

}

}

removeInlineStyle(styleWithoutEmbedding ? *styleWithoutEmbedding : style, removeStart, end);

start = startPosition();

end = endPosition();

if (start.isNull() || start.isOrphan() || end.isNull() || end.isOrphan())

return;

if (splitStart && mergeStartWithPreviousIfIdentical(start, end)) {

start = startPosition();

end = endPosition();

}

if (start.isNull() || end.isNull())

return;

if (splitEnd) {

mergeEndWithNextIfIdentical(start, end);

start = startPosition();

end = endPosition();

}

if (start.isNull() || end.isNull())

return;

// update document layout once before running the rest of the function

// so that we avoid the expense of updating before each and every call

// to check a computed style

document().updateLayoutIgnorePendingStylesheets();

RefPtr styleToApply = style;

if (textDirection) {

// Avoid applying the unicode-bidi and direction properties beneath ancestors that already have them.

RefPtr startNode = start.deprecatedNode();

auto embeddingStartNode = highestEmbeddingAncestor(startNode.get(), enclosingBlock(startNode).get());

RefPtr endNode = end.deprecatedNode();

auto embeddingEndNode = highestEmbeddingAncestor(endNode.get(), enclosingBlock(endNode).get());

if (embeddingStartNode || embeddingEndNode) {

Position embeddingApplyStart = embeddingStartNode ? positionInParentAfterNode(*embeddingStartNode) : start;

Position embeddingApplyEnd = embeddingEndNode ? positionInParentBeforeNode(*embeddingEndNode) : end;

ASSERT(embeddingApplyStart.isNotNull() && embeddingApplyEnd.isNotNull());

if (!embeddingStyle) {

styleWithoutEmbedding = style.copy();

embeddingStyle = styleWithoutEmbedding->extractAndRemoveTextDirection();

}

fixRangeAndApplyInlineStyle(*embeddingStyle, embeddingApplyStart, embeddingApplyEnd);

styleToApply = styleWithoutEmbedding;

}

}

fixRangeAndApplyInlineStyle(*styleToApply, start, end);

// Remove dummy style spans created by splitting text elements.

cleanupUnstyledAppleStyleSpans(startDummySpanAncestor.get());

if (endDummySpanAncestor != startDummySpanAncestor)

cleanupUnstyledAppleStyleSpans(endDummySpanAncestor.get());

{

RefPtr startNode = start.deprecatedNode();

if (start.deprecatedEditingOffset() >= caretMaxOffset(*startNode)) {

startNode = NodeTraversal::next(*startNode);

if (!startNode || end < firstPositionInOrBeforeNode(startNode.get()))

return;

}

RefPtr pastEndNode = end.deprecatedNode();

if (end.deprecatedEditingOffset() >= caretMaxOffset(*pastEndNode))

pastEndNode = NodeTraversal::nextSkippingChildren(*pastEndNode);

// FIXME: Callers should perform this operation on a Range that includes the br

// if they want style applied to the empty line.

// FIXME: Should this be using startNode instead of start.deprecatedNode()?

if (start == end && start.deprecatedNode()->hasTagName(brTag))

pastEndNode = NodeTraversal::next(*start.deprecatedNode());

// Start from the highest fully selected ancestor so that we can modify the fully selected node.

// e.g. When applying font-size: large on <font color="blue">hello</font>, we need to include the font element in our run

// to generate <font color="blue" size="4">hello</font> instead of <font color="blue"><font size="4">hello</font></font>

auto range = *makeSimpleRange(start, end);

RefPtr editableRoot { startNode->rootEditableElement() };

if (startNode != editableRoot) {

while (editableRoot && startNode->parentNode() != editableRoot && isNodeVisiblyContainedWithin(*startNode->parentNode(), range))

startNode = startNode->parentNode();

}

applyInlineStyleToNodeRange(style, *startNode, pastEndNode.get());

{

if (!node.hasEditableStyle())

return true;

RefPtr sibling { NodeTraversal::nextSkippingChildren(node) };

for (RefPtr descendant = node.firstChild(); descendant && descendant != sibling; descendant = NodeTraversal::next(*descendant)) {

if (!descendant->hasEditableStyle())

return true;

}

return false;

InlineRunToApplyStyle(Node* start, Node* end, Node* pastEndNode)

: start(start)

, end(end)

, pastEndNode(pastEndNode)

{

ASSERT(start->parentNode() == end->parentNode());

}

bool NODELETE startAndEndAreStillInDocument()

{

return start && end && start->isConnected() && end->isConnected();

}

RefPtr<Node> start;

RefPtr<Node> end;

RefPtr<Node> pastEndNode;

Position positionForStyleComputation;

RefPtr<Node> dummyElement;

StyleChange change;

{

if (m_removeOnly)

return;

document().updateLayoutIgnorePendingStylesheets();

Vector<InlineRunToApplyStyle> runs;

RefPtr node = startNode;

for (RefPtr<Node> next; node && node != pastEndNode; node = next) {

next = NodeTraversal::next(*node);

if (!node->renderer() || !node->hasEditableStyle())

continue;

if (!node->hasRichlyEditableStyle()) {

if (auto* element = dynamicDowncast<HTMLElement>(*node)) {

// This is a plaintext-only region. Only proceed if it's fully selected.

// pastEndNode is the node after the last fully selected node, so if it's inside node then

// node isn't fully selected.

if (pastEndNode && pastEndNode->isDescendantOf(*node))

break;

// Add to this element's inline style and skip over its contents.

RefPtr inlineStyle = copyStyleOrCreateEmpty(element->inlineStyle());

if (RefPtr otherStyle = style.style())

inlineStyle->mergeAndOverrideOnConflict(*otherStyle);

setNodeAttribute(*element, styleAttr, inlineStyle->asTextAtom(CSS::defaultSerializationContext()));

next = NodeTraversal::nextSkippingChildren(*element);

continue;

}

}

if (isBlock(*node))

continue;

if (node->hasChildNodes()) {

if (node->contains(pastEndNode) || containsNonEditableRegion(*node) || !node->parentNode()->hasEditableStyle())

continue;

if (editingIgnoresContent(*node)) {

next = NodeTraversal::nextSkippingChildren(*node);

continue;

}

}

auto runStart = node;

auto runEnd = node;

RefPtr sibling { node->nextSibling() };

while (sibling && sibling != pastEndNode && !sibling->contains(pastEndNode) && (!isBlock(*sibling) || sibling->hasTagName(brTag)) && !containsNonEditableRegion(*sibling)) {

runEnd = sibling;

sibling = runEnd->nextSibling();

}

next = NodeTraversal::nextSkippingChildren(*runEnd);

RefPtr pastEndNode { NodeTraversal::nextSkippingChildren(*runEnd) };

if (!shouldApplyInlineStyleToRun(style, runStart.get(), pastEndNode.get()))

continue;

runs.append(InlineRunToApplyStyle(runStart.get(), runEnd.get(), pastEndNode.get()));

}

for (auto& run : runs) {

removeConflictingInlineStyleFromRun(style, run.start, run.end, run.pastEndNode.get());

if (run.startAndEndAreStillInDocument())

run.positionForStyleComputation = positionToComputeInlineStyleChange(*run.start, run.dummyElement);

}

document().updateLayoutIgnorePendingStylesheets();

for (auto& run : runs)

run.change = StyleChange(&style, run.positionForStyleComputation);

for (auto& run : runs) {

if (run.dummyElement)

removeNode(*run.dummyElement);

if (run.startAndEndAreStillInDocument())

applyInlineStyleChange(run.start.releaseNonNull(), run.end.releaseNonNull(), run.change, AddStyledElement::Yes);

}

{

return (m_styledInlineElement && element->hasTagName(m_styledInlineElement->tagQName()))

|| (m_isInlineElementToRemoveFunction && m_isInlineElementToRemoveFunction(element));

{

ASSERT(runStart);

for (RefPtr node = runStart; node && node != pastEndNode; node = NodeTraversal::next(*node)) {

if (node->hasChildNodes())

continue;

// We don't consider m_isInlineElementToRemoveFunction here because we never apply style when m_isInlineElementToRemoveFunction is specified

if (!style.styleIsPresentInComputedStyleOfNode(*node))

return true;

if (m_styledInlineElement && !enclosingElementWithTag(positionBeforeNode(*node), m_styledInlineElement->tagQName()))

return true;

}

return false;

{

ASSERT(runStart && runEnd);

RefPtr<Node> next = runStart;

for (RefPtr<Node> node = next; node && node->isConnected() && node != pastEndNode; node = next) {

if (editingIgnoresContent(*node)) {

ASSERT(!node->contains(pastEndNode));

next = NodeTraversal::nextSkippingChildren(*node);

} else

next = NodeTraversal::next(*node);

auto* htmlElement = dynamicDowncast<HTMLElement>(*node);

if (!htmlElement)

continue;

RefPtr<Node> previousSibling = node->previousSibling();

RefPtr<Node> nextSibling = node->nextSibling();

RefPtr<ContainerNode> parent = node->parentNode();

removeInlineStyleFromElement(style, *htmlElement, InlineStyleRemovalMode::Always);

if (!node->isConnected()) {

// FIXME: We might need to update the start and the end of current selection here but need a test.

if (runStart == node)

runStart = previousSibling ? previousSibling->nextSibling() : parent->firstChild();

if (runEnd == node)

runEnd = nextSibling ? nextSibling->previousSibling() : parent->lastChild();

}

}

{

if (!element.parentNode() || !isEditableNode(*element.parentNode()))

return false;

if (isStyledInlineElementToRemove(&element)) {

if (mode == InlineStyleRemovalMode::None)

return true;

if (extractedStyle)

extractedStyle->mergeInlineStyleOfElement(element, EditingStyle::CSSPropertyOverrideMode::OverrideValues);

removeNodePreservingChildren(element);

return true;

}

bool removed = false;

if (removeImplicitlyStyledElement(style, element, mode, extractedStyle))

removed = true;

if (!element.isConnected())

return removed;

// If the node was converted to a span, the span may still contain relevant

// styles which must be removed (e.g. <b style='font-weight: bold'>)

if (removeCSSStyle(style, element, mode, extractedStyle))

removed = true;

return removed;

{

if (hasNoAttributeOrOnlyStyleAttribute(element, StyleAttributeShouldBeEmpty))

removeNodePreservingChildren(element);

else {

RefPtr newSpanElement = replaceElementWithSpanPreservingChildrenAndAttributes(element);

ASSERT_UNUSED(newSpanElement, newSpanElement && newSpanElement->isConnected());

}

{

if (mode == InlineStyleRemovalMode::None) {

ASSERT(!extractedStyle);

return style.conflictsWithImplicitStyleOfElement(element) || style.conflictsWithImplicitStyleOfAttributes(element);

}

ASSERT(mode == InlineStyleRemovalMode::IfNeeded || mode == InlineStyleRemovalMode::Always);

if (style.conflictsWithImplicitStyleOfElement(element, extractedStyle, mode == InlineStyleRemovalMode::Always ? EditingStyle::ShouldExtractMatchingStyle::Yes : EditingStyle::ShouldExtractMatchingStyle::No)) {

replaceWithSpanOrRemoveIfWithoutAttributes(element);

return true;

}

// unicode-bidi and direction are pushed down separately so don't push down with other styles

Vector<QualifiedName> attributes;

if (!style.extractConflictingImplicitStyleOfAttributes(element, extractedStyle ? EditingStyle::ShouldPreserveWritingDirection::Yes : EditingStyle::ShouldPreserveWritingDirection::No, extractedStyle, attributes, mode == InlineStyleRemovalMode::Always ? EditingStyle::ShouldExtractMatchingStyle::Yes : EditingStyle::ShouldExtractMatchingStyle::No))

return false;

for (auto& attribute : attributes)

removeNodeAttribute(element, attribute);

if (isEmptyFontTag(&element) || isSpanWithoutAttributesOrUnstyledStyleSpan(element))

removeNodePreservingChildren(element);

return true;

{

if (mode == InlineStyleRemovalMode::None)

return style.conflictsWithInlineStyleOfElement(element);

RefPtr<MutableStyleProperties> newInlineStyle;

if (!style.conflictsWithInlineStyleOfElement(element, newInlineStyle, extractedStyle))

return false;

if (newInlineStyle->isEmpty())

removeNodeAttribute(element, styleAttr);

else

setNodeAttribute(element, styleAttr, newInlineStyle->asTextAtom(CSS::defaultSerializationContext()));

if (isSpanWithoutAttributesOrUnstyledStyleSpan(element))

removeNodePreservingChildren(element);

return true;

{

if (!node)

return nullptr;

RefPtr<HTMLElement> result;

RefPtr unsplittableElement = unsplittableElementForPosition(firstPositionInOrBeforeNode(node));

for (RefPtr ancestor = node; ancestor; ancestor = ancestor->parentNode()) {

auto* htmlAncestor = dynamicDowncast<HTMLElement>(*ancestor);

if (htmlAncestor && shouldRemoveInlineStyleFromElement(style, *htmlAncestor))

result = htmlAncestor;