Enable selection for the composed tree

Source/core/editing/FrameSelection.cpp

 /*
  * Copyright (C) 2004, 2008, 2009, 2010 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
@@ skipping 206 matching lines @@
 
     newSelection.setIsDirectional(isDirectional); // Adjusting base and extent will make newSelection always directional
     if (Strategy::equalSelections(m_selection, newSelection))
         return;
 
     setSelection(newSelection, granularity);
 }
 
 void FrameSelection::setNonDirectionalSelectionIfNeeded(const VisibleSelection& passedNewSelection, TextGranularity granularity, EndPointsAdjustmentMode endpointsAdjustmentMode)
 {
+    if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
+        return setNonDirectionalSelectionIfNeededAlgorithm<VisibleSelection::InComposedTree>(passedNewSelection, granularity, endpointsAdjustmentMode);
     setNonDirectionalSelectionIfNeededAlgorithm<VisibleSelection::InDOMTree>(passedNewSelection, granularity, endpointsAdjustmentMode);
 }
 
+static bool areEquivalentSelections(const VisibleSelection& selection1, const VisibleSelection& selection2)
+{
+    if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
+        return VisibleSelection::InComposedTree::equalSelections(selection1, selection2);
+    return VisibleSelection::InDOMTree::equalSelections(selection1, selection2);
+}
+
 void FrameSelection::setSelection(const VisibleSelection& newSelection, SetSelectionOptions options, CursorAlignOnScroll align, TextGranularity granularity)
 {
     if (m_granularityStrategy && (options & FrameSelection::DoNotClearStrategy) == 0)
         m_granularityStrategy->Clear();
     bool closeTyping = options & CloseTyping;
     bool shouldClearTypingStyle = options & ClearTypingStyle;
     EUserTriggered userTriggered = selectionOptionsToUserTriggered(options);
 
     VisibleSelection s = validateSelection(newSelection);
     if (shouldAlwaysUseDirectionalSelection(m_frame))
         s.setIsDirectional(true);
 
     if (!m_frame) {
         m_selection = s;
         return;
     }
 
     // <http://bugs.webkit.org/show_bug.cgi?id=23464>: Infinite recursion at FrameSelection::setSelection
     // if document->frame() == m_frame we can get into an infinite loop
     if (s.base().anchorNode()) {
         Document& document = *s.base().document();
+        // TODO(hajimehoshi): validateSelection already checks if the selection
+        // is valid, thus we don't need this 'if' clause any more.
         if (document.frame() && document.frame() != m_frame && document != m_frame->document()) {
             RefPtrWillBeRawPtr<LocalFrame> guard(document.frame());
             document.frame()->selection().setSelection(s, options, align, granularity);
             // It's possible that during the above set selection, this FrameSelection has been modified by
             // selectFrameElementInParentIfFullySelected, but that the selection is no longer valid since
             // the frame is about to be destroyed. If this is the case, clear our selection.
             if (!guard->host() && !m_selection.isNonOrphanedCaretOrRange())
                 clear();
             return;
         }
     }
 
     m_granularity = granularity;
 
     if (closeTyping)
         TypingCommand::closeTyping(m_frame);
 
     if (shouldClearTypingStyle)
         clearTypingStyle();
 
-    if (m_selection == s) {
+    if (areEquivalentSelections(m_selection, s)) {
         // Even if selection was not changed, selection offsets may have been changed.
         m_frame->inputMethodController().cancelCompositionIfSelectionIsInvalid();
         notifyLayoutObjectOfSelectionChange(userTriggered);
         return;
     }
 
     VisibleSelection oldSelection = m_selection;
 
     m_selection = s;
     setCaretRectNeedsUpdate();
 
     if (!s.isNone() && !(options & DoNotSetFocus))
         setFocusedNodeIfNeeded();
 
     if (!(options & DoNotUpdateAppearance)) {
         // Hits in compositing/overflow/do-not-paint-outline-into-composited-scrolling-contents.html
         DisableCompositingQueryAsserts disabler;
         updateAppearance(ResetCaretBlink);
     }
 
     // Always clear the x position used for vertical arrow navigation.
     // It will be restored by the vertical arrow navigation code if necessary.
     m_xPosForVerticalArrowNavigation = NoXPosForVerticalArrowNavigation();
     selectFrameElementInParentIfFullySelected();
     notifyLayoutObjectOfSelectionChange(userTriggered);
+    // If the selections are same in the DOM tree but not in the composed tree,
+    // don't fire events. For example, if the selection crosses shadow tree
+    // boundary, selection for the DOM tree is shrunk while that for the
+    // composed tree is not. Additionally, this case occurs in some edge cases.
+    // See also: editing/pasteboard/4076267-3.html
+    if (VisibleSelection::InDOMTree::equalSelections(oldSelection, m_selection))
+        return;
     m_frame->editor().respondToChangedSelection(oldSelection, options);
     if (userTriggered == UserTriggered) {
         ScrollAlignment alignment;
 
         if (m_frame->editor().behavior().shouldCenterAlignWhenSelectionIsRevealed())
             alignment = (align == AlignCursorOnScrollAlways) ? ScrollAlignment::alignCenterAlways : ScrollAlignment::alignCenterIfNeeded;
         else
             alignment = (align == AlignCursorOnScrollAlways) ? ScrollAlignment::alignTopAlways : ScrollAlignment::alignToEdgeIfNeeded;
 
         revealSelection(alignment, RevealExtent);
@@ skipping 1022 matching lines @@
         return false;
 
     PositionType start(Strategy::toPositionType(visibleStart.deepEquivalent()));
     PositionType end(Strategy::toPositionType(visibleEnd.deepEquivalent()));
     PositionType pos(Strategy::toPositionType(visiblePos.deepEquivalent()));
     return start.compareTo(pos) <= 0 && pos.compareTo(end) <= 0;
 }
 
 bool FrameSelection::contains(const LayoutPoint& point)
 {
+    if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
+        return containsAlgorithm<VisibleSelection::InComposedTree>(point);
     return containsAlgorithm<VisibleSelection::InDOMTree>(point);
 }
 
 // Workaround for the fact that it's hard to delete a frame.
 // Call this after doing user-triggered selections to make it easy to delete the frame you entirely selected.
 // Can't do this implicitly as part of every setSelection call because in some contexts it might not be good
 // for the focus to move to another frame. So instead we call it from places where we are selecting with the
 // mouse or the keyboard after setting the selection.
 void FrameSelection::selectFrameElementInParentIfFullySelected()
 {
@@ skipping 337 matching lines @@
     PositionType start;
     PositionType end;
     VisibleSelection visibleSelection = selection.selection();
     VisibleSelection::normalizePositions(Strategy::selectionStart(visibleSelection), Strategy::selectionEnd(visibleSelection), &start, &end);
     // We remove '\0' characters because they are not visibly rendered to the user.
     return plainText(start, end, behavior).replace(0, "");
 }
 
 static String extractSelectedText(const FrameSelection& selection, TextIteratorBehavior behavior)
 {
+    if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
+        return extractSelectedTextAlgorithm<VisibleSelection::InComposedTree>(selection, behavior);
     return extractSelectedTextAlgorithm<VisibleSelection::InDOMTree>(selection, behavior);
 }
 
 template <typename Strategy>
 static String extractSelectedHTMLAlgorithm(const FrameSelection& selection)
 {
     using PositionType = typename Strategy::PositionType;
     PositionType start;
     PositionType end;
     VisibleSelection visibleSelection = selection.selection();
     VisibleSelection::normalizePositions(Strategy::selectionStart(visibleSelection), Strategy::selectionEnd(visibleSelection), &start, &end);
     return createMarkup(start, end, AnnotateForInterchange, ConvertBlocksToInlines::NotConvert, ResolveNonLocalURLs);
 }
 
 String FrameSelection::selectedHTMLForClipboard() const
 {
-    return extractSelectedHTMLAlgorithm<VisibleSelection::InDOMTree>(*this);
+    if (!RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
+        return extractSelectedHTMLAlgorithm<VisibleSelection::InDOMTree>(*this);
+    return extractSelectedHTMLAlgorithm<VisibleSelection::InComposedTree>(*this);
 }
 
 String FrameSelection::selectedText() const
 {
     return extractSelectedText(*this, TextIteratorDefaultBehavior);
 }
 
 String FrameSelection::selectedTextForClipboard() const
 {
     if (m_frame->settings() && m_frame->settings()->selectionIncludesAltImageText())
@@ skipping 288 matching lines @@
 
 void showTree(const blink::FrameSelection* sel)
 {
     if (sel)
         sel->showTreeForThis();
     else
         fprintf(stderr, "Cannot showTree for (nil) FrameSelection.\n");
 }
 
 #endif