Return EphemeralRange from Editor::findRangeOfString.

third_party/WebKit/Source/core/editing/Editor.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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
@@ skipping 1127 matching lines @@
         ASSERT(frame().document());
         ApplyStyleCommand::create(*frame().document(), blockStyle.get(), editingAction)->apply();
     }
 
     // Set the remaining style as the typing style.
     frame().selection().setTypingStyle(typingStyle);
 }
 
 bool Editor::findString(const String& target, FindOptions options)
 {
-    VisibleSelection selection = frame().selection().selection();
+    const VisibleSelection& selection = frame().selection().selection();
+    const EphemeralRange& resultRange = findRangeOfString(
+        target,
+        EphemeralRange(selection.start(), selection.end()),
+        static_cast<FindOptions>(options | FindAPICall));
 
-    // TODO(yosin) We should make |findRangeOfString()| to return
-    // |EphemeralRange| rather than|Range| object.
-    RefPtrWillBeRawPtr<Range> resultRange = findRangeOfString(target, EphemeralRange(selection.start(), selection.end()), static_cast<FindOptions>(options | FindAPICall));
-
-    if (!resultRange)
+    if (resultRange.isCollapsed())
         return false;
 
-    frame().selection().setSelection(VisibleSelection(EphemeralRange(resultRange.get())));
+    frame().selection().setSelection(VisibleSelection(resultRange));
     frame().selection().revealSelection();
     return true;
 }
 
 template <typename Strategy>
-static PassRefPtrWillBeRawPtr<Range> findStringAndScrollToVisibleAlgorithm(Editor& editor, const String& target, const EphemeralRangeTemplate<Strategy>& previousMatch, FindOptions options)
+static EphemeralRangeTemplate<Strategy> findStringAndScrollToVisibleAlgorithm(Editor& editor, const String& target, const EphemeralRangeTemplate<Strategy>& previousMatch, FindOptions options)
 {
-    RefPtrWillBeRawPtr<Range> nextMatch = editor.findRangeOfString(target, previousMatch, options);
-    if (!nextMatch)
-        return nullptr;
+    const EphemeralRangeTemplate<Strategy>& nextMatch = editor.findRangeOfString(target, previousMatch, options);
+    if (nextMatch.isCollapsed())
+        return EphemeralRangeTemplate<Strategy>();
 
-    nextMatch->firstNode()->layoutObject()->scrollRectToVisible(LayoutRect(nextMatch->boundingBox()),
-        ScrollAlignment::alignCenterIfNeeded, ScrollAlignment::alignCenterIfNeeded, UserScroll);
+    if (auto* layoutObject = nextMatch.startPosition().nodeAsRangeFirstNode()->layoutObject()) {
+        layoutObject->scrollRectToVisible(
+            LayoutRect(nextMatch.textBoundingBox()),
+            ScrollAlignment::alignCenterIfNeeded,
+            ScrollAlignment::alignCenterIfNeeded,
+            UserScroll);
+    }
 
-    return nextMatch.release();
+    return nextMatch;
 }
 
-PassRefPtrWillBeRawPtr<Range> Editor::findStringAndScrollToVisible(const String& target, Range* range, FindOptions options)
+EphemeralRange Editor::findStringAndScrollToVisible(const String& target, const EphemeralRange& range, FindOptions options)
 {
-    if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
-        return findStringAndScrollToVisibleAlgorithm<EditingInComposedTreeStrategy>(*this, target, EphemeralRangeInComposedTree(range), options);
-    return findStringAndScrollToVisibleAlgorithm<EditingStrategy>(*this, target, EphemeralRange(range), options);
+    return findStringAndScrollToVisibleAlgorithm(*this, target, range, options);
 }
 
-// TODO(yosin) We should return |EphemeralRange| rather than |Range|. We use
-// |Range| object for checking whether start and end position crossing shadow
-// boundaries, however we can do it without |Range| object.
+EphemeralRangeInComposedTree Editor::findStringAndScrollToVisible(const String& target, const EphemeralRangeInComposedTree& range, FindOptions options)
+{
+    ASSERT(RuntimeEnabledFeatures::selectionForComposedTreeEnabled());
+    return findStringAndScrollToVisibleAlgorithm(*this, target, range, options);
+}
+
+// This function checks whether start and end position of the |range|
+// crossing shadow boundaries.
+// It should be equivalent to !Range::create(ephemeralRange)->collapsed().
 template <typename Strategy>
-static PassRefPtrWillBeRawPtr<Range> findStringBetweenPositions(const String& target, const EphemeralRangeTemplate<Strategy>& referenceRange, FindOptions options)
+static bool rangeBoundariesAreValid(const EphemeralRangeTemplate<Strategy>& range)

[yosin_UTC9, 2015/11/04 07:11:06]

This function doesn't check shadow boundary crossing as comment mentioned.

I talked with shadow DOM experts offline, there are no easy way to detect
crossing shadow boundary.

I think we want to have a way not to detect crossing shadow boundary.

+{
+    const Node* endRootContainer = range.endPosition().computeContainerNode();

[yosin_UTC9, 2015/11/04 07:11:06]

When start is null position, end must be null position too, as of ctor of
EphemeralRange.
So, this check could be:

if (range.isNull())
  return false;

+    const Node* startRootContainer = range.startPosition().computeContainerNode();
+    if (!startRootContainer || !endRootContainer)
+        return false;
+
+    ASSERT(Strategy::commonAncestor(*startRootContainer, *endRootContainer));
+    return range.startPosition().compareTo(range.endPosition()) < 0;
+}
+
+template <typename Strategy>
+static EphemeralRangeTemplate<Strategy> findStringBetweenPositions(const String& target, const EphemeralRangeTemplate<Strategy>& referenceRange, FindOptions options)
 {
     EphemeralRangeTemplate<Strategy> searchRange(referenceRange);
 
     bool forward = !(options & Backwards);
 
     while (true) {
-        EphemeralRangeTemplate<Strategy> resultRange = findPlainText(searchRange, target, options);
+        const EphemeralRangeTemplate<Strategy>& resultRange = findPlainText(searchRange, target, options);
         if (resultRange.isCollapsed())
-            return nullptr;
+            return EphemeralRangeTemplate<Strategy>();
 
-        RefPtrWillBeRawPtr<Range> rangeObject = Range::create(resultRange.document(), toPositionInDOMTree(resultRange.startPosition()), toPositionInDOMTree(resultRange.endPosition()));
-        if (!rangeObject->collapsed())
-            return rangeObject.release();
+        if (rangeBoundariesAreValid(resultRange))

[yosin_UTC9, 2015/11/04 07:11:06]

Just return found range even if it is crossing shadow boundary.
Composed tree version can represent found text spans multiple trees.

According to
https://www.chromestatus.com/metrics/feature/popularity#WindowFindWithShadowTree
we can switch window.find() to composed tree version or drop shadow tree support
in DOM version.

+            return resultRange;
 
         // Found text spans over multiple TreeScopes. Since it's impossible to
         // return such section as a Range, we skip this match and seek for the
         // next occurrence.
         // TODO(yosin) Handle this case.
         if (forward) {
             // TODO(yosin) We should use |PositionMoveType::Character|
             // for |nextPositionOf()|.
             searchRange = EphemeralRangeTemplate<Strategy>(nextPositionOf(resultRange.startPosition(), PositionMoveType::CodePoint), searchRange.endPosition());
         } else {
             // TODO(yosin) We should use |PositionMoveType::Character|
             // for |previousPositionOf()|.
             searchRange = EphemeralRangeTemplate<Strategy>(searchRange.startPosition(), previousPositionOf(resultRange.endPosition(), PositionMoveType::CodePoint));
         }
     }
 
     ASSERT_NOT_REACHED();
-    return nullptr;
+    return EphemeralRangeTemplate<Strategy>();
 }
 
 template <typename Strategy>
-static PassRefPtrWillBeRawPtr<Range> findRangeOfStringAlgorithm(Document& document, const String& target, const EphemeralRangeTemplate<Strategy>& referenceRange, FindOptions options)
+static EphemeralRangeTemplate<Strategy> findRangeOfStringAlgorithm(Document& document, const String& target, const EphemeralRangeTemplate<Strategy>& referenceRange, FindOptions options)
 {
     if (target.isEmpty())
-        return nullptr;
+        return EphemeralRangeTemplate<Strategy>();
 
     // Start from an edge of the reference range. Which edge is used depends on
     // whether we're searching forward or backward, and whether startInSelection
     // is set.
     EphemeralRangeTemplate<Strategy> documentRange = EphemeralRangeTemplate<Strategy>::rangeOfContents(document);
     EphemeralRangeTemplate<Strategy> searchRange(documentRange);
 
     bool forward = !(options & Backwards);
     bool startInReferenceRange = false;
     if (referenceRange.isNotNull()) {
         startInReferenceRange = options & StartInSelection;
         if (forward && startInReferenceRange)
             searchRange = EphemeralRangeTemplate<Strategy>(referenceRange.startPosition(), documentRange.endPosition());
         else if (forward)
             searchRange = EphemeralRangeTemplate<Strategy>(referenceRange.endPosition(), documentRange.endPosition());
         else if (startInReferenceRange)
             searchRange = EphemeralRangeTemplate<Strategy>(documentRange.startPosition(), referenceRange.endPosition());
         else
             searchRange = EphemeralRangeTemplate<Strategy>(documentRange.startPosition(), referenceRange.startPosition());
     }
 
-    RefPtrWillBeRawPtr<Range> resultRange = findStringBetweenPositions(target, searchRange, options);
+    EphemeralRangeTemplate<Strategy> resultRange = findStringBetweenPositions(target, searchRange, options);
 
     // If we started in the reference range and the found range exactly matches
     // the reference range, find again. Build a selection with the found range
     // to remove collapsed whitespace. Compare ranges instead of selection
     // objects to ignore the way that the current selection was made.
-    if (resultRange && startInReferenceRange && normalizeRange(EphemeralRangeTemplate<Strategy>(resultRange.get())) == referenceRange) {
+    if (!resultRange.isCollapsed() && startInReferenceRange && normalizeRange(resultRange) == referenceRange) {
         if (forward)
-            searchRange = EphemeralRangeTemplate<Strategy>(fromPositionInDOMTree<Strategy>(resultRange->endPosition()), searchRange.endPosition());
+            searchRange = EphemeralRangeTemplate<Strategy>(resultRange.endPosition(), searchRange.endPosition());
         else
-            searchRange = EphemeralRangeTemplate<Strategy>(searchRange.startPosition(), fromPositionInDOMTree<Strategy>(resultRange->startPosition()));
+            searchRange = EphemeralRangeTemplate<Strategy>(searchRange.startPosition(), resultRange.startPosition());
         resultRange = findStringBetweenPositions(target, searchRange, options);
     }
 
-    if (!resultRange && options & WrapAround)
+    if (resultRange.isCollapsed() && options & WrapAround)
         return findStringBetweenPositions(target, documentRange, options);
 
-    return resultRange.release();
+    return resultRange;
 }
 
-PassRefPtrWillBeRawPtr<Range> Editor::findRangeOfString(const String& target, const EphemeralRange& reference, FindOptions options)
+EphemeralRange Editor::findRangeOfString(const String& target, const EphemeralRange& reference, FindOptions options)
 {
     return findRangeOfStringAlgorithm<EditingStrategy>(*frame().document(), target, reference, options);
 }
 
-PassRefPtrWillBeRawPtr<Range> Editor::findRangeOfString(const String& target, const EphemeralRangeInComposedTree& reference, FindOptions options)
+EphemeralRangeInComposedTree Editor::findRangeOfString(const String& target, const EphemeralRangeInComposedTree& reference, FindOptions options)
 {
     return findRangeOfStringAlgorithm<EditingInComposedTreeStrategy>(*frame().document(), target, reference, options);
 }
 
 void Editor::setMarkedTextMatchesAreHighlighted(bool flag)
 {
     if (flag == m_areMarkedTextMatchesHighlighted)
         return;
 
     m_areMarkedTextMatchesHighlighted = flag;
@@ skipping 19 matching lines @@
 }
 
 DEFINE_TRACE(Editor)
 {
     visitor->trace(m_frame);
     visitor->trace(m_lastEditCommand);
     visitor->trace(m_mark);
 }
 
 } // namespace blink