[WK2] Add support for keeping the selection in a focused editable element when dragging begins

https://bugs.webkit.org/show_bug.cgi?id=171585
<rdar://problem/31544320>

Reviewed by Beth Dakin and Zalan Bujtas.

Source/WebCore:

Covered by 4 API tests.

* dom/DocumentMarker.h:

Introduces the DraggedContent DocumentMarker type, which applies to the Range in the DOM that is being used as
a drag source. Also adds DraggedContentData, which contains nodes found by the TextIterator in the process of
finding Ranges to mark.

(WebCore::DocumentMarker::AllMarkers::AllMarkers):
* dom/DocumentMarkerController.cpp:
(WebCore::DocumentMarkerController::addDraggedContentMarker):
(WebCore::shouldInsertAsSeparateMarker):
(WebCore::DocumentMarkerController::addMarker):

When adding DocumentMarkers of type DraggedContent, keep adjacent RenderReplaced elements separate, rather than
merging them into existing RenderedDocumentMarkers. This is because the data for each of these (i.e. the target
node) needs to be preserved.

(WebCore::DocumentMarkerController::markersFor):

Bail and return an empty list if the map of document markers cannot possibly contain a dragged content marker.

* dom/DocumentMarkerController.h:
* page/DragController.h:
* page/DragState.h:

Add draggedContentRange to DragState. This tracks the Range that is being dragged; it is created when the drag
session has begun, and ends when drag session finishes (either via WebPage::dragEnded or WebPage::dragCancelled).

* page/EventHandler.cpp:
(WebCore::repaintContentsOfRange):
(WebCore::EventHandler::dragCancelled):

Called when a drag is cancelled in the UI process without a session ever getting a chance to begin. We use this
as a hook to remove all DraggedContent document markers from the document of the dragged content range.

(WebCore::EventHandler::didStartDrag):

Called when a drag session has begun in the UI process. We use this as a hook to set up document markers for the
Range of content being dragged.

(WebCore::EventHandler::dragSourceEndedAt):

Called when a drag session ends. We use this as a hook to remove all DraggedContent document markers from the
document of the dragged content range.

(WebCore::EventHandler::draggedElement):
* page/EventHandler.h:
* page/FocusController.cpp:
(WebCore::shouldClearSelectionWhenChangingFocusedElement):

Prevent the selection from clearing when the previously focused element is editable and also contains the drag
source element. Ideally, we should experiment with clearing out the selection whenever the element is blurred
(and not have additional restrictions on editability and containing the drag source), but this change is much
riskier.

(WebCore::FocusController::setFocusedElement):
* rendering/InlineTextBox.cpp:
(WebCore::InlineTextBox::paint):

Use RenderText::draggedContentStartEnd to find the range of text (if any) that is dragged content, and paint
these ranges of text at a lower alpha using TextPainter::paintTextInRange.

* rendering/RenderReplaced.cpp:
(WebCore::draggedContentContainsReplacedElement):

Determines whether or not the element being rendered is contained within a dragged content range. Assuming that
the DraggedContent type flag is set in DocumentMarkerController, we first look to see whether or not the
container node is in the document marker map. If so, instead of consulting node offset ranges (since this is, in
the worst-case, linear in the number of sibling nodes per RenderReplaced) we simply check the DraggedContentData
to see if the current element being rendered matches one of the target nodes.

(WebCore::RenderReplaced::paint):

If the element rendered by this RenderReplaced is dragged content, then render it at a low alpha.

* rendering/RenderText.cpp:
(WebCore::RenderText::draggedContentRangesBetweenOffsets):

Determines what range of text, if any, contains dragged content by consulting the Document's DocumentMarkers.

* rendering/RenderText.h:
* rendering/TextPainter.cpp:
(WebCore::TextPainter::paintTextInRange):

Teach TextPainter to only paint a given range in a TextRun.

* rendering/TextPainter.h:

Add TextPainter support for specifying special text offset ranges when rendering a TextRun, such that each
special range in text is rendered after applying some modification to the GraphicsContext.

Source/WebKit2:

Minor adjustments and refactoring in WebKit2. See WebCore ChangeLog for more details.

* UIProcess/WebPageProxy.cpp:
(WebKit::WebPageProxy::startDrag):
(WebKit::WebPageProxy::didStartDrag):

Factor out code in WebPageProxy that sends a WebPage::DidStartDrag message to the web process into a separate
helper, and tweak the places where we directly send this IPC message to the web process to instead call this
helper.

* UIProcess/WebPageProxy.h:
* UIProcess/mac/WebPageProxyMac.mm:
(WebKit::WebPageProxy::setDragImage):
* WebProcess/WebPage/WebPage.cpp:
(WebKit::WebPage::didStartDrag):
(WebKit::WebPage::dragCancelled):

Clear out state in the web process and call out to the EventHandler to handle drag cancellation and the drag
start response from the UI process.

* WebProcess/WebPage/WebPage.h:
(WebKit::WebPage::didStartDrag): Deleted.
(WebKit::WebPage::dragCancelled): Deleted.

Tools:

Adds 1 new unit test and tweaks existing tests to check that when first responder status is lost after beginning
a drag while editing, content is still moved (and not copied) when performing data interaction on a different
element. ContentEditableMoveParagraphs checks that content can be shifted within a single element via a move
operation rather than a copy.

See WebCore ChangeLog for more details.

Tests:  DataInteractionSimulator.ContentEditableToContentEditable
        DataInteractionSimulator.ContentEditableToTextarea
        DataInteractionSimulator.ContentEditableMoveParagraphs
        DataInteractionSimulator.TextAreaToInput

* TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj:
* TestWebKitAPI/Tests/WebKit2Cocoa/two-paragraph-contenteditable.html: Added.
* TestWebKitAPI/Tests/ios/DataInteractionTests.mm:
(TestWebKitAPI::TEST):
* TestWebKitAPI/ios/DataInteractionSimulator.h:
* TestWebKitAPI/ios/DataInteractionSimulator.mm:
(-[DataInteractionSimulator initWithWebView:]):
(-[DataInteractionSimulator dealloc]):
(-[DataInteractionSimulator _advanceProgress]):
(-[DataInteractionSimulator waitForInputSession]):
(-[DataInteractionSimulator _webView:focusShouldStartInputSession:]):
(-[DataInteractionSimulator _webView:didStartInputSession:]):


git-svn-id: http://svn.webkit.org/repository/webkit/trunk@216212 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Author: [email protected]

Source/WebCore/ChangeLog

@@ -1,3 +1,103 @@
+2017-05-04  Wenson Hsieh  <[email protected]>
+
+        [WK2] Add support for keeping the selection in a focused editable element when dragging begins
+        https://bugs.webkit.org/show_bug.cgi?id=171585
+        <rdar://problem/31544320>
+
+        Reviewed by Beth Dakin and Zalan Bujtas.
+
+        Covered by 4 API tests.
+
+        * dom/DocumentMarker.h:
+
+        Introduces the DraggedContent DocumentMarker type, which applies to the Range in the DOM that is being used as
+        a drag source. Also adds DraggedContentData, which contains nodes found by the TextIterator in the process of
+        finding Ranges to mark.
+
+        (WebCore::DocumentMarker::AllMarkers::AllMarkers):
+        * dom/DocumentMarkerController.cpp:
+        (WebCore::DocumentMarkerController::addDraggedContentMarker):
+        (WebCore::shouldInsertAsSeparateMarker):
+        (WebCore::DocumentMarkerController::addMarker):
+
+        When adding DocumentMarkers of type DraggedContent, keep adjacent RenderReplaced elements separate, rather than
+        merging them into existing RenderedDocumentMarkers. This is because the data for each of these (i.e. the target
+        node) needs to be preserved.
+
+        (WebCore::DocumentMarkerController::markersFor):
+
+        Bail and return an empty list if the map of document markers cannot possibly contain a dragged content marker.
+
+        * dom/DocumentMarkerController.h:
+        * page/DragController.h:
+        * page/DragState.h:
+
+        Add draggedContentRange to DragState. This tracks the Range that is being dragged; it is created when the drag
+        session has begun, and ends when drag session finishes (either via WebPage::dragEnded or WebPage::dragCancelled).
+
+        * page/EventHandler.cpp:
+        (WebCore::repaintContentsOfRange):
+        (WebCore::EventHandler::dragCancelled):
+
+        Called when a drag is cancelled in the UI process without a session ever getting a chance to begin. We use this
+        as a hook to remove all DraggedContent document markers from the document of the dragged content range.
+
+        (WebCore::EventHandler::didStartDrag):
+
+        Called when a drag session has begun in the UI process. We use this as a hook to set up document markers for the
+        Range of content being dragged.
+
+        (WebCore::EventHandler::dragSourceEndedAt):
+
+        Called when a drag session ends. We use this as a hook to remove all DraggedContent document markers from the
+        document of the dragged content range.
+
+        (WebCore::EventHandler::draggedElement):
+        * page/EventHandler.h:
+        * page/FocusController.cpp:
+        (WebCore::shouldClearSelectionWhenChangingFocusedElement):
+
+        Prevent the selection from clearing when the previously focused element is editable and also contains the drag
+        source element. Ideally, we should experiment with clearing out the selection whenever the element is blurred
+        (and not have additional restrictions on editability and containing the drag source), but this change is much
+        riskier.
+
+        (WebCore::FocusController::setFocusedElement):
+        * rendering/InlineTextBox.cpp:
+        (WebCore::InlineTextBox::paint):
+
+        Use RenderText::draggedContentStartEnd to find the range of text (if any) that is dragged content, and paint
+        these ranges of text at a lower alpha using TextPainter::paintTextInRange.
+
+        * rendering/RenderReplaced.cpp:
+        (WebCore::draggedContentContainsReplacedElement):
+
+        Determines whether or not the element being rendered is contained within a dragged content range. Assuming that
+        the DraggedContent type flag is set in DocumentMarkerController, we first look to see whether or not the
+        container node is in the document marker map. If so, instead of consulting node offset ranges (since this is, in
+        the worst-case, linear in the number of sibling nodes per RenderReplaced) we simply check the DraggedContentData
+        to see if the current element being rendered matches one of the target nodes.
+
+        (WebCore::RenderReplaced::paint):
+
+        If the element rendered by this RenderReplaced is dragged content, then render it at a low alpha.
+
+        * rendering/RenderText.cpp:
+        (WebCore::RenderText::draggedContentRangesBetweenOffsets):
+
+        Determines what range of text, if any, contains dragged content by consulting the Document's DocumentMarkers.
+
+        * rendering/RenderText.h:
+        * rendering/TextPainter.cpp:
+        (WebCore::TextPainter::paintTextInRange):
+
+        Teach TextPainter to only paint a given range in a TextRun.
+
+        * rendering/TextPainter.h:
+
+        Add TextPainter support for specifying special text offset ranges when rendering a TextRun, such that each
+        special range in text is rendered after applying some modification to the GraphicsContext.
+
 2017-05-04  Jeremy Jones  <[email protected]>
 
         Crash when pointer lock element is removed before pointer lock allowed arrives.

Source/WebCore/dom/DocumentMarker.h

@@ -20,6 +20,8 @@
 
 #pragma once
 
+#include "Node.h"
+
 #include <wtf/Forward.h>
 #include <wtf/Variant.h>
 #include <wtf/text/WTFString.h>
@@ -75,6 +77,8 @@ class DocumentMarker {
 #endif
         // This marker indicates that the user has selected a text candidate.
         AcceptedCandidate = 1 << 13,
+        // This marker indicates that the user has initiated a drag with this content.
+        DraggedContent = 1 << 14
     };
 
     class MarkerTypes {
@@ -115,6 +119,7 @@ class DocumentMarker {
                 | DictationPhraseWithAlternatives
                 | DictationResult
 #endif
+                | DraggedContent
             )
         {
         }
@@ -132,7 +137,10 @@ class DocumentMarker {
         RetainPtr<id> metadata;
 #endif
     };
-    using Data = Variant<IsActiveMatchData, DescriptionData, DictationData, DictationAlternativesData>;
+    struct DraggedContentData {
+        RefPtr<Node> targetNode;
+    };
+    using Data = Variant<IsActiveMatchData, DescriptionData, DictationData, DictationAlternativesData, DraggedContentData>;
 
     DocumentMarker(unsigned startOffset, unsigned endOffset, bool isActiveMatch);
     DocumentMarker(MarkerType, unsigned startOffset, unsigned endOffset, const String& description = String());

Source/WebCore/dom/DocumentMarkerController.cpp

@@ -135,6 +135,15 @@ void DocumentMarkerController::addDictationResultMarker(Range* range, const Reta
 
 #endif
 
+void DocumentMarkerController::addDraggedContentMarker(RefPtr<Range> range)
+{
+    for (TextIterator markedText(range.get()); !markedText.atEnd(); markedText.advance()) {
+        RefPtr<Range> textPiece = markedText.range();
+        DocumentMarker::DraggedContentData draggedContentData { markedText.node() };
+        addMarker(&textPiece->startContainer(), { DocumentMarker::DraggedContent, textPiece->startOffset(), textPiece->endOffset(), WTFMove(draggedContentData) });
+    }
+}
+
 void DocumentMarkerController::removeMarkers(Range* range, DocumentMarker::MarkerTypes markerTypes, RemovePartiallyOverlappingMarkerOrNot shouldRemovePartiallyOverlappingMarker)
 {
     for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
@@ -293,6 +302,20 @@ Vector<FloatRect> DocumentMarkerController::renderedRectsForMarkers(DocumentMark
     return result;
 }
 
+static bool shouldInsertAsSeparateMarker(const DocumentMarker& newMarker)
+{
+#if PLATFORM(IOS)
+    if (newMarker.type() == DocumentMarker::DictationPhraseWithAlternatives || newMarker.type() == DocumentMarker::DictationResult)
+        return true;
+#endif
+    if (newMarker.type() == DocumentMarker::DraggedContent) {
+        if (auto targetNode = WTF::get<DocumentMarker::DraggedContentData>(newMarker.data()).targetNode)
+            return targetNode->renderer() && targetNode->renderer()->isRenderReplaced();
+    }
+
+    return false;
+}
+
 // Markers are stored in order sorted by their start offset.
 // Markers of the same type do not overlap each other.
 
@@ -317,8 +340,7 @@ void DocumentMarkerController::addMarker(Node* node, const DocumentMarker& newMa
     if (!list) {
         list = std::make_unique<MarkerList>();
         list->append(RenderedDocumentMarker(newMarker));
-#if PLATFORM(IOS)
-    } else if (newMarker.type() == DocumentMarker::DictationPhraseWithAlternatives || newMarker.type() == DocumentMarker::DictationResult) {
+    } else if (shouldInsertAsSeparateMarker(newMarker)) {
         // We don't merge dictation markers.
         size_t i;
         size_t numberOfMarkers = list->size();
@@ -328,7 +350,6 @@ void DocumentMarkerController::addMarker(Node* node, const DocumentMarker& newMa
                 break;
         }
         list->insert(i, RenderedDocumentMarker(newMarker));
-#endif
     } else {
         RenderedDocumentMarker toInsert(newMarker);
         size_t numMarkers = list->size();
@@ -504,6 +525,9 @@ DocumentMarker* DocumentMarkerController::markerContainingPoint(const LayoutPoin
 
 Vector<RenderedDocumentMarker*> DocumentMarkerController::markersFor(Node* node, DocumentMarker::MarkerTypes markerTypes)
 {
+    if (!possiblyHasMarkers(markerTypes))
+        return { };
+
     Vector<RenderedDocumentMarker*> result;
     MarkerList* list = m_markers.get(node);
     if (!list)

Source/WebCore/dom/DocumentMarkerController.h

@@ -59,6 +59,7 @@ class DocumentMarkerController {
     void addDictationPhraseWithAlternativesMarker(Range*, const Vector<String>& interpretations);
     void addDictationResultMarker(Range*, const RetainPtr<id>& metadata);
 #endif
+    void addDraggedContentMarker(RefPtr<Range>);
 
     void copyMarkers(Node* srcNode, unsigned startOffset, int length, Node* dstNode, int delta);
     bool hasMarkers() const

Source/WebCore/page/DragController.h

@@ -62,6 +62,7 @@ struct DragState;
         WEBCORE_EXPORT void dragExited(const DragData&);
         WEBCORE_EXPORT DragOperation dragUpdated(const DragData&);
         WEBCORE_EXPORT bool performDragOperation(const DragData&);
+        WEBCORE_EXPORT void dragCancelled();
 
         bool mouseIsOverFileInput() const { return m_fileInputElementUnderMouse; }
         unsigned numberOfItemsToBeAccepted() const { return m_numberOfItemsToBeAccepted; }

Source/WebCore/page/DragState.h

@@ -34,6 +34,7 @@ namespace WebCore {
 
 struct DragState {
     RefPtr<Element> source; // Element that may be a drag source, for the current mouse gesture.
+    RefPtr<Range> draggedContentRange;
     bool shouldDispatchEvents;
     DragSourceAction type;
     RefPtr<DataTransfer> dataTransfer; // Used on only the source side of dragging.

Source/WebCore/page/EventHandler.cpp

@@ -34,6 +34,7 @@
 #include "Chrome.h"
 #include "ChromeClient.h"
 #include "CursorList.h"
+#include "DocumentMarkerController.h"
 #include "DragController.h"
 #include "DragState.h"
 #include "Editing.h"
@@ -3451,6 +3452,60 @@ void EventHandler::invalidateDataTransfer()
     dragState().dataTransfer = nullptr;
 }
 
+static void repaintContentsOfRange(RefPtr<Range> range)
+{
+    if (!range)
+        return;
+
+    auto* container = range->commonAncestorContainer();
+    if (!container)
+        return;
+
+    // This ensures that all nodes enclosed in this Range are repainted.
+    if (auto rendererToRepaint = container->renderer()) {
+        if (auto* containingRenderer = rendererToRepaint->container())
+            rendererToRepaint = containingRenderer;
+        rendererToRepaint->repaint();
+    }
+}
+
+void EventHandler::dragCancelled()
+{
+#if ENABLE(DATA_INTERACTION)
+    if (auto range = dragState().draggedContentRange) {
+        range->ownerDocument().markers().removeMarkers(DocumentMarker::DraggedContent);
+        repaintContentsOfRange(range);
+    }
+    dragState().draggedContentRange = nullptr;
+#endif
+}
+
+void EventHandler::didStartDrag()
+{
+#if ENABLE(DATA_INTERACTION)
+    auto dragSource = dragState().source;
+    if (!dragSource)
+        return;
+
+    auto* renderer = dragSource->renderer();
+    if (!renderer)
+        return;
+
+    if (dragState().type & DragSourceActionSelection)
+        dragState().draggedContentRange = m_frame.selection().selection().toNormalizedRange();
+    else {
+        Position startPosition(dragSource.get(), Position::PositionIsBeforeAnchor);
+        Position endPosition(dragSource.get(), Position::PositionIsAfterAnchor);
+        dragState().draggedContentRange = Range::create(dragSource->document(), startPosition, endPosition);
+    }
+
+    if (auto range = dragState().draggedContentRange) {
+        range->ownerDocument().markers().addDraggedContentMarker(range.get());
+        repaintContentsOfRange(range);
+    }
+#endif
+}
+
 void EventHandler::dragSourceEndedAt(const PlatformMouseEvent& event, DragOperation operation)
 {
     // Send a hit test request so that RenderLayer gets a chance to update the :hover and :active pseudoclasses.
@@ -3463,6 +3518,12 @@ void EventHandler::dragSourceEndedAt(const PlatformMouseEvent& event, DragOperat
         dispatchDragSrcEvent(eventNames().dragendEvent, event);
     }
     invalidateDataTransfer();
+
+    if (auto range = dragState().draggedContentRange) {
+        range->ownerDocument().markers().removeMarkers(DocumentMarker::DraggedContent);
+        repaintContentsOfRange(range);
+    }
+
     dragState().source = nullptr;
     // In case the drag was ended due to an escape key press we need to ensure
     // that consecutive mousemove events don't reinitiate the drag and drop.
@@ -3487,6 +3548,11 @@ static bool ExactlyOneBitSet(DragSourceAction n)
     return n && !(n & (n - 1));
 }
 
+RefPtr<Element> EventHandler::draggedElement() const
+{
+    return dragState().source;
+}
+
 bool EventHandler::handleDrag(const MouseEventWithHitTestResults& event, CheckDragHysteresis checkDragHysteresis)
 {
     if (event.event().button() != LeftButton || event.event().type() != PlatformEvent::MouseMoved) {

Source/WebCore/page/EventHandler.h

@@ -159,6 +159,7 @@ class EventHandler {
     void cancelDragAndDrop(const PlatformMouseEvent&, DataTransfer&);
     bool performDragAndDrop(const PlatformMouseEvent&, DataTransfer&);
     void updateDragStateAfterEditDragIfNeeded(Element& rootEditableElement);
+    RefPtr<Element> draggedElement() const;
 #endif
 
     void scheduleHoverStateUpdate();
@@ -253,6 +254,8 @@ class EventHandler {
 #if ENABLE(DRAG_SUPPORT)
     WEBCORE_EXPORT bool eventMayStartDrag(const PlatformMouseEvent&) const;
 
+    WEBCORE_EXPORT void didStartDrag();
+    WEBCORE_EXPORT void dragCancelled();
     WEBCORE_EXPORT void dragSourceEndedAt(const PlatformMouseEvent&, DragOperation);
 #endif
 

Source/WebCore/page/FocusController.cpp

@@ -765,6 +765,29 @@ static void clearSelectionIfNeeded(Frame* oldFocusedFrame, Frame* newFocusedFram
     oldFocusedFrame->selection().clear();
 }
 
+static bool shouldClearSelectionWhenChangingFocusedElement(const Page& page, RefPtr<Element> oldFocusedElement, RefPtr<Element> newFocusedElement)
+{
+#if ENABLE(DATA_INTERACTION)
+    if (newFocusedElement || !oldFocusedElement)
+        return true;
+
+    // FIXME: These additional checks should not be necessary. We should consider generally keeping the selection whenever the
+    // focused element is blurred, with no new element taking focus.
+    if (!oldFocusedElement->isRootEditableElement() && !is<HTMLInputElement>(oldFocusedElement.get()) && !is<HTMLTextAreaElement>(oldFocusedElement.get()))
+        return true;
+
+    for (auto ancestor = page.mainFrame().eventHandler().draggedElement(); ancestor; ancestor = ancestor->parentOrShadowHostElement()) {
+        if (ancestor == oldFocusedElement)
+            return false;
+    }
+#else
+    UNUSED_PARAM(page);
+    UNUSED_PARAM(oldFocusedElement);
+    UNUSED_PARAM(newFocusedElement);
+#endif
+    return true;
+}
+
 bool FocusController::setFocusedElement(Element* element, Frame& newFocusedFrame, FocusDirection direction)
 {
     Ref<Frame> protectedNewFocusedFrame = newFocusedFrame;
@@ -781,7 +804,8 @@ bool FocusController::setFocusedElement(Element* element, Frame& newFocusedFrame
 
     m_page.editorClient().willSetInputMethodState();
 
-    clearSelectionIfNeeded(oldFocusedFrame.get(), &newFocusedFrame, element);
+    if (shouldClearSelectionWhenChangingFocusedElement(m_page, oldFocusedElement, element))
+        clearSelectionIfNeeded(oldFocusedFrame.get(), &newFocusedFrame, element);
 
     if (!element) {
         if (oldDocument)