CANCELLED Merge SelectionAdjuster into VisibleSelection part 2

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

 /*
  * Copyright (C) 2004, 2005, 2006 Apple Computer, 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 12 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/editing/VisibleSelection.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/Range.h"
 #include "core/editing/EditingUtilities.h"
-#include "core/editing/SelectionAdjuster.h"
 #include "core/editing/iterators/CharacterIterator.h"
 #include "platform/geometry/LayoutPoint.h"
 #include "wtf/Assertions.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/CharacterNames.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
+namespace {
+
+enum class AdjustDirection { kAdjustNone, kAdjustStart, kAdjustEnd };
+
+Node* enclosingShadowHost(Node* node) {
+  for (Node* runner = node; runner;
+       runner = FlatTreeTraversal::parent(*runner)) {
+    if (isShadowHost(runner))
+      return runner;
+  }
+  return nullptr;
+}
+
+bool isEnclosedBy(const PositionInFlatTree& position, const Node& node) {
+  DCHECK(position.isNotNull());
+  Node* anchorNode = position.anchorNode();
+  if (anchorNode == node)
+    return !position.isAfterAnchor() && !position.isBeforeAnchor();
+
+  return FlatTreeTraversal::isDescendantOf(*anchorNode, node);
+}
+
+bool isSelectionBoundary(const Node& node) {
+  return isHTMLTextAreaElement(node) || isHTMLInputElement(node) ||
+         isHTMLSelectElement(node);
+}
+
+Node* enclosingShadowHostForStart(const PositionInFlatTree& position) {
+  Node* node = position.nodeAsRangeFirstNode();
+  if (!node)
+    return nullptr;
+  Node* shadowHost = enclosingShadowHost(node);
+  if (!shadowHost)
+    return nullptr;
+  if (!isEnclosedBy(position, *shadowHost))
+    return nullptr;
+  return isSelectionBoundary(*shadowHost) ? shadowHost : nullptr;
+}
+
+Node* enclosingShadowHostForEnd(const PositionInFlatTree& position) {
+  Node* node = position.nodeAsRangeLastNode();
+  if (!node)
+    return nullptr;
+  Node* shadowHost = enclosingShadowHost(node);
+  if (!shadowHost)
+    return nullptr;
+  if (!isEnclosedBy(position, *shadowHost))
+    return nullptr;
+  return isSelectionBoundary(*shadowHost) ? shadowHost : nullptr;
+}
+
+PositionInFlatTree adjustPositionInFlatTreeForStart(
+    const PositionInFlatTree& position,
+    Node* shadowHost) {
+  if (isEnclosedBy(position, *shadowHost)) {
+    if (position.isBeforeChildren())
+      return PositionInFlatTree::beforeNode(shadowHost);
+    return PositionInFlatTree::afterNode(shadowHost);
+  }
+
+  // We use |firstChild|'s after instead of beforeAllChildren for backward
+  // compatibility. The positions are same but the anchors would be different,
+  // and selection painting uses anchor nodes.
+  if (Node* firstChild = FlatTreeTraversal::firstChild(*shadowHost))
+    return PositionInFlatTree::beforeNode(firstChild);
+  return PositionInFlatTree();
+}
+
+Position adjustPositionForEnd(const Position& currentPosition,
+                              Node* startContainerNode) {
+  TreeScope& treeScope = startContainerNode->treeScope();
+
+  DCHECK(currentPosition.computeContainerNode()->treeScope() != treeScope);
+
+  if (Node* ancestor = treeScope.ancestorInThisScope(
+          currentPosition.computeContainerNode())) {
+    if (ancestor->contains(startContainerNode))
+      return Position::afterNode(ancestor);
+    return Position::beforeNode(ancestor);
+  }
+
+  if (Node* lastChild = treeScope.rootNode().lastChild())
+    return Position::afterNode(lastChild);
+
+  return Position();
+}
+
+PositionInFlatTree adjustPositionInFlatTreeForEnd(
+    const PositionInFlatTree& position,
+    Node* shadowHost) {
+  if (isEnclosedBy(position, *shadowHost)) {
+    if (position.isAfterChildren())
+      return PositionInFlatTree::afterNode(shadowHost);
+    return PositionInFlatTree::beforeNode(shadowHost);
+  }
+
+  // We use |lastChild|'s after instead of afterAllChildren for backward
+  // compatibility. The positions are same but the anchors would be different,
+  // and selection painting uses anchor nodes.
+  if (Node* lastChild = FlatTreeTraversal::lastChild(*shadowHost))
+    return PositionInFlatTree::afterNode(lastChild);
+  return PositionInFlatTree();
+}
+
+Position adjustPositionForStart(const Position& currentPosition,
+                                Node* endContainerNode) {
+  TreeScope& treeScope = endContainerNode->treeScope();
+
+  DCHECK(currentPosition.computeContainerNode()->treeScope() != treeScope);
+
+  if (Node* ancestor = treeScope.ancestorInThisScope(
+          currentPosition.computeContainerNode())) {
+    if (ancestor->contains(endContainerNode))
+      return Position::beforeNode(ancestor);
+    return Position::afterNode(ancestor);
+  }
+
+  if (Node* firstChild = treeScope.rootNode().firstChild())
+    return Position::beforeNode(firstChild);
+
+  return Position();
+}
+
+std::pair<AdjustDirection, Position> adjustmentToAvoidCrossingShadowBoundaries(
+    const VisibleSelection& selection) {
+  // Note: |m_selectionType| isn't computed yet.
+  DCHECK(selection.base().isNotNull());
+  DCHECK(selection.extent().isNotNull());
+  DCHECK(selection.start().isNotNull());
+  DCHECK(selection.end().isNotNull());
+
+  // TODO(hajimehoshi): Checking treeScope is wrong when a node is
+  // distributed, but we leave it as it is for backward compatibility.
+  if (selection.start().anchorNode()->treeScope() ==
+      selection.end().anchorNode()->treeScope())
+    return std::make_pair(AdjustDirection::kAdjustNone, Position());
+
+  if (selection.isBaseFirst()) {
+    const Position& newEnd = adjustPositionForEnd(
+        selection.end(), selection.start().computeContainerNode());
+    return std::make_pair(AdjustDirection::kAdjustEnd, newEnd);
+  }
+
+  const Position& newStart = adjustPositionForStart(
+      selection.start(), selection.end().computeContainerNode());
+  return std::make_pair(AdjustDirection::kAdjustStart, newStart);
+}
+
+// This function is called twice. The first is called when |m_start| and |m_end|
+// or |m_extent| are same, and the second when |m_start| and |m_end| are changed
+// after downstream/upstream.
+std::pair<AdjustDirection, PositionInFlatTree>
+adjustmentToAvoidCrossingShadowBoundaries(
+    const VisibleSelectionInFlatTree& selection) {
+  Node* const shadowHostStart = enclosingShadowHostForStart(selection.start());
+  Node* const shadowHostEnd = enclosingShadowHostForEnd(selection.end());
+  if (shadowHostStart == shadowHostEnd)
+    return std::make_pair(AdjustDirection::kAdjustNone, PositionInFlatTree());
+
+  if (selection.isBaseFirst()) {
+    Node* const shadowHost = shadowHostStart ? shadowHostStart : shadowHostEnd;
+    const PositionInFlatTree& newEnd =
+        adjustPositionInFlatTreeForEnd(selection.end(), shadowHost);
+    return std::make_pair(AdjustDirection::kAdjustEnd, newEnd);
+  }
+  Node* const shadowHost = shadowHostEnd ? shadowHostEnd : shadowHostStart;
+  const PositionInFlatTree& newStart =
+      adjustPositionInFlatTreeForStart(selection.start(), shadowHost);
+  return std::make_pair(AdjustDirection::kAdjustStart, newStart);
+}
+
+}  // namespace
+
 template <typename Strategy>
 VisibleSelectionTemplate<Strategy>::VisibleSelectionTemplate()
     : m_affinity(TextAffinity::Downstream),
       m_selectionType(NoSelection),
       m_baseIsFirst(true),
       m_isDirectional(false),
       m_granularity(CharacterGranularity),
       m_hasTrailingWhitespace(false) {}
 
 template <typename Strategy>
@@ skipping 755 matching lines @@
 
 void showTree(const blink::VisibleSelectionInFlatTree& sel) {
   sel.showTreeForThis();
 }
 
 void showTree(const blink::VisibleSelectionInFlatTree* sel) {
   if (sel)
     sel->showTreeForThis();
 }
 #endif