/*

* Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

*

* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR

* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#include "config.h"

#include "CompositeEditCommand.h"

#include "AXObjectCache.h"

#include "AppendNodeCommand.h"

#include "ApplyStyleCommand.h"

#include "BreakBlockquoteCommand.h"

#include "DataTransfer.h"

#include "DeleteFromTextNodeCommand.h"

#include "DeleteSelectionCommand.h"

#include "Document.h"

#include "DocumentFragment.h"

#include "DocumentMarkerController.h"

#include "Editing.h"

#include "Editor.h"

#include "EditorInsertAction.h"

#include "ElementTraversal.h"

#include "Event.h"

#include "Frame.h"

#include "HTMLBRElement.h"

#include "HTMLDivElement.h"

#include "HTMLLIElement.h"

#include "HTMLNames.h"

#include "HTMLSpanElement.h"

#include "InsertIntoTextNodeCommand.h"

#include "InsertLineBreakCommand.h"

#include "InsertNodeBeforeCommand.h"

#include "InsertParagraphSeparatorCommand.h"

#include "InsertTextCommand.h"

#include "LayoutIntegrationRunIterator.h"

#include "LegacyInlineTextBox.h"

#include "MergeIdenticalElementsCommand.h"

#include "NodeTraversal.h"

#include "RemoveNodeCommand.h"

#include "RemoveNodePreservingChildrenCommand.h"

#include "RenderBlockFlow.h"

#include "RenderText.h"

#include "RenderedDocumentMarker.h"

#include "ReplaceNodeWithSpanCommand.h"

#include "ReplaceSelectionCommand.h"

#include "ScopedEventQueue.h"

#include "ScriptDisallowedScope.h"

#include "SetNodeAttributeCommand.h"

#include "SplitElementCommand.h"

#include "SplitTextNodeCommand.h"

#include "SplitTextNodeContainingElementCommand.h"

#include "StaticRange.h"

#include "Text.h"

#include "TextIterator.h"

#include "VisibleUnits.h"

#include "WrapContentsInDummySpanCommand.h"

#include "markup.h"

namespace WebCore {

using namespace HTMLNames;

int AccessibilityUndoReplacedText::indexForVisiblePosition(const VisiblePosition& position, RefPtr<ContainerNode>& scope) const

{

if (position.deepEquivalent().isNull())

return -1;

return WebCore::indexForVisiblePosition(position, scope);

}

void AccessibilityUndoReplacedText::configureRangeDeletedByReapplyWithEndingSelection(const VisibleSelection& selection)

{

if (!AXObjectCache::accessibilityEnabled())

return;

if (selection.isNone())

return;

m_rangeDeletedByReapply.endIndex.value = indexForVisiblePosition(selection.end(), m_rangeDeletedByReapply.endIndex.scope);

}

void AccessibilityUndoReplacedText::configureRangeDeletedByReapplyWithStartingSelection(const VisibleSelection& selection)

{

if (!AXObjectCache::accessibilityEnabled())

return;

if (selection.isNone())

return;

if (m_rangeDeletedByReapply.startIndex.value == -1)

m_rangeDeletedByReapply.startIndex.value = indexForVisiblePosition(selection.start(), m_rangeDeletedByReapply.startIndex.scope);

}

void AccessibilityUndoReplacedText::setRangeDeletedByUnapply(const VisiblePositionIndexRange& range)

{

if (m_rangeDeletedByUnapply.isNull())

m_rangeDeletedByUnapply = range;

}

void AccessibilityUndoReplacedText::captureTextForUnapply()

{

if (!AXObjectCache::accessibilityEnabled())

return;

m_replacedText = textDeletedByReapply();

}

void AccessibilityUndoReplacedText::captureTextForReapply()

{

if (!AXObjectCache::accessibilityEnabled())

return;

m_replacedText = textDeletedByUnapply();

}

static String stringForVisiblePositionIndexRange(const VisiblePositionIndexRange& range)

{

if (range.isNull())

return String();

VisiblePosition start = visiblePositionForIndex(range.startIndex.value, range.startIndex.scope.get());

VisiblePosition end = visiblePositionForIndex(range.endIndex.value, range.endIndex.scope.get());

return AccessibilityObject::stringForVisiblePositionRange({ WTFMove(start), WTFMove(end) });

}

String AccessibilityUndoReplacedText::textDeletedByUnapply()

{

if (!AXObjectCache::accessibilityEnabled())

return String();

return stringForVisiblePositionIndexRange(m_rangeDeletedByUnapply);

}

String AccessibilityUndoReplacedText::textDeletedByReapply()

{

if (!AXObjectCache::accessibilityEnabled())

return String();

return stringForVisiblePositionIndexRange(m_rangeDeletedByReapply);

}

static void postTextStateChangeNotification(AXObjectCache* cache, const VisiblePosition& position, const String& deletedText, const String& insertedText)

{

ASSERT(cache);

RefPtr node { highestEditableRoot(position.deepEquivalent(), HasEditableAXRole) };

if (!node)

return;

if (insertedText.length() && deletedText.length())

cache->postTextReplacementNotification(node.get(), AXTextEditTypeDelete, insertedText, AXTextEditTypeInsert, deletedText, position);

else if (deletedText.length())

cache->postTextStateChangeNotification(node.get(), AXTextEditTypeInsert, deletedText, position);

else if (insertedText.length())

cache->postTextStateChangeNotification(node.get(), AXTextEditTypeDelete, insertedText, position);

}

void AccessibilityUndoReplacedText::postTextStateChangeNotificationForUnapply(AXObjectCache* cache)

{

if (!cache)

return;

if (!AXObjectCache::accessibilityEnabled())

return;

if (m_rangeDeletedByUnapply.isNull())

return;

VisiblePosition position = visiblePositionForIndex(m_rangeDeletedByUnapply.endIndex.value, m_rangeDeletedByUnapply.endIndex.scope.get());

if (position.isNull())

return;

postTextStateChangeNotification(cache, position, textDeletedByUnapply(), m_replacedText);

m_replacedText = String();

}

void AccessibilityUndoReplacedText::postTextStateChangeNotificationForReapply(AXObjectCache* cache)

{

if (!cache)

return;

if (!AXObjectCache::accessibilityEnabled())

return;

if (m_rangeDeletedByReapply.isNull())

return;

VisiblePosition position = visiblePositionForIndex(m_rangeDeletedByReapply.startIndex.value, m_rangeDeletedByReapply.startIndex.scope.get());

if (position.isNull())

return;

postTextStateChangeNotification(cache, position, textDeletedByReapply(), m_replacedText);

m_replacedText = String();

}

Ref<EditCommandComposition> EditCommandComposition::create(Document& document,

const VisibleSelection& startingSelection, const VisibleSelection& endingSelection, EditAction editAction)

{

return adoptRef(*new EditCommandComposition(document, startingSelection, endingSelection, editAction));

}

EditCommandComposition::EditCommandComposition(Document& document, const VisibleSelection& startingSelection, const VisibleSelection& endingSelection, EditAction editAction)

: m_document(&document)

, m_startingSelection(startingSelection)

, m_endingSelection(endingSelection)

, m_startingRootEditableElement(startingSelection.rootEditableElement())

, m_endingRootEditableElement(endingSelection.rootEditableElement())

, m_editAction(editAction)

{

m_replacedText.configureRangeDeletedByReapplyWithStartingSelection(startingSelection);

}

bool EditCommandComposition::areRootEditabledElementsConnected()

{

if (m_startingRootEditableElement && !m_startingRootEditableElement->isConnected())

return false;

if (m_endingRootEditableElement && !m_endingRootEditableElement->isConnected())

return false;

return true;

}

void EditCommandComposition::unapply()

{

ASSERT(m_document);

RefPtr<Frame> frame = m_document->frame();

if (!frame)

return;

if (!areRootEditabledElementsConnected())

return;

m_replacedText.captureTextForUnapply();

// Changes to the document may have been made since the last editing operation that require a layout, as in <rdar://problem/5658603>.

// Low level operations, like RemoveNodeCommand, don't require a layout because the high level operations that use them perform one

// if one is necessary (like for the creation of VisiblePositions).

m_document->updateLayoutIgnorePendingStylesheets();

#if PLATFORM(IOS_FAMILY)

// FIXME: Where should iPhone code deal with the composition?

// Since editing commands don't save/restore the composition, undoing without fixing

// up the composition will leave a stale, invalid composition, as in <rdar://problem/6831637>.

// Desktop handles this in -[WebHTMLView _updateSelectionForInputManager], but the phone

// goes another route.

m_document->editor().cancelComposition();

#endif

auto prohibitScrollingForScope = m_document->view() ? m_document->view()->prohibitScrollingWhenChangingContentSizeForScope() : nullptr;

if (!m_document->editor().willUnapplyEditing(*this))

return;

size_t size = m_commands.size();

for (size_t i = size; i; --i)

m_commands[i - 1]->doUnapply();

m_document->editor().unappliedEditing(*this);

if (AXObjectCache::accessibilityEnabled())

m_replacedText.postTextStateChangeNotificationForUnapply(m_document->existingAXObjectCache());

RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(m_document->selection().isNone() || m_document->selection().isConnectedToDocument());

}

void EditCommandComposition::reapply()

{

ASSERT(m_document);

RefPtr<Frame> frame = m_document->frame();

if (!frame)

return;

if (!areRootEditabledElementsConnected())

return;

m_replacedText.captureTextForReapply();

// Changes to the document may have been made since the last editing operation that require a layout, as in <rdar://problem/5658603>.

// Low level operations, like RemoveNodeCommand, don't require a layout because the high level operations that use them perform one

// if one is necessary (like for the creation of VisiblePositions).

m_document->updateLayoutIgnorePendingStylesheets();

auto prohibitScrollingForScope = m_document->view() ? m_document->view()->prohibitScrollingWhenChangingContentSizeForScope() : nullptr;

if (!m_document->editor().willReapplyEditing(*this))

return;

for (auto& command : m_commands)

command->doReapply();

m_document->editor().reappliedEditing(*this);

if (AXObjectCache::accessibilityEnabled())

m_replacedText.postTextStateChangeNotificationForReapply(m_document->existingAXObjectCache());

RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(m_document->selection().isNone() || m_document->selection().isConnectedToDocument());

}

void EditCommandComposition::append(SimpleEditCommand* command)

{

m_commands.append(command);

}

void EditCommandComposition::setStartingSelection(const VisibleSelection& selection)

{

m_startingSelection = selection;

m_startingRootEditableElement = selection.rootEditableElement();

m_replacedText.configureRangeDeletedByReapplyWithStartingSelection(selection);

}

void EditCommandComposition::setEndingSelection(const VisibleSelection& selection)

{

m_endingSelection = selection;

m_endingRootEditableElement = selection.rootEditableElement();

m_replacedText.configureRangeDeletedByReapplyWithEndingSelection(selection);

}

void EditCommandComposition::setRangeDeletedByUnapply(const VisiblePositionIndexRange& range)

{

m_replacedText.setRangeDeletedByUnapply(range);

}

#ifndef NDEBUG

void EditCommandComposition::getNodesInCommand(HashSet<Ref<Node>>& nodes)

{

for (auto& command : m_commands)

command->getNodesInCommand(nodes);

}

#endif

String EditCommandComposition::label() const

{

return undoRedoLabel(m_editAction);

}

CompositeEditCommand::CompositeEditCommand(Document& document, EditAction editingAction)

: EditCommand(document, editingAction)

{

}

CompositeEditCommand::~CompositeEditCommand()

{

ASSERT(isTopLevelCommand() || !m_composition);

}

bool CompositeEditCommand::willApplyCommand()

{

return document().editor().willApplyEditing(*this, targetRangesForBindings());

}

void CompositeEditCommand::apply()

{

if (!endingSelection().isContentRichlyEditable()) {

switch (editingAction()) {

case EditAction::TypingDeleteSelection:

case EditAction::TypingDeleteBackward:

case EditAction::TypingDeleteForward:

case EditAction::TypingDeleteWordBackward:

case EditAction::TypingDeleteWordForward:

case EditAction::TypingDeleteLineBackward:

case EditAction::TypingDeleteLineForward:

case EditAction::TypingDeletePendingComposition:

case EditAction::TypingDeleteFinalComposition:

case EditAction::TypingInsertText:

case EditAction::TypingInsertLineBreak:

case EditAction::TypingInsertParagraph:

case EditAction::TypingInsertPendingComposition:

case EditAction::TypingInsertFinalComposition:

case EditAction::Paste:

case EditAction::DeleteByDrag:

case EditAction::SetInlineWritingDirection:

case EditAction::SetBlockWritingDirection:

case EditAction::Cut:

case EditAction::Unspecified:

case EditAction::Insert:

case EditAction::InsertReplacement:

case EditAction::InsertFromDrop:

case EditAction::Delete:

case EditAction::Dictation:

break;

default:

ASSERT_NOT_REACHED();

return;

}

}

ensureComposition();

// Changes to the document may have been made since the last editing operation that require a layout, as in <rdar://problem/5658603>.

// Low level operations, like RemoveNodeCommand, don't require a layout because the high level operations that use them perform one

// if one is necessary (like for the creation of VisiblePositions).

document().updateLayoutIgnorePendingStylesheets();

auto prohibitScrollingForScope = document().view() ? document().view()->prohibitScrollingWhenChangingContentSizeForScope() : nullptr;

if (!willApplyCommand())

return;

{

EventQueueScope eventQueueScope;

doApply();

}

didApplyCommand();

setShouldRetainAutocorrectionIndicator(false);

}

void CompositeEditCommand::didApplyCommand()

{

document().editor().appliedEditing(*this);

}

Vector<RefPtr<StaticRange>> CompositeEditCommand::targetRanges() const

{

ASSERT(!isEditingTextAreaOrTextInput());

auto firstRange = document().selection().selection().firstRange();

if (!firstRange)

return { };

return { 1, StaticRange::create(WTFMove(*firstRange)) };

}

Vector<RefPtr<StaticRange>> CompositeEditCommand::targetRangesForBindings() const

{

if (isEditingTextAreaOrTextInput())

return { };

return targetRanges();

}

RefPtr<DataTransfer> CompositeEditCommand::inputEventDataTransfer() const

{

return nullptr;

}

EditCommandComposition* CompositeEditCommand::composition() const

{

for (auto* command = this; command; command = command->parent()) {

if (auto composition = command->m_composition) {

ASSERT(!command->parent());

return composition.get();

}

}

return nullptr;

}

EditCommandComposition& CompositeEditCommand::ensureComposition()

{

RefPtr command { this };

while (auto* parent = command->parent())

command = parent;

if (!command->m_composition)

command->m_composition = EditCommandComposition::create(document(), startingSelection(), endingSelection(), editingAction());

return *command->m_composition;

}

bool CompositeEditCommand::isCreateLinkCommand() const

{

return false;

}

bool CompositeEditCommand::preservesTypingStyle() const

{

return false;

}

bool CompositeEditCommand::isTypingCommand() const

{

return false;

}

bool CompositeEditCommand::shouldRetainAutocorrectionIndicator() const

{

return false;

}

void CompositeEditCommand::setShouldRetainAutocorrectionIndicator(bool)

{

}

String CompositeEditCommand::inputEventTypeName() const

{

return inputTypeNameForEditingAction(editingAction());

}

//

// sugary-sweet convenience functions to help create and apply edit commands in composite commands

//

void CompositeEditCommand::applyCommandToComposite(Ref<EditCommand>&& command)

{

command->setParent(this);

command->doApply();

if (command->isSimpleEditCommand()) {

command->setParent(nullptr);

ensureComposition().append(toSimpleEditCommand(command.ptr()));

}

m_commands.append(WTFMove(command));

}

void CompositeEditCommand::applyCommandToComposite(Ref<CompositeEditCommand>&& command, const VisibleSelection& selection)

{

command->setParent(this);

if (selection != command->endingSelection()) {

command->setStartingSelection(selection);

command->setEndingSelection(selection);

}

command->doApply();

m_commands.append(WTFMove(command));

}

void CompositeEditCommand::applyStyle(const EditingStyle* style, EditAction editingAction)

{

applyCommandToComposite(ApplyStyleCommand::create(document(), style, editingAction));

}

void CompositeEditCommand::applyStyle(const EditingStyle* style, const Position& start, const Position& end, EditAction editingAction)

{

applyCommandToComposite(ApplyStyleCommand::create(document(), style, start, end, editingAction));

}

void CompositeEditCommand::applyStyledElement(Ref<Element>&& element)

{

applyCommandToComposite(ApplyStyleCommand::create(WTFMove(element), false));

}

void CompositeEditCommand::removeStyledElement(Ref<Element>&& element)

{

applyCommandToComposite(ApplyStyleCommand::create(WTFMove(element), true));

}

void CompositeEditCommand::insertParagraphSeparator(bool useDefaultParagraphElement, bool pasteBlockqutoeIntoUnquotedArea)

{

applyCommandToComposite(InsertParagraphSeparatorCommand::create(document(), useDefaultParagraphElement, pasteBlockqutoeIntoUnquotedArea, editingAction()));

}

void CompositeEditCommand::insertLineBreak()

{

applyCommandToComposite(InsertLineBreakCommand::create(document()));

}

bool CompositeEditCommand::isRemovableBlock(const Node* node)

{

ASSERT(node);

// FIXME: We should support other elements that can be removed.

if (!is<HTMLDivElement>(*node))

return false;

auto* parentNode = node->parentNode();

if (!parentNode || !parentNode->hasOneChild())

return false;

if (!downcast<HTMLDivElement>(*node).hasAttributes())

return true;

return false;

}

void CompositeEditCommand::insertNodeBefore(Ref<Node>&& insertChild, Node& refChild, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)

{

RefPtr parent { refChild.parentNode() };

if (!parent || (!parent->hasEditableStyle() && parent->renderer()))

return;

applyCommandToComposite(InsertNodeBeforeCommand::create(WTFMove(insertChild), refChild, shouldAssumeContentIsAlwaysEditable, editingAction()));

}

void CompositeEditCommand::insertNodeAfter(Ref<Node>&& insertChild, Node& refChild)

{

RefPtr parent { refChild.parentNode() };

if (!parent)

return;

ASSERT(!parent->isShadowRoot());

if (parent->lastChild() == &refChild)

appendNode(WTFMove(insertChild), *parent);

else {

ASSERT(refChild.nextSibling());

insertNodeBefore(WTFMove(insertChild), *refChild.nextSibling());

}

}

void CompositeEditCommand::insertNodeAt(Ref<Node>&& insertChild, const Position& editingPosition)

{

ASSERT(isEditablePosition(editingPosition));

// For editing positions like [table, 0], insert before the table,

// likewise for replaced elements, brs, etc.

Position p = editingPosition.parentAnchoredEquivalent();

RefPtr refChild { p.deprecatedNode() };

int offset = p.deprecatedEditingOffset();

if (canHaveChildrenForEditing(*refChild)) {

RefPtr child { refChild->firstChild() };

for (int i = 0; child && i < offset; i++)

child = child->nextSibling();

if (child)

insertNodeBefore(WTFMove(insertChild), *child);

else

appendNode(WTFMove(insertChild), downcast<ContainerNode>(*refChild));

} else if (caretMinOffset(*refChild) >= offset)

insertNodeBefore(WTFMove(insertChild), *refChild);

else if (is<Text>(*refChild) && caretMaxOffset(*refChild) > offset) {

splitTextNode(downcast<Text>(*refChild), offset);

// Mutation events (bug 22634) from the text node insertion may have removed the refChild

if (!refChild->isConnected())

return;

insertNodeBefore(WTFMove(insertChild), *refChild);

} else

insertNodeAfter(WTFMove(insertChild), *refChild);

}

void CompositeEditCommand::appendNode(Ref<Node>&& node, Ref<ContainerNode>&& parent)

{

ASSERT(canHaveChildrenForEditing(parent));

applyCommandToComposite(AppendNodeCommand::create(WTFMove(parent), WTFMove(node), editingAction()));

}

void CompositeEditCommand::removeChildrenInRange(Node& node, unsigned from, unsigned to)

{

Vector<Ref<Node>> children;

RefPtr child { node.traverseToChildAt(from) };

for (unsigned i = from; child && i < to; i++, child = child->nextSibling())

children.append(*child);

for (auto& child : children)

removeNode(child);

}

void CompositeEditCommand::removeNode(Node& node, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)

{

if (!node.nonShadowBoundaryParentNode())

return;

applyCommandToComposite(RemoveNodeCommand::create(node, shouldAssumeContentIsAlwaysEditable, editingAction()));

}

void CompositeEditCommand::removeNodePreservingChildren(Node& node, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)

{

applyCommandToComposite(RemoveNodePreservingChildrenCommand::create(node, shouldAssumeContentIsAlwaysEditable, editingAction()));

}

void CompositeEditCommand::removeNodeAndPruneAncestors(Node& node)

{

RefPtr parent { node.parentNode() };

removeNode(node);

prune(parent.get());

}

void CompositeEditCommand::moveRemainingSiblingsToNewParent(Node* node, Node* pastLastNodeToMove, Element& newParent)

{

NodeVector nodesToRemove;

Ref<Element> protectedNewParent = newParent;

for (; node && node != pastLastNodeToMove; node = node->nextSibling())

nodesToRemove.append(*node);

for (auto& nodeToRemove : nodesToRemove) {

removeNode(nodeToRemove);

appendNode(WTFMove(nodeToRemove), newParent);

}

}

void CompositeEditCommand::updatePositionForNodeRemovalPreservingChildren(Position& position, Node& node)

{

int offset = (position.anchorType() == Position::PositionIsOffsetInAnchor) ? position.offsetInContainerNode() : 0;

updatePositionForNodeRemoval(position, node);

if (offset)

position.moveToOffset(offset);

}

HTMLElement* CompositeEditCommand::replaceElementWithSpanPreservingChildrenAndAttributes(HTMLElement& element)

{

// It would also be possible to implement all of ReplaceNodeWithSpanCommand

// as a series of existing smaller edit commands. Someone who wanted to

// reduce the number of edit commands could do so here.

auto command = ReplaceNodeWithSpanCommand::create(element);

applyCommandToComposite(command);

// Returning a raw pointer here is OK because the command is retained by

// applyCommandToComposite (thus retaining the span), and the span is also

// in the DOM tree, and thus alive whie it has a parent.

ASSERT(command->spanElement()->isConnected());

return command->spanElement();

}

void CompositeEditCommand::prune(Node* node)

{

if (RefPtr highestNodeToRemove = highestNodeToRemoveInPruning(node))

removeNode(*highestNodeToRemove);

}

void CompositeEditCommand::splitTextNode(Text& node, unsigned offset)

{

applyCommandToComposite(SplitTextNodeCommand::create(node, offset));

}

void CompositeEditCommand::splitElement(Element& element, Node& atChild)

{

applyCommandToComposite(SplitElementCommand::create(element, atChild));

}

void CompositeEditCommand::mergeIdenticalElements(Element& first, Element& second)

{

Ref<Element> protectedFirst = first;

Ref<Element> protectedSecond = second;

ASSERT(!first.isDescendantOf(&second) && &second != &first);

if (first.nextSibling() != &second) {

removeNode(second);

insertNodeAfter(second, first);

}

applyCommandToComposite(MergeIdenticalElementsCommand::create(first, second));

}

void CompositeEditCommand::wrapContentsInDummySpan(Element& element)

{

applyCommandToComposite(WrapContentsInDummySpanCommand::create(element));

}

void CompositeEditCommand::splitTextNodeContainingElement(Text& text, unsigned offset)

{

applyCommandToComposite(SplitTextNodeContainingElementCommand::create(text, offset));

}

void CompositeEditCommand::inputText(const String& text, bool selectInsertedText)

{

unsigned offset = 0;

unsigned length = text.length();

RefPtr<ContainerNode> scope;

unsigned startIndex = indexForVisiblePosition(endingSelection().visibleStart(), scope);

size_t newline;

do {

newline = text.find('\n', offset);

if (newline != offset) {

int substringLength = newline == notFound ? length - offset : newline - offset;

applyCommandToComposite(InsertTextCommand::create(document(), text.substring(offset, substringLength), false));

}

if (newline != notFound) {

VisiblePosition caret(endingSelection().visibleStart());

if (enclosingNodeOfType(caret.deepEquivalent(), &isMailBlockquote)) {

// FIXME: Breaking a blockquote when the caret is just after a space will collapse the

// space. Modify startIndex or length to compensate for this so that the ending selection

// will be positioned correctly.

// <rdar://problem/9914462> breaking a Mail blockquote just after a space collapses the space

if (caret.previous().characterAfter() == ' ') {

if (!offset && !startIndex)

startIndex--;

else if (!length)

length--;

}

applyCommandToComposite(BreakBlockquoteCommand::create(document()));

} else

insertLineBreak();

}

offset = newline + 1;

} while (newline != notFound && offset != length);

if (selectInsertedText)

setEndingSelection(VisibleSelection(visiblePositionForIndex(startIndex, scope.get()), visiblePositionForIndex(startIndex + length, scope.get())));

}

void CompositeEditCommand::insertTextIntoNode(Text& node, unsigned offset, const String& text)

{

if (!text.isEmpty())

applyCommandToComposite(InsertIntoTextNodeCommand::create(node, offset, text, editingAction()));

}

void CompositeEditCommand::deleteTextFromNode(Text& node, unsigned offset, unsigned count)

{

applyCommandToComposite(DeleteFromTextNodeCommand::create(node, offset, count, editingAction()));

}

void CompositeEditCommand::replaceTextInNode(Text& node, unsigned offset, unsigned count, const String& replacementText)

{

applyCommandToComposite(DeleteFromTextNodeCommand::create(node, offset, count));

if (!replacementText.isEmpty())

applyCommandToComposite(InsertIntoTextNodeCommand::create(node, offset, replacementText, editingAction()));

}

Position CompositeEditCommand::replaceSelectedTextInNode(const String& text)

{

Position start = endingSelection().start();

Position end = endingSelection().end();

if (start.containerNode() != end.containerNode() || !start.containerNode()->isTextNode() || isTabSpanTextNode(start.containerNode()))

return Position();

RefPtr<Text> textNode = start.containerText();

replaceTextInNode(*textNode, start.offsetInContainerNode(), end.offsetInContainerNode() - start.offsetInContainerNode(), text);

return Position(textNode.get(), start.offsetInContainerNode() + text.length());

}

static Vector<RenderedDocumentMarker> copyMarkers(const Vector<RenderedDocumentMarker*>& markerPointers)

{

Vector<RenderedDocumentMarker> markers;

markers.reserveInitialCapacity(markerPointers.size());

for (auto& markerPointer : markerPointers)

markers.uncheckedAppend(*markerPointer);

return markers;

}

void CompositeEditCommand::replaceTextInNodePreservingMarkers(Text& node, unsigned offset, unsigned count, const String& replacementText)

{

auto range = SimpleRange { { node, offset }, { node, offset + count } };

auto markers = copyMarkers(document().markers().markersInRange(range, DocumentMarker::allMarkers()));

replaceTextInNode(node, offset, count, replacementText);

range.end.offset = range.start.offset + replacementText.length();

for (auto& marker : markers)

addMarker(range, marker.type(), marker.data());

}

Position CompositeEditCommand::positionOutsideTabSpan(const Position& position)

{

if (!isTabSpanTextNode(position.anchorNode()))

return position;

switch (position.anchorType()) {

case Position::PositionIsBeforeChildren:

case Position::PositionIsAfterChildren:

ASSERT_NOT_REACHED();

return position;

case Position::PositionIsOffsetInAnchor:

break;

case Position::PositionIsBeforeAnchor:

return positionInParentBeforeNode(position.anchorNode());

case Position::PositionIsAfterAnchor:

return positionInParentAfterNode(position.anchorNode());

}

RefPtr tabSpan { tabSpanNode(position.containerNode()) };

if (position.offsetInContainerNode() <= caretMinOffset(*position.containerNode()))

return positionInParentBeforeNode(tabSpan.get());

if (position.offsetInContainerNode() >= caretMaxOffset(*position.containerNode()))

return positionInParentAfterNode(tabSpan.get());

splitTextNodeContainingElement(downcast<Text>(*position.containerNode()), position.offsetInContainerNode());

return positionInParentBeforeNode(tabSpan.get());

}

void CompositeEditCommand::insertNodeAtTabSpanPosition(Ref<Node>&& node, const Position& pos)

{

// insert node before, after, or at split of tab span

insertNodeAt(WTFMove(node), positionOutsideTabSpan(pos));

}

static EditAction deleteSelectionEditingActionForEditingAction(EditAction editingAction)

{

switch (editingAction) {

case EditAction::Cut:

return EditAction::Cut;

default:

return EditAction::Delete;

}

}

void CompositeEditCommand::deleteSelection(bool smartDelete, bool mergeBlocksAfterDelete, bool replace, bool expandForSpecialElements, bool sanitizeMarkup)

{

if (endingSelection().isRange())

applyCommandToComposite(DeleteSelectionCommand::create(document(), smartDelete, mergeBlocksAfterDelete, replace, expandForSpecialElements, sanitizeMarkup, deleteSelectionEditingActionForEditingAction(editingAction())));

}

void CompositeEditCommand::deleteSelection(const VisibleSelection &selection, bool smartDelete, bool mergeBlocksAfterDelete, bool replace, bool expandForSpecialElements, bool sanitizeMarkup)

{

if (selection.isRange())

applyCommandToComposite(DeleteSelectionCommand::create(selection, smartDelete, mergeBlocksAfterDelete, replace, expandForSpecialElements, sanitizeMarkup));

}

void CompositeEditCommand::removeNodeAttribute(Element& element, const QualifiedName& attribute)

{

setNodeAttribute(element, attribute, nullAtom());

}

void CompositeEditCommand::setNodeAttribute(Element& element, const QualifiedName& attribute, const AtomString& value)

{

applyCommandToComposite(SetNodeAttributeCommand::create(element, attribute, value));

}

static inline bool containsOnlyDeprecatedEditingWhitespace(const String& text)

{

for (unsigned i = 0; i < text.length(); ++i) {

if (!deprecatedIsEditingWhitespace(text[i]))

return false;

}

return true;

}

bool CompositeEditCommand::shouldRebalanceLeadingWhitespaceFor(const String& text) const

{

return containsOnlyDeprecatedEditingWhitespace(text);

}

RefPtr<Text> CompositeEditCommand::textNodeForRebalance(const Position& position) const

{

RefPtr node { position.containerNode() };

if (position.anchorType() != Position::PositionIsOffsetInAnchor || !is<Text>(node))

return nullptr;

auto textNode = static_pointer_cast<Text>(std::exchange(node, nullptr));

if (!textNode->length())

return nullptr;

textNode->document().updateStyleIfNeeded();

ScriptDisallowedScope::InMainThread scriptDisallowedScope;

RenderObject* renderer = textNode->renderer();

if (renderer && !renderer->style().collapseWhiteSpace())

return nullptr;

return textNode;

}

// FIXME: Doesn't go into text nodes that contribute adjacent text (siblings, cousins, etc).

void CompositeEditCommand::rebalanceWhitespaceAt(const Position& position)

{

auto textNode = textNodeForRebalance(position);

if (!textNode)

return;

// If the rebalance is for the single offset, and neither text[offset] nor text[offset - 1] are some form of whitespace, do nothing.

int offset = position.deprecatedEditingOffset();

String text = textNode->data();

if (!deprecatedIsEditingWhitespace(text[offset])) {

offset--;

if (offset < 0 || !deprecatedIsEditingWhitespace(text[offset]))

return;

}

rebalanceWhitespaceOnTextSubstring(*textNode, position.offsetInContainerNode(), position.offsetInContainerNode());

}

void CompositeEditCommand::rebalanceWhitespaceOnTextSubstring(Text& textNode, int startOffset, int endOffset)

{

String text = textNode.data();

ASSERT(!text.isEmpty());

// Set upstream and downstream to define the extent of the whitespace surrounding text[offset].

unsigned upstream = std::max(0, startOffset);

while (upstream > 0 && deprecatedIsEditingWhitespace(text[upstream - 1]))

upstream--;

unsigned downstream = std::max(0, endOffset);

while (downstream < text.length() && deprecatedIsEditingWhitespace(text[downstream]))

downstream++;

int length = downstream - upstream;

if (!length)

return;

VisiblePosition visibleUpstreamPos(Position(&textNode, upstream));

VisiblePosition visibleDownstreamPos(Position(&textNode, downstream));

String string = text.substring(upstream, length);

// FIXME: Because of the problem mentioned at the top of this function, we must also use nbsps at the start/end of the string because

// this function doesn't get all surrounding whitespace, just the whitespace in the current text node.

String rebalancedString = stringWithRebalancedWhitespace(string, isStartOfParagraph(visibleUpstreamPos) || !upstream,

isEndOfParagraph(visibleDownstreamPos) || downstream == text.length());

if (string != rebalancedString)

replaceTextInNodePreservingMarkers(textNode, upstream, length, rebalancedString);

}

void CompositeEditCommand::prepareWhitespaceAtPositionForSplit(Position& position)

{

RefPtr node { position.deprecatedNode() };

if (!is<Text>(node))

return;

Text& textNode = downcast<Text>(*node);

if (!textNode.length())

return;

{

ScriptDisallowedScope::InMainThread scriptDisallowedScope;

RenderObject* renderer = textNode.renderer();

if (renderer && !renderer->style().collapseWhiteSpace())

return;

}

// Delete collapsed whitespace so that inserting nbsps doesn't uncollapse it.

Position upstreamPos = position.upstream();

deleteInsignificantText(position.upstream(), position.downstream());

position = upstreamPos.downstream();

VisiblePosition visiblePos(position);

VisiblePosition previousVisiblePos(visiblePos.previous());

Position previous(previousVisiblePos.deepEquivalent());

if (deprecatedIsCollapsibleWhitespace(previousVisiblePos.characterAfter()) && is<Text>(*previous.deprecatedNode()) && !is<HTMLBRElement>(*previous.deprecatedNode()))

replaceTextInNodePreservingMarkers(downcast<Text>(*previous.deprecatedNode()), previous.deprecatedEditingOffset(), 1, nonBreakingSpaceString());

if (deprecatedIsCollapsibleWhitespace(visiblePos.characterAfter()) && is<Text>(*position.deprecatedNode()) && !is<HTMLBRElement>(*position.deprecatedNode()))

replaceTextInNodePreservingMarkers(downcast<Text>(*position.deprecatedNode()), position.deprecatedEditingOffset(), 1, nonBreakingSpaceString());

}

void CompositeEditCommand::rebalanceWhitespace()

{

VisibleSelection selection = endingSelection();

if (selection.isNone())

return;

rebalanceWhitespaceAt(selection.start());

if (selection.isRange())