Move execCommand related files in core/editing/ related files into core/editing/commands/

Source/core/editing/commands/ReplaceSelectionCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009, 2010, 2011 Google 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 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/ReplaceSelectionCommand.h"
+#include "core/editing/commands/ReplaceSelectionCommand.h"
 
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/CSSPropertyNames.h"
 #include "core/HTMLNames.h"
 #include "core/InputTypeNames.h"
 #include "core/css/CSSStyleDeclaration.h"
 #include "core/css/StylePropertySet.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentFragment.h"
 #include "core/dom/Element.h"
 #include "core/dom/Text.h"
-#include "core/editing/ApplyStyleCommand.h"
-#include "core/editing/BreakBlockquoteCommand.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/FrameSelection.h"
-#include "core/editing/SimplifyMarkupCommand.h"
-#include "core/editing/SmartReplace.h"
 #include "core/editing/VisibleUnits.h"
+#include "core/editing/commands/ApplyStyleCommand.h"
+#include "core/editing/commands/BreakBlockquoteCommand.h"
+#include "core/editing/commands/SimplifyMarkupCommand.h"
+#include "core/editing/commands/SmartReplace.h"
 #include "core/editing/iterators/TextIterator.h"
 #include "core/editing/serializers/HTMLInterchange.h"
 #include "core/editing/serializers/Serialization.h"
 #include "core/events/BeforeTextInsertedEvent.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLBRElement.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLLIElement.h"
@@ skipping 82 matching lines @@
 
         if (nextPosition == pos
             || enclosingBlock(nextPosition.computeContainerNode()) != enclosingBlockElement
             || VisiblePosition(pos).deepEquivalent() != VisiblePosition(nextPosition).deepEquivalent())
             break;
     }
     return pos;
 }
 
 ReplacementFragment::ReplacementFragment(Document* document, DocumentFragment* fragment, const VisibleSelection& selection)
-    : m_document(document),
-      m_fragment(fragment),
-      m_hasInterchangeNewlineAtStart(false),
-      m_hasInterchangeNewlineAtEnd(false)
+    : m_document(document)
+    , m_fragment(fragment)
+    , m_hasInterchangeNewlineAtStart(false)
+    , m_hasInterchangeNewlineAtEnd(false)
 {
     if (!m_document)
         return;
     if (!m_fragment || !m_fragment->hasChildren())
         return;
 
     RefPtrWillBeRawPtr<Element> editableRoot = selection.rootEditableElement();
     ASSERT(editableRoot);
     if (!editableRoot)
         return;
@@ skipping 689 matching lines @@
         insertNodeBefore(placeholder, startOfParagraphToMove.deepEquivalent().anchorNode());
         destination = VisiblePosition(positionBeforeNode(placeholder.get()));
     }
 
     moveParagraph(startOfParagraphToMove, endOfParagraph(startOfParagraphToMove), destination);
 
     // Merging forward will remove m_endOfInsertedContent from the document.
     if (mergeForward) {
         if (m_startOfInsertedContent.isOrphan())
             m_startOfInsertedContent = endingSelection().visibleStart().deepEquivalent();
-         m_endOfInsertedContent = endingSelection().visibleEnd().deepEquivalent();
+        m_endOfInsertedContent = endingSelection().visibleEnd().deepEquivalent();
         // If we merged text nodes, m_endOfInsertedContent could be null. If this is the case, we use m_startOfInsertedContent.
         if (m_endOfInsertedContent.isNull())
             m_endOfInsertedContent = m_startOfInsertedContent;
     }
 }
 
 static Node* enclosingInline(Node* node)
 {
     while (ContainerNode* parent = node->parentNode()) {
         if (isBlockFlowElement(*parent) || isHTMLBodyElement(*parent))
@@ skipping 74 matching lines @@
     bool selectionEndWasEndOfParagraph = isEndOfParagraph(visibleEnd);
     bool selectionStartWasStartOfParagraph = isStartOfParagraph(visibleStart);
 
     Element* enclosingBlockOfVisibleStart = enclosingBlock(visibleStart.deepEquivalent().anchorNode());
 
     Position insertionPos = selection.start();
     bool startIsInsideMailBlockquote = enclosingNodeOfType(insertionPos, isMailHTMLBlockquoteElement, CanCrossEditingBoundary);
     bool selectionIsPlainText = !selection.isContentRichlyEditable();
     Element* currentRoot = selection.rootEditableElement();
 
-    if ((selectionStartWasStartOfParagraph && selectionEndWasEndOfParagraph && !startIsInsideMailBlockquote) ||
-        enclosingBlockOfVisibleStart == currentRoot || isListItem(enclosingBlockOfVisibleStart) || selectionIsPlainText)
+    if ((selectionStartWasStartOfParagraph && selectionEndWasEndOfParagraph && !startIsInsideMailBlockquote)
+        || enclosingBlockOfVisibleStart == currentRoot
+        || isListItem(enclosingBlockOfVisibleStart)
+        || selectionIsPlainText) {
         m_preventNesting = false;
+    }
 
     if (selection.isRange()) {
         // When the end of the selection being pasted into is at the end of a paragraph, and that selection
         // spans multiple blocks, not merging may leave an empty line.
         // When the start of the selection being pasted into is at the start of a block, not merging
         // will leave hanging block(s).
         // Merge blocks if the start of the selection was in a Mail blockquote, since we handle
         // that case specially to prevent nesting.
         bool mergeBlocksAfterDelete = startIsInsideMailBlockquote || isEndOfParagraph(visibleEnd) || isStartOfBlock(visibleStart);
         // FIXME: We should only expand to include fully selected special elements if we are copying a
         // selection and pasting it on top of itself.
         deleteSelection(false, mergeBlocksAfterDelete, false);
         visibleStart = endingSelection().visibleStart();
         if (fragment.hasInterchangeNewlineAtStart()) {
             if (isEndOfParagraph(visibleStart) && !isStartOfParagraph(visibleStart)) {
                 if (!isEndOfEditableOrNonEditableContent(visibleStart))
                     setEndingSelection(visibleStart.next());
-            } else
+            } else {
                 insertParagraphSeparator();
+            }
         }
         insertionPos = endingSelection().start();
     } else {
         ASSERT(selection.isCaret());
         if (fragment.hasInterchangeNewlineAtStart()) {
             VisiblePosition next = visibleStart.next(CannotCrossEditingBoundary);
-            if (isEndOfParagraph(visibleStart) && !isStartOfParagraph(visibleStart) && next.isNotNull())
+            if (isEndOfParagraph(visibleStart) && !isStartOfParagraph(visibleStart) && next.isNotNull()) {
                 setEndingSelection(next);
-            else  {
+            } else  {
                 insertParagraphSeparator();
                 visibleStart = endingSelection().visibleStart();
             }
         }
         // We split the current paragraph in two to avoid nesting the blocks from the fragment inside the current block.
         // For example paste <div>foo</div><div>bar</div><div>baz</div> into <div>x^x</div>, where ^ is the caret.
         // As long as the  div styles are the same, visually you'd expect: <div>xbar</div><div>bar</div><div>bazx</div>,
         // not <div>xbar<div>bar</div><div>bazx</div></div>.
         // Don't do this if the selection started in a Mail blockquote.
         if (m_preventNesting && !startIsInsideMailBlockquote && !isEndOfParagraph(visibleStart) && !isStartOfParagraph(visibleStart)) {
@@ skipping 14 matching lines @@
         // Insert content between the two blockquotes, but remove the br (since it was just a placeholder).
         insertionPos = positionInParentBeforeNode(*br);
         removeNode(br);
     }
 
     // Inserting content could cause whitespace to collapse, e.g. inserting <div>foo</div> into hello^ world.
     prepareWhitespaceAtPositionForSplit(insertionPos);
 
     // If the downstream node has been removed there's no point in continuing.
     if (!insertionPos.downstream().anchorNode())
-      return;
+        return;
 
     // NOTE: This would be an incorrect usage of downstream() if downstream() were changed to mean the last position after
     // p that maps to the same visible position as p (since in the case where a br is at the end of a block and collapsed
     // away, there are positions after the br which map to the same visible position as [br, 0]).
     HTMLBRElement* endBR = isHTMLBRElement(*insertionPos.downstream().anchorNode()) ? toHTMLBRElement(insertionPos.downstream().anchorNode()) : 0;
     VisiblePosition originalVisPosBeforeEndBR;
     if (endBR)
         originalVisPosBeforeEndBR = VisiblePosition(positionBeforeNode(endBR), DOWNSTREAM).previous();
 
     RefPtrWillBeRawPtr<Element> enclosingBlockOfInsertionPos = enclosingBlock(insertionPos.anchorNode());
@@ skipping 71 matching lines @@
 
     InsertedNodes insertedNodes;
     RefPtrWillBeRawPtr<Node> refNode = fragment.firstChild();
     ASSERT(refNode);
     RefPtrWillBeRawPtr<Node> node = refNode->nextSibling();
 
     fragment.removeNode(refNode);
 
     Element* blockStart = enclosingBlock(insertionPos.anchorNode());
     if ((isHTMLListElement(refNode.get()) || (isLegacyAppleHTMLSpanElement(refNode.get()) && isHTMLListElement(refNode->firstChild())))
-        && blockStart && blockStart->layoutObject()->isListItem())
+        && blockStart && blockStart->layoutObject()->isListItem()) {
         refNode = insertAsListItems(toHTMLElement(refNode), blockStart, insertionPos, insertedNodes);
-    else {
+    } else {
         insertNodeAt(refNode, insertionPos);
         insertedNodes.respondToNodeInsertion(*refNode);
     }
 
     // Mutation events (bug 22634) may have already removed the inserted content
     if (!refNode->inDocument())
         return;
 
     bool plainTextFragment = isPlainTextMarkup(refNode.get());
 
@@ skipping 242 matching lines @@
 
         if (m_matchStyle) {
             ASSERT(m_insertionStyle);
             applyStyle(m_insertionStyle.get(), start, end);
         }
 
         if (lastPositionToSelect.isNotNull())
             end = lastPositionToSelect;
 
         mergeTextNodesAroundPosition(start, end);
-    } else if (lastPositionToSelect.isNotNull())
+    } else if (lastPositionToSelect.isNotNull()) {
         start = end = lastPositionToSelect;
-    else
+    } else {
         return;
+    }
 
     if (m_selectReplacement)
         setEndingSelection(VisibleSelection(start, end, SEL_DEFAULT_AFFINITY, endingSelection().isDirectional()));
     else
         setEndingSelection(VisibleSelection(end, SEL_DEFAULT_AFFINITY, endingSelection().isDirectional()));
 }
 
 void ReplaceSelectionCommand::mergeTextNodesAroundPosition(Position& position, Position& positionOnlyToBeUpdated)
 {
     bool positionIsOffsetInAnchor = position.isOffsetInAnchor();
     bool positionOnlyToBeUpdatedIsOffsetInAnchor = positionOnlyToBeUpdated.isOffsetInAnchor();
     RefPtrWillBeRawPtr<Text> text = nullptr;
-    if (positionIsOffsetInAnchor && position.computeContainerNode() && position.computeContainerNode()->isTextNode())
+    if (positionIsOffsetInAnchor && position.computeContainerNode() && position.computeContainerNode()->isTextNode()) {
         text = toText(position.computeContainerNode());
-    else {
+    } else {
         Node* before = position.computeNodeBeforePosition();
-        if (before && before->isTextNode())
+        if (before && before->isTextNode()) {
             text = toText(before);
-        else {
+        } else {
             Node* after = position.computeNodeAfterPosition();
             if (after && after->isTextNode())
                 text = toText(after);
         }
     }
     if (!text)
         return;
 
     if (text->previousSibling() && text->previousSibling()->isTextNode()) {
         RefPtrWillBeRawPtr<Text> previous = toText(text->previousSibling());
@@ skipping 62 matching lines @@
 
     while (RefPtrWillBeRawPtr<Node> listItem = listElement->firstChild()) {
         listElement->removeChild(listItem.get(), ASSERT_NO_EXCEPTION);
         if (isStart || isMiddle) {
             insertNodeBefore(listItem, lastNode);
             insertedNodes.respondToNodeInsertion(*listItem);
         } else if (isEnd) {
             insertNodeAfter(listItem, lastNode);
             insertedNodes.respondToNodeInsertion(*listItem);
             lastNode = listItem.get();
-        } else
+        } else {
             ASSERT_NOT_REACHED();
+        }
     }
     if (isStart || isMiddle) {
         if (Node* node = lastNode->previousSibling())
             return node;
     }
     return lastNode;
 }
 
 void ReplaceSelectionCommand::updateNodesInserted(Node *node)
 {
@@ skipping 46 matching lines @@
 DEFINE_TRACE(ReplaceSelectionCommand)
 {
     visitor->trace(m_startOfInsertedContent);
     visitor->trace(m_endOfInsertedContent);
     visitor->trace(m_insertionStyle);
     visitor->trace(m_documentFragment);
     CompositeEditCommand::trace(visitor);
 }
 
 } // namespace blink