Move parentEditingBoundary() to VisibileUnits.cpp from Position.cpp.

Source/core/editing/VisibleUnits.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 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 437 matching lines @@
     rightWordBreak = visiblePosition.honorEditingBoundaryAtOrBefore(rightWordBreak);
 
     // FIXME: How should we handle a non-editable position?
     if (rightWordBreak.isNull() && isEditablePosition(visiblePosition.deepEquivalent())) {
         TextDirection blockDirection = directionOfEnclosingBlock(visiblePosition.deepEquivalent());
         rightWordBreak = blockDirection == LTR ? endOfEditableContent(visiblePosition) : startOfEditableContent(visiblePosition);
     }
     return rightWordBreak;
 }
 
+template <typename Strategy>
+static ContainerNode* nonShadowBoundaryParentNode(Node* node)
+{
+    ContainerNode* parent = Strategy::parent(*node);
+    return parent && !parent->isShadowRoot() ? parent : nullptr;
+}
+
+template <typename Strategy>
+static Node* parentEditingBoundary(const PositionAlgorithm<Strategy>& position)
+{
+    Node* const anchorNode = position.anchorNode();
+    if (!anchorNode)
+        return nullptr;
+
+    Node* documentElement = anchorNode->document().documentElement();
+    if (!documentElement)
+        return nullptr;
+
+    Node* boundary = position.computeContainerNode();
+    while (boundary != documentElement && nonShadowBoundaryParentNode<Strategy>(boundary) && anchorNode->hasEditableStyle() == Strategy::parent(*boundary)->hasEditableStyle())
+        boundary = nonShadowBoundaryParentNode<Strategy>(boundary);
+
+    return boundary;
+}
 
 enum BoundarySearchContextAvailability { DontHaveMoreContext, MayHaveMoreContext };
 
 typedef unsigned (*BoundarySearchFunction)(const UChar*, unsigned length, unsigned offset, BoundarySearchContextAvailability, bool& needMoreContext);
 
 static VisiblePosition previousBoundary(const VisiblePosition& c, BoundarySearchFunction searchFunction)
 {
     Position pos = c.deepEquivalent();
     Node* boundary = parentEditingBoundary(pos);
     if (!boundary)
@@ skipping 1454 matching lines @@
 {
     return mostBackwardCaretPosition<EditingStrategy>(position, rule);
 }
 
 PositionInComposedTree mostBackwardCaretPosition(const PositionInComposedTree& position, EditingBoundaryCrossingRule rule)
 {
     return mostBackwardCaretPosition<EditingInComposedTreeStrategy>(position, rule);
 }
 
 }