Source/core/editing/DeleteSelectionCommand.cpp - Issue 1294543005: Move execCommand related files in core/editing/ related files into core/editing/commands/

Unified Diff: Source/core/editing/DeleteSelectionCommand.cpp

Issue 1294543005: Move execCommand related files in core/editing/ related files into core/editing/commands/ (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master

Patch Set: 2015-08-17T17:57:33 Created 5 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: Source/core/editing/DeleteSelectionCommand.cpp

diff --git a/Source/core/editing/DeleteSelectionCommand.cpp b/Source/core/editing/DeleteSelectionCommand.cpp

deleted file mode 100644

index 58ad9c54fe5092a0e14befa45989e0093b3dd788..0000000000000000000000000000000000000000

--- a/Source/core/editing/DeleteSelectionCommand.cpp

+++ /dev/null

@@ -1,900 +0,0 @@

-/*

- *

- * 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 COMPUTER, 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 COMPUTER, 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 "core/editing/DeleteSelectionCommand.h"

-#include "core/HTMLNames.h"

-#include "core/dom/Document.h"

-#include "core/dom/Element.h"

-#include "core/dom/NodeTraversal.h"

-#include "core/dom/Text.h"

-#include "core/editing/EditingBoundary.h"

-#include "core/editing/EditingUtilities.h"

-#include "core/editing/Editor.h"

-#include "core/editing/VisibleUnits.h"

-#include "core/frame/LocalFrame.h"

-#include "core/html/HTMLBRElement.h"

-#include "core/html/HTMLInputElement.h"

-#include "core/html/HTMLStyleElement.h"

-#include "core/html/HTMLTableRowElement.h"

-#include "core/layout/LayoutTableCell.h"

-#include "core/layout/LayoutText.h"

-namespace blink {

-using namespace HTMLNames;

-static bool isTableCellEmpty(Node* cell)

- ASSERT(isTableCell(cell));

- return VisiblePosition(firstPositionInNode(cell)).deepEquivalent() == VisiblePosition(lastPositionInNode(cell)).deepEquivalent();

-static bool isTableRowEmpty(Node* row)

- if (!isHTMLTableRowElement(row))

- return false;

- for (Node* child = row->firstChild(); child; child = child->nextSibling())

- if (isTableCell(child) && !isTableCellEmpty(child))

- return false;

- return true;

-DeleteSelectionCommand::DeleteSelectionCommand(Document& document, bool smartDelete, bool mergeBlocksAfterDelete, bool expandForSpecialElements, bool sanitizeMarkup)

- : CompositeEditCommand(document)

- , m_hasSelectionToDelete(false)

- , m_smartDelete(smartDelete)

- , m_mergeBlocksAfterDelete(mergeBlocksAfterDelete)

- , m_needPlaceholder(false)

- , m_expandForSpecialElements(expandForSpecialElements)

- , m_pruneStartBlockIfNecessary(false)

- , m_startsAtEmptyLine(false)

- , m_sanitizeMarkup(sanitizeMarkup)

- , m_startBlock(nullptr)

- , m_endBlock(nullptr)

- , m_typingStyle(nullptr)

- , m_deleteIntoBlockquoteStyle(nullptr)

-DeleteSelectionCommand::DeleteSelectionCommand(const VisibleSelection& selection, bool smartDelete, bool mergeBlocksAfterDelete, bool expandForSpecialElements, bool sanitizeMarkup)

- : CompositeEditCommand(*selection.start().document())

- , m_hasSelectionToDelete(true)

- , m_smartDelete(smartDelete)

- , m_mergeBlocksAfterDelete(mergeBlocksAfterDelete)

- , m_needPlaceholder(false)

- , m_expandForSpecialElements(expandForSpecialElements)

- , m_pruneStartBlockIfNecessary(false)

- , m_startsAtEmptyLine(false)

- , m_sanitizeMarkup(sanitizeMarkup)

- , m_selectionToDelete(selection)

- , m_startBlock(nullptr)

- , m_endBlock(nullptr)

- , m_typingStyle(nullptr)

- , m_deleteIntoBlockquoteStyle(nullptr)

-void DeleteSelectionCommand::initializeStartEnd(Position& start, Position& end)

- HTMLElement* startSpecialContainer = nullptr;

- HTMLElement* endSpecialContainer = nullptr;

- start = m_selectionToDelete.start();

- end = m_selectionToDelete.end();

- // For HRs, we'll get a position at (HR,1) when hitting delete from the beginning of the previous line, or (HR,0) when forward deleting,

- // but in these cases, we want to delete it, so manually expand the selection

- if (isHTMLHRElement(*start.anchorNode()))

- start = positionBeforeNode(start.anchorNode());

- else if (isHTMLHRElement(*end.anchorNode()))

- end = positionAfterNode(end.anchorNode());

- // FIXME: This is only used so that moveParagraphs can avoid the bugs in special element expansion.

- if (!m_expandForSpecialElements)

- return;

- while (1) {

- startSpecialContainer = 0;

- endSpecialContainer = 0;

- Position s = positionBeforeContainingSpecialElement(start, &startSpecialContainer);

- Position e = positionAfterContainingSpecialElement(end, &endSpecialContainer);

- if (!startSpecialContainer && !endSpecialContainer)

- break;

- if (VisiblePosition(start).deepEquivalent() != m_selectionToDelete.visibleStart().deepEquivalent() || VisiblePosition(end).deepEquivalent() != m_selectionToDelete.visibleEnd().deepEquivalent())

- break;

- // If we're going to expand to include the startSpecialContainer, it must be fully selected.

- if (startSpecialContainer && !endSpecialContainer && comparePositions(positionInParentAfterNode(*startSpecialContainer), end) > -1)

- break;

- // If we're going to expand to include the endSpecialContainer, it must be fully selected.

- if (endSpecialContainer && !startSpecialContainer && comparePositions(start, positionInParentBeforeNode(*endSpecialContainer)) > -1)

- break;

- if (startSpecialContainer && startSpecialContainer->isDescendantOf(endSpecialContainer))

- // Don't adjust the end yet, it is the end of a special element that contains the start

- // special element (which may or may not be fully selected).

- start = s;

- else if (endSpecialContainer && endSpecialContainer->isDescendantOf(startSpecialContainer))

- // Don't adjust the start yet, it is the start of a special element that contains the end

- // special element (which may or may not be fully selected).

- end = e;

- else {

- start = s;

- end = e;

- }

-void DeleteSelectionCommand::setStartingSelectionOnSmartDelete(const Position& start, const Position& end)

- bool isBaseFirst = startingSelection().isBaseFirst();

- VisiblePosition newBase(isBaseFirst ? start : end);

- VisiblePosition newExtent(isBaseFirst ? end : start);

- setStartingSelection(VisibleSelection(newBase, newExtent, startingSelection().isDirectional()));

-void DeleteSelectionCommand::initializePositionData()

- Position start, end;

- initializeStartEnd(start, end);

- ASSERT(isEditablePosition(start, ContentIsEditable, DoNotUpdateStyle));

- if (!isEditablePosition(end, ContentIsEditable, DoNotUpdateStyle))

- end = lastEditablePositionBeforePositionInRoot(end, highestEditableRoot(start));

- m_upstreamStart = start.upstream();

- m_downstreamStart = start.downstream();

- m_upstreamEnd = end.upstream();

- m_downstreamEnd = end.downstream();

- m_startRoot = editableRootForPosition(start);

- m_endRoot = editableRootForPosition(end);

- m_startTableRow = toHTMLTableRowElement(enclosingNodeOfType(start, &isHTMLTableRowElement));

- m_endTableRow = toHTMLTableRowElement(enclosingNodeOfType(end, &isHTMLTableRowElement));

- // Don't move content out of a table cell.

- // If the cell is non-editable, enclosingNodeOfType won't return it by default, so

- // tell that function that we don't care if it returns non-editable nodes.

- Node* startCell = enclosingNodeOfType(m_upstreamStart, &isTableCell, CanCrossEditingBoundary);

- Node* endCell = enclosingNodeOfType(m_downstreamEnd, &isTableCell, CanCrossEditingBoundary);

- // FIXME: This isn't right. A borderless table with two rows and a single column would appear as two paragraphs.

- if (endCell && endCell != startCell)

- m_mergeBlocksAfterDelete = false;

- // Usually the start and the end of the selection to delete are pulled together as a result of the deletion.

- // Sometimes they aren't (like when no merge is requested), so we must choose one position to hold the caret

- // and receive the placeholder after deletion.

- VisiblePosition visibleEnd(m_downstreamEnd);

- if (m_mergeBlocksAfterDelete && !isEndOfParagraph(visibleEnd))

- m_endingPosition = m_downstreamEnd;

- else

- m_endingPosition = m_downstreamStart;

- // We don't want to merge into a block if it will mean changing the quote level of content after deleting

- // selections that contain a whole number paragraphs plus a line break, since it is unclear to most users

- // that such a selection actually ends at the start of the next paragraph. This matches TextEdit behavior

- // for indented paragraphs.

- // Only apply this rule if the endingSelection is a range selection. If it is a caret, then other operations have created

- // the selection we're deleting (like the process of creating a selection to delete during a backspace), and the user isn't in the situation described above.

- if (numEnclosingMailBlockquotes(start) != numEnclosingMailBlockquotes(end)

- && isStartOfParagraph(visibleEnd) && isStartOfParagraph(VisiblePosition(start))

- && endingSelection().isRange()) {

- m_mergeBlocksAfterDelete = false;

- m_pruneStartBlockIfNecessary = true;

- }

- // Handle leading and trailing whitespace, as well as smart delete adjustments to the selection

- m_leadingWhitespace = leadingWhitespacePosition(m_upstreamStart, m_selectionToDelete.affinity());

- m_trailingWhitespace = trailingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY);

- if (m_smartDelete) {

- // skip smart delete if the selection to delete already starts or ends with whitespace

- Position pos = VisiblePosition(m_upstreamStart, m_selectionToDelete.affinity()).deepEquivalent();

- bool skipSmartDelete = trailingWhitespacePosition(pos, VP_DEFAULT_AFFINITY, ConsiderNonCollapsibleWhitespace).isNotNull();

- if (!skipSmartDelete)

- skipSmartDelete = leadingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY, ConsiderNonCollapsibleWhitespace).isNotNull();

- // extend selection upstream if there is whitespace there

- bool hasLeadingWhitespaceBeforeAdjustment = leadingWhitespacePosition(m_upstreamStart, m_selectionToDelete.affinity(), ConsiderNonCollapsibleWhitespace).isNotNull();

- if (!skipSmartDelete && hasLeadingWhitespaceBeforeAdjustment) {

- VisiblePosition visiblePos = VisiblePosition(m_upstreamStart, VP_DEFAULT_AFFINITY).previous();

- pos = visiblePos.deepEquivalent();

- // Expand out one character upstream for smart delete and recalculate

- // positions based on this change.

- m_upstreamStart = pos.upstream();

- m_downstreamStart = pos.downstream();

- m_leadingWhitespace = leadingWhitespacePosition(m_upstreamStart, visiblePos.affinity());

- setStartingSelectionOnSmartDelete(m_upstreamStart, m_upstreamEnd);

- }

- // trailing whitespace is only considered for smart delete if there is no leading

- // whitespace, as in the case where you double-click the first word of a paragraph.

- if (!skipSmartDelete && !hasLeadingWhitespaceBeforeAdjustment && trailingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY, ConsiderNonCollapsibleWhitespace).isNotNull()) {

- // Expand out one character downstream for smart delete and recalculate

- // positions based on this change.

- pos = VisiblePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY).next().deepEquivalent();

- m_upstreamEnd = pos.upstream();

- m_downstreamEnd = pos.downstream();

- m_trailingWhitespace = trailingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY);

- setStartingSelectionOnSmartDelete(m_downstreamStart, m_downstreamEnd);

- }

- // We must pass call parentAnchoredEquivalent on the positions since some editing positions

- // that appear inside their nodes aren't really inside them. [hr, 0] is one example.

- // FIXME: parentAnchoredEquivalent should eventually be moved into enclosing element getters

- // like the one below, since editing functions should obviously accept editing positions.

- // FIXME: Passing false to enclosingNodeOfType tells it that it's OK to return a non-editable

- // node. This was done to match existing behavior, but it seems wrong.

- m_startBlock = enclosingNodeOfType(m_downstreamStart.parentAnchoredEquivalent(), &isBlock, CanCrossEditingBoundary);

- m_endBlock = enclosingNodeOfType(m_upstreamEnd.parentAnchoredEquivalent(), &isBlock, CanCrossEditingBoundary);

-// We don't want to inherit style from an element which can't have contents.

-static bool shouldNotInheritStyleFrom(const Node& node)

- return !node.canContainRangeEndPoint();

-void DeleteSelectionCommand::saveTypingStyleState()

- // A common case is deleting characters that are all from the same text node. In

- // that case, the style at the start of the selection before deletion will be the

- // same as the style at the start of the selection after deletion (since those

- // two positions will be identical). Therefore there is no need to save the

- // typing style at the start of the selection, nor is there a reason to

- // compute the style at the start of the selection after deletion (see the

- // early return in calculateTypingStyleAfterDelete).

- if (m_upstreamStart.anchorNode() == m_downstreamEnd.anchorNode() && m_upstreamStart.anchorNode()->isTextNode())

- return;

- if (shouldNotInheritStyleFrom(*m_selectionToDelete.start().anchorNode()))

- return;

- // Figure out the typing style in effect before the delete is done.

- m_typingStyle = EditingStyle::create(m_selectionToDelete.start(), EditingStyle::EditingPropertiesInEffect);

- m_typingStyle->removeStyleAddedByElement(enclosingAnchorElement(m_selectionToDelete.start()));

- // If we're deleting into a Mail blockquote, save the style at end() instead of start()

- // We'll use this later in computeTypingStyleAfterDelete if we end up outside of a Mail blockquote

- if (enclosingNodeOfType(m_selectionToDelete.start(), isMailHTMLBlockquoteElement))

- m_deleteIntoBlockquoteStyle = EditingStyle::create(m_selectionToDelete.end());

- else

- m_deleteIntoBlockquoteStyle = nullptr;

-bool DeleteSelectionCommand::handleSpecialCaseBRDelete()

- Node* nodeAfterUpstreamStart = m_upstreamStart.computeNodeAfterPosition();

- Node* nodeAfterDownstreamStart = m_downstreamStart.computeNodeAfterPosition();

- // Upstream end will appear before BR due to canonicalization

- Node* nodeAfterUpstreamEnd = m_upstreamEnd.computeNodeAfterPosition();

- if (!nodeAfterUpstreamStart || !nodeAfterDownstreamStart)

- return false;

- // Check for special-case where the selection contains only a BR on a line by itself after another BR.

- bool upstreamStartIsBR = isHTMLBRElement(*nodeAfterUpstreamStart);

- bool downstreamStartIsBR = isHTMLBRElement(*nodeAfterDownstreamStart);

- bool isBROnLineByItself = upstreamStartIsBR && downstreamStartIsBR && nodeAfterDownstreamStart == nodeAfterUpstreamEnd;

- if (isBROnLineByItself) {

- removeNode(nodeAfterDownstreamStart);

- return true;

- }

- // FIXME: This code doesn't belong in here.

- // We detect the case where the start is an empty line consisting of BR not wrapped in a block element.

- if (upstreamStartIsBR && downstreamStartIsBR && !(isStartOfBlock(VisiblePosition(positionBeforeNode(nodeAfterUpstreamStart))) && isEndOfBlock(VisiblePosition(positionAfterNode(nodeAfterUpstreamStart))))) {

- m_startsAtEmptyLine = true;

- m_endingPosition = m_downstreamEnd;

- }

- return false;

-static Position firstEditablePositionInNode(Node* node)

- ASSERT(node);

- Node* next = node;

- while (next && !next->hasEditableStyle())

- next = NodeTraversal::next(*next, node);

- return next ? firstPositionInOrBeforeNode(next) : Position();

-void DeleteSelectionCommand::removeNode(PassRefPtrWillBeRawPtr<Node> node, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)

- if (!node)

- return;

- if (m_startRoot != m_endRoot && !(node->isDescendantOf(m_startRoot.get()) && node->isDescendantOf(m_endRoot.get()))) {

- // If a node is not in both the start and end editable roots, remove it only if its inside an editable region.

- if (!node->parentNode()->hasEditableStyle()) {

- // Don't remove non-editable atomic nodes.

- if (!node->hasChildren())

- return;

- // Search this non-editable region for editable regions to empty.

- RefPtrWillBeRawPtr<Node> child = node->firstChild();

- while (child) {

- RefPtrWillBeRawPtr<Node> nextChild = child->nextSibling();

- removeNode(child.get(), shouldAssumeContentIsAlwaysEditable);

- // Bail if nextChild is no longer node's child.

- if (nextChild && nextChild->parentNode() != node)

- return;

- child = nextChild;

- }

- // Don't remove editable regions that are inside non-editable ones, just clear them.

- return;

- }

- if (isTableStructureNode(node.get()) || node->isRootEditableElement()) {

- // Do not remove an element of table structure; remove its contents.

- // Likewise for the root editable element.

- Node* child = node->firstChild();

- while (child) {

- Node* remove = child;

- child = child->nextSibling();

- removeNode(remove, shouldAssumeContentIsAlwaysEditable);

- }

- // Make sure empty cell has some height, if a placeholder can be inserted.

- document().updateLayoutIgnorePendingStylesheets();

- LayoutObject* r = node->layoutObject();

- if (r && r->isTableCell() && toLayoutTableCell(r)->contentHeight() <= 0) {

- Position firstEditablePosition = firstEditablePositionInNode(node.get());

- if (firstEditablePosition.isNotNull())

- insertBlockPlaceholder(firstEditablePosition);

- }

- return;

- }

- if (node == m_startBlock) {

- VisiblePosition previous = VisiblePosition(firstPositionInNode(m_startBlock.get())).previous();

- if (previous.isNotNull() && !isEndOfBlock(previous))

- m_needPlaceholder = true;

- }

- if (node == m_endBlock) {

- VisiblePosition next = VisiblePosition(lastPositionInNode(m_endBlock.get())).next();

- if (next.isNotNull() && !isStartOfBlock(next))

- m_needPlaceholder = true;

- }

- // FIXME: Update the endpoints of the range being deleted.

- updatePositionForNodeRemoval(m_endingPosition, *node);

- updatePositionForNodeRemoval(m_leadingWhitespace, *node);

- updatePositionForNodeRemoval(m_trailingWhitespace, *node);

- CompositeEditCommand::removeNode(node, shouldAssumeContentIsAlwaysEditable);

-static void updatePositionForTextRemoval(Text* node, int offset, int count, Position& position)

- if (!position.isOffsetInAnchor() || position.computeContainerNode() != node)

- return;

- if (position.offsetInContainerNode() > offset + count)

- position = Position(position.computeContainerNode(), position.offsetInContainerNode() - count);

- else if (position.offsetInContainerNode() > offset)

- position = Position(position.computeContainerNode(), offset);

-void DeleteSelectionCommand::deleteTextFromNode(PassRefPtrWillBeRawPtr<Text> node, unsigned offset, unsigned count)

- // FIXME: Update the endpoints of the range being deleted.

- updatePositionForTextRemoval(node.get(), offset, count, m_endingPosition);

- updatePositionForTextRemoval(node.get(), offset, count, m_leadingWhitespace);

- updatePositionForTextRemoval(node.get(), offset, count, m_trailingWhitespace);

- updatePositionForTextRemoval(node.get(), offset, count, m_downstreamEnd);

- CompositeEditCommand::deleteTextFromNode(node, offset, count);

-void DeleteSelectionCommand::makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss()

- RefPtrWillBeRawPtr<Range> range = m_selectionToDelete.toNormalizedRange();

- RefPtrWillBeRawPtr<Node> node = range->firstNode();

- while (node && node != range->pastLastNode()) {

- RefPtrWillBeRawPtr<Node> nextNode = NodeTraversal::next(*node);

- if (isHTMLStyleElement(*node) || isHTMLLinkElement(*node)) {

- nextNode = NodeTraversal::nextSkippingChildren(*node);

- RefPtrWillBeRawPtr<Element> rootEditableElement = node->rootEditableElement();

- if (rootEditableElement.get()) {

- removeNode(node);

- appendNode(node, rootEditableElement);

- }

- node = nextNode;

- }

-void DeleteSelectionCommand::handleGeneralDelete()

- if (m_upstreamStart.isNull())

- return;

- int startOffset = m_upstreamStart.computeEditingOffset();

- Node* startNode = m_upstreamStart.anchorNode();

- ASSERT(startNode);

- makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss();

- // Never remove the start block unless it's a table, in which case we won't merge content in.

- if (startNode->isSameNode(m_startBlock.get()) && !startOffset && canHaveChildrenForEditing(startNode) && !isHTMLTableElement(*startNode)) {

- startOffset = 0;

- startNode = NodeTraversal::next(*startNode);

- if (!startNode)

- return;

- }

- if (startOffset >= caretMaxOffset(startNode) && startNode->isTextNode()) {

- Text* text = toText(startNode);

- if (text->length() > (unsigned)caretMaxOffset(startNode))

- deleteTextFromNode(text, caretMaxOffset(startNode), text->length() - caretMaxOffset(startNode));

- }

- if (startOffset >= EditingStrategy::lastOffsetForEditing(startNode)) {

- startNode = NodeTraversal::nextSkippingChildren(*startNode);

- startOffset = 0;

- }

- // Done adjusting the start. See if we're all done.

- if (!startNode)

- return;

- if (startNode == m_downstreamEnd.anchorNode()) {

- if (m_downstreamEnd.computeEditingOffset() - startOffset > 0) {

- if (startNode->isTextNode()) {

- // in a text node that needs to be trimmed

- Text* text = toText(startNode);

- deleteTextFromNode(text, startOffset, m_downstreamEnd.computeOffsetInContainerNode() - startOffset);

- } else {

- removeChildrenInRange(startNode, startOffset, m_downstreamEnd.computeEditingOffset());

- m_endingPosition = m_upstreamStart;

- }

- // The selection to delete is all in one node.

- if (!startNode->layoutObject() || (!startOffset && m_downstreamEnd.atLastEditingPositionForNode()))

- removeNode(startNode);

- }

- else {

- bool startNodeWasDescendantOfEndNode = m_upstreamStart.anchorNode()->isDescendantOf(m_downstreamEnd.anchorNode());

- // The selection to delete spans more than one node.

- RefPtrWillBeRawPtr<Node> node(startNode);

- if (startOffset > 0) {

- if (startNode->isTextNode()) {

- // in a text node that needs to be trimmed

- Text* text = toText(node);

- deleteTextFromNode(text, startOffset, text->length() - startOffset);

- node = NodeTraversal::next(*node);

- } else {

- node = NodeTraversal::childAt(*startNode, startOffset);

- }

- } else if (startNode == m_upstreamEnd.anchorNode() && startNode->isTextNode()) {

- Text* text = toText(m_upstreamEnd.anchorNode());

- deleteTextFromNode(text, 0, m_upstreamEnd.computeOffsetInContainerNode());

- }

- // handle deleting all nodes that are completely selected

- while (node && node != m_downstreamEnd.anchorNode()) {

- if (comparePositions(firstPositionInOrBeforeNode(node.get()), m_downstreamEnd) >= 0) {

- // NodeTraversal::nextSkippingChildren just blew past the end position, so stop deleting

- node = nullptr;

- } else if (!m_downstreamEnd.anchorNode()->isDescendantOf(node.get())) {

- RefPtrWillBeRawPtr<Node> nextNode = NodeTraversal::nextSkippingChildren(*node);

- // if we just removed a node from the end container, update end position so the

- // check above will work

- updatePositionForNodeRemoval(m_downstreamEnd, *node);

- removeNode(node.get());

- node = nextNode.get();

- } else {

- Node& n = NodeTraversal::lastWithinOrSelf(*node);

- if (m_downstreamEnd.anchorNode() == n && m_downstreamEnd.computeEditingOffset() >= caretMaxOffset(&n)) {

- removeNode(node.get());

- node = nullptr;

- } else {

- node = NodeTraversal::next(*node);

- }

- if (m_downstreamEnd.anchorNode() != startNode && !m_upstreamStart.anchorNode()->isDescendantOf(m_downstreamEnd.anchorNode()) && m_downstreamEnd.inDocument() && m_downstreamEnd.computeEditingOffset() >= caretMinOffset(m_downstreamEnd.anchorNode())) {

- if (m_downstreamEnd.atLastEditingPositionForNode() && !canHaveChildrenForEditing(m_downstreamEnd.anchorNode())) {

- // The node itself is fully selected, not just its contents. Delete it.

- removeNode(m_downstreamEnd.anchorNode());

- } else {

- if (m_downstreamEnd.anchorNode()->isTextNode()) {

- // in a text node that needs to be trimmed

- Text* text = toText(m_downstreamEnd.anchorNode());

- if (m_downstreamEnd.computeEditingOffset() > 0) {

- deleteTextFromNode(text, 0, m_downstreamEnd.computeEditingOffset());

- }

- // Remove children of m_downstreamEnd.anchorNode() that come after m_upstreamStart.

- // Don't try to remove children if m_upstreamStart was inside m_downstreamEnd.anchorNode()

- // and m_upstreamStart has been removed from the document, because then we don't

- // know how many children to remove.

- // FIXME: Make m_upstreamStart a position we update as we remove content, then we can

- // always know which children to remove.

- } else if (!(startNodeWasDescendantOfEndNode && !m_upstreamStart.inDocument())) {

- int offset = 0;

- if (m_upstreamStart.anchorNode()->isDescendantOf(m_downstreamEnd.anchorNode())) {

- Node* n = m_upstreamStart.anchorNode();

- while (n && n->parentNode() != m_downstreamEnd.anchorNode())

- n = n->parentNode();

- if (n)

- offset = n->nodeIndex() + 1;

- }

- removeChildrenInRange(m_downstreamEnd.anchorNode(), offset, m_downstreamEnd.computeEditingOffset());

- m_downstreamEnd = createLegacyEditingPosition(m_downstreamEnd.anchorNode(), offset);

- }

-void DeleteSelectionCommand::fixupWhitespace()

- document().updateLayoutIgnorePendingStylesheets();

- // FIXME: isRenderedCharacter should be removed, and we should use VisiblePosition::characterAfter and VisiblePosition::characterBefore

- if (m_leadingWhitespace.isNotNull() && !m_leadingWhitespace.isRenderedCharacter() && m_leadingWhitespace.anchorNode()->isTextNode()) {

- Text* textNode = toText(m_leadingWhitespace.anchorNode());

- ASSERT(!textNode->layoutObject() || textNode->layoutObject()->style()->collapseWhiteSpace());

- replaceTextInNodePreservingMarkers(textNode, m_leadingWhitespace.computeOffsetInContainerNode(), 1, nonBreakingSpaceString());

- }

- if (m_trailingWhitespace.isNotNull() && !m_trailingWhitespace.isRenderedCharacter() && m_trailingWhitespace.anchorNode()->isTextNode()) {

- Text* textNode = toText(m_trailingWhitespace.anchorNode());

- ASSERT(!textNode->layoutObject() || textNode->layoutObject()->style()->collapseWhiteSpace());

- replaceTextInNodePreservingMarkers(textNode, m_trailingWhitespace.computeOffsetInContainerNode(), 1, nonBreakingSpaceString());

- }

-// If a selection starts in one block and ends in another, we have to merge to bring content before the

-// start together with content after the end.

-void DeleteSelectionCommand::mergeParagraphs()

- if (!m_mergeBlocksAfterDelete) {

- if (m_pruneStartBlockIfNecessary) {

- // We aren't going to merge into the start block, so remove it if it's empty.

- prune(m_startBlock);

- // Removing the start block during a deletion is usually an indication that we need

- // a placeholder, but not in this case.

- m_needPlaceholder = false;

- }

- return;

- }

- // It shouldn't have been asked to both try and merge content into the start block and prune it.

- ASSERT(!m_pruneStartBlockIfNecessary);

- // FIXME: Deletion should adjust selection endpoints as it removes nodes so that we never get into this state (4099839).

- if (!m_downstreamEnd.inDocument() || !m_upstreamStart.inDocument())

- return;

- // FIXME: The deletion algorithm shouldn't let this happen.

- if (comparePositions(m_upstreamStart, m_downstreamEnd) > 0)

- return;

- // There's nothing to merge.

- if (m_upstreamStart == m_downstreamEnd)

- return;

- VisiblePosition startOfParagraphToMove(m_downstreamEnd);

- VisiblePosition mergeDestination(m_upstreamStart);

- // m_downstreamEnd's block has been emptied out by deletion. There is no content inside of it to

- // move, so just remove it.

- Element* endBlock = enclosingBlock(m_downstreamEnd.anchorNode());

- if (!endBlock || !endBlock->contains(startOfParagraphToMove.deepEquivalent().anchorNode()) || !startOfParagraphToMove.deepEquivalent().anchorNode()) {

- removeNode(enclosingBlock(m_downstreamEnd.anchorNode()));

- return;

- }

- // We need to merge into m_upstreamStart's block, but it's been emptied out and collapsed by deletion.

- if (!mergeDestination.deepEquivalent().anchorNode() || (!mergeDestination.deepEquivalent().anchorNode()->isDescendantOf(enclosingBlock(m_upstreamStart.computeContainerNode())) && (!mergeDestination.deepEquivalent().anchorNode()->hasChildren() || !m_upstreamStart.computeContainerNode()->hasChildren())) || (m_startsAtEmptyLine && mergeDestination.deepEquivalent() != startOfParagraphToMove.deepEquivalent())) {

- insertNodeAt(createBreakElement(document()).get(), m_upstreamStart);

- mergeDestination = VisiblePosition(m_upstreamStart);

- }

- if (mergeDestination.deepEquivalent() == startOfParagraphToMove.deepEquivalent())

- return;

- VisiblePosition endOfParagraphToMove = endOfParagraph(startOfParagraphToMove, CanSkipOverEditingBoundary);

- if (mergeDestination.deepEquivalent() == endOfParagraphToMove.deepEquivalent())

- return;

- // If the merge destination and source to be moved are both list items of different lists, merge them into single list.

- Node* listItemInFirstParagraph = enclosingNodeOfType(m_upstreamStart, isListItem);

- Node* listItemInSecondParagraph = enclosingNodeOfType(m_downstreamEnd, isListItem);

- if (listItemInFirstParagraph && listItemInSecondParagraph

- && listItemInFirstParagraph->parentElement() != listItemInSecondParagraph->parentElement()

- && canMergeLists(listItemInFirstParagraph->parentElement(), listItemInSecondParagraph->parentElement())) {

- mergeIdenticalElements(listItemInFirstParagraph->parentElement(), listItemInSecondParagraph->parentElement());

- m_endingPosition = mergeDestination.deepEquivalent();

- return;

- }

- // The rule for merging into an empty block is: only do so if its farther to the right.

- // FIXME: Consider RTL.

- if (!m_startsAtEmptyLine && isStartOfParagraph(mergeDestination) && startOfParagraphToMove.absoluteCaretBounds().x() > mergeDestination.absoluteCaretBounds().x()) {

- if (isHTMLBRElement(*mergeDestination.deepEquivalent().downstream().anchorNode())) {

- removeNodeAndPruneAncestors(mergeDestination.deepEquivalent().downstream().anchorNode());

- m_endingPosition = startOfParagraphToMove.deepEquivalent();

- return;

- }

- // Block images, tables and horizontal rules cannot be made inline with content at mergeDestination. If there is

- // any (!isStartOfParagraph(mergeDestination)), don't merge, just move the caret to just before the selection we deleted.

- // See https://bugs.webkit.org/show_bug.cgi?id=25439

- if (isRenderedAsNonInlineTableImageOrHR(startOfParagraphToMove.deepEquivalent().anchorNode()) && !isStartOfParagraph(mergeDestination)) {

- m_endingPosition = m_upstreamStart;

- return;

- }

- // moveParagraphs will insert placeholders if it removes blocks that would require their use, don't let block

- // removals that it does cause the insertion of *another* placeholder.

- bool needPlaceholder = m_needPlaceholder;

- bool paragraphToMergeIsEmpty = startOfParagraphToMove.deepEquivalent() == endOfParagraphToMove.deepEquivalent();

- moveParagraph(startOfParagraphToMove, endOfParagraphToMove, mergeDestination, false, !paragraphToMergeIsEmpty);

- m_needPlaceholder = needPlaceholder;

- // The endingPosition was likely clobbered by the move, so recompute it (moveParagraph selects the moved paragraph).

- m_endingPosition = endingSelection().start();

-void DeleteSelectionCommand::removePreviouslySelectedEmptyTableRows()

- if (m_endTableRow && m_endTableRow->inDocument() && m_endTableRow != m_startTableRow) {

- Node* row = m_endTableRow->previousSibling();

- while (row && row != m_startTableRow) {

- RefPtrWillBeRawPtr<Node> previousRow = row->previousSibling();

- if (isTableRowEmpty(row))

- // Use a raw removeNode, instead of DeleteSelectionCommand's, because

- // that won't remove rows, it only empties them in preparation for this function.

- CompositeEditCommand::removeNode(row);

- row = previousRow.get();

- }

- // Remove empty rows after the start row.

- if (m_startTableRow && m_startTableRow->inDocument() && m_startTableRow != m_endTableRow) {

- Node* row = m_startTableRow->nextSibling();

- while (row && row != m_endTableRow) {

- RefPtrWillBeRawPtr<Node> nextRow = row->nextSibling();

- if (isTableRowEmpty(row))

- CompositeEditCommand::removeNode(row);

- row = nextRow.get();

- }

- if (m_endTableRow && m_endTableRow->inDocument() && m_endTableRow != m_startTableRow)

- if (isTableRowEmpty(m_endTableRow.get())) {

- // Don't remove m_endTableRow if it's where we're putting the ending selection.

- if (!m_endingPosition.anchorNode()->isDescendantOf(m_endTableRow.get())) {

- // FIXME: We probably shouldn't remove m_endTableRow unless it's fully selected, even if it is empty.

- // We'll need to start adjusting the selection endpoints during deletion to know whether or not m_endTableRow

- // was fully selected here.

- CompositeEditCommand::removeNode(m_endTableRow.get());

- }

-void DeleteSelectionCommand::calculateTypingStyleAfterDelete()

- // Clearing any previously set typing style and doing an early return.

- if (!m_typingStyle) {

- document().frame()->selection().clearTypingStyle();

- return;

- }

- // Compute the difference between the style before the delete and the style now

- // after the delete has been done. Set this style on the frame, so other editing

- // commands being composed with this one will work, and also cache it on the command,

- // so the LocalFrame::appliedEditing can set it after the whole composite command

- // has completed.

- // If we deleted into a blockquote, but are now no longer in a blockquote, use the alternate typing style

- if (m_deleteIntoBlockquoteStyle && !enclosingNodeOfType(m_endingPosition, isMailHTMLBlockquoteElement, CanCrossEditingBoundary))

- m_typingStyle = m_deleteIntoBlockquoteStyle;

- m_deleteIntoBlockquoteStyle = nullptr;

- m_typingStyle->prepareToApplyAt(m_endingPosition);

- if (m_typingStyle->isEmpty())

- m_typingStyle = nullptr;

- // This is where we've deleted all traces of a style but not a whole paragraph (that's handled above).

- // In this case if we start typing, the new characters should have the same style as the just deleted ones,

- // but, if we change the selection, come back and start typing that style should be lost. Also see

- // preserveTypingStyle() below.

- document().frame()->selection().setTypingStyle(m_typingStyle);

-void DeleteSelectionCommand::clearTransientState()

- m_selectionToDelete = VisibleSelection();

- m_upstreamStart = Position();

- m_downstreamStart = Position();

- m_upstreamEnd = Position();

- m_downstreamEnd = Position();

- m_endingPosition = Position();

- m_leadingWhitespace = Position();

- m_trailingWhitespace = Position();

-// This method removes div elements with no attributes that have only one child or no children at all.

-void DeleteSelectionCommand::removeRedundantBlocks()

- Node* node = m_endingPosition.computeContainerNode();

- Element* rootElement = node->rootEditableElement();

- while (node != rootElement) {

- if (isRemovableBlock(node)) {

- if (node == m_endingPosition.anchorNode())

- updatePositionForNodeRemovalPreservingChildren(m_endingPosition, *node);

- CompositeEditCommand::removeNodePreservingChildren(node);

- node = m_endingPosition.anchorNode();

- } else

- node = node->parentNode();

- }

-void DeleteSelectionCommand::doApply()

- // If selection has not been set to a custom selection when the command was created,

- // use the current ending selection.

- if (!m_hasSelectionToDelete)

- m_selectionToDelete = endingSelection();

- if (!m_selectionToDelete.isNonOrphanedRange() || !m_selectionToDelete.isContentEditable())

- return;

- // save this to later make the selection with

- EAffinity affinity = m_selectionToDelete.affinity();

- Position downstreamEnd = m_selectionToDelete.end().downstream();

- bool rootWillStayOpenWithoutPlaceholder = downstreamEnd.computeContainerNode() == downstreamEnd.computeContainerNode()->rootEditableElement()

- || (downstreamEnd.computeContainerNode()->isTextNode() && downstreamEnd.computeContainerNode()->parentNode() == downstreamEnd.computeContainerNode()->rootEditableElement());

- bool lineBreakAtEndOfSelectionToDelete = lineBreakExistsAtVisiblePosition(m_selectionToDelete.visibleEnd());

- m_needPlaceholder = !rootWillStayOpenWithoutPlaceholder

- && isStartOfParagraph(m_selectionToDelete.visibleStart(), CanCrossEditingBoundary)

- && isEndOfParagraph(m_selectionToDelete.visibleEnd(), CanCrossEditingBoundary)

- && !lineBreakAtEndOfSelectionToDelete;

- if (m_needPlaceholder) {

- // Don't need a placeholder when deleting a selection that starts just before a table

- // and ends inside it (we do need placeholders to hold open empty cells, but that's

- // handled elsewhere).

- if (Element* table = isLastPositionBeforeTable(m_selectionToDelete.visibleStart()))

- if (m_selectionToDelete.end().anchorNode()->isDescendantOf(table))

- m_needPlaceholder = false;

- }

- // set up our state

- initializePositionData();

- bool lineBreakBeforeStart = lineBreakExistsAtVisiblePosition(VisiblePosition(m_upstreamStart).previous());

- // Delete any text that may hinder our ability to fixup whitespace after the delete

- deleteInsignificantTextDownstream(m_trailingWhitespace);

- saveTypingStyleState();

- // deleting just a BR is handled specially, at least because we do not

- // want to replace it with a placeholder BR!

- if (handleSpecialCaseBRDelete()) {

- calculateTypingStyleAfterDelete();

- setEndingSelection(VisibleSelection(m_endingPosition, affinity, endingSelection().isDirectional()));

- clearTransientState();

- rebalanceWhitespace();

- return;

- }

- handleGeneralDelete();

- fixupWhitespace();

- mergeParagraphs();

- removePreviouslySelectedEmptyTableRows();

- if (!m_needPlaceholder && rootWillStayOpenWithoutPlaceholder) {

- VisiblePosition visualEnding(m_endingPosition);

- bool hasPlaceholder = lineBreakExistsAtVisiblePosition(visualEnding)

- && visualEnding.next(CannotCrossEditingBoundary).isNull();

- m_needPlaceholder = hasPlaceholder && lineBreakBeforeStart && !lineBreakAtEndOfSelectionToDelete;

- }

- RefPtrWillBeRawPtr<HTMLBRElement> placeholder = m_needPlaceholder ? createBreakElement(document()) : nullptr;

- if (placeholder) {

- if (m_sanitizeMarkup)

- removeRedundantBlocks();

- // handleGeneralDelete cause DOM mutation events so |m_endingPosition|

- // can be out of document.

- if (m_endingPosition.inDocument())

- insertNodeAt(placeholder.get(), m_endingPosition);

- }

- rebalanceWhitespaceAt(m_endingPosition);

- calculateTypingStyleAfterDelete();

- setEndingSelection(VisibleSelection(m_endingPosition, affinity, endingSelection().isDirectional()));

- clearTransientState();

-EditAction DeleteSelectionCommand::editingAction() const

- // Note that DeleteSelectionCommand is also used when the user presses the Delete key,

- // but in that case there's a TypingCommand that supplies the editingAction(), so

- // the Undo menu correctly shows "Undo Typing"

- return EditActionCut;

-// Normally deletion doesn't preserve the typing style that was present before it. For example,

-// type a character, Bold, then delete the character and start typing. The Bold typing style shouldn't

-// stick around. Deletion should preserve a typing style that *it* sets, however.

-bool DeleteSelectionCommand::preservesTypingStyle() const

- return m_typingStyle;

-DEFINE_TRACE(DeleteSelectionCommand)

- visitor->trace(m_selectionToDelete);

- visitor->trace(m_upstreamStart);

- visitor->trace(m_downstreamStart);

- visitor->trace(m_upstreamEnd);

- visitor->trace(m_downstreamEnd);

- visitor->trace(m_endingPosition);

- visitor->trace(m_leadingWhitespace);

- visitor->trace(m_trailingWhitespace);

- visitor->trace(m_startBlock);

- visitor->trace(m_endBlock);

- visitor->trace(m_typingStyle);

- visitor->trace(m_deleteIntoBlockquoteStyle);

- visitor->trace(m_startRoot);

- visitor->trace(m_endRoot);

- visitor->trace(m_startTableRow);

- visitor->trace(m_endTableRow);

- visitor->trace(m_temporaryPlaceholder);

- CompositeEditCommand::trace(visitor);

-} // namespace blink

« Source/core/core.gypi ('K') | « Source/core/editing/DeleteSelectionCommand.h ('k') | Source/core/editing/EditAction.h » ('j') | Source/core/editing/commands/EditAction.h » ('J')