2016-03-02T18:53:01 LayoutPosition

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

 /*
  * Copyright (C) 2004, 2005, 2006, 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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/editing/Position.h"
 
+#include "core/dom/Text.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/TextAffinity.h"
 #include "wtf/text/CString.h"
-#include <stdio.h>
 #include <ostream> // NOLINT
 
 namespace blink {
 
 #if DCHECK_IS_ON()
 static bool canBeAnchorNode(Node* node)
 {
     return !node || !node->isPseudoElement();
 }
 #endif
@@ skipping 24 matching lines @@
     DCHECK_GE(offset, 1);
     return PositionTemplate<Strategy>(anchorNode, PositionAnchorType::AfterAnchor);
 }
 
 template <typename Strategy>
 PositionTemplate<Strategy>::PositionTemplate(Node* anchorNode, PositionAnchorType anchorType)
     : m_anchorNode(anchorNode)
     , m_offset(0)
     , m_anchorType(anchorType)
 {
-    if (!m_anchorNode) {
-        m_anchorType = PositionAnchorType::OffsetInAnchor;
-        return;
-    }
+    DCHECK(m_anchorNode);
+    DCHECK_NE(m_anchorType, PositionAnchorType::OffsetInAnchor);
     if (m_anchorNode->isTextNode()) {
-        DCHECK(m_anchorType == PositionAnchorType::BeforeAnchor || m_anchorType == PositionAnchorType::AfterAnchor);
+        DCHECK(isBeforeAnchor() || isAfterAnchor()) << m_anchorType;
         return;
     }
     if (m_anchorNode->isDocumentNode()) {
         // Since |RangeBoundaryPoint| can't represent before/after Document, we
         // should not use them.
         DCHECK(isBeforeChildren() || isAfterChildren()) << m_anchorType;
         return;
     }
+
 #if DCHECK_IS_ON()
     DCHECK(canBeAnchorNode(m_anchorNode.get()));
 #endif
     DCHECK_NE(m_anchorType, PositionAnchorType::OffsetInAnchor);
 }
 
 template <typename Strategy>
 PositionTemplate<Strategy>::PositionTemplate(Node* anchorNode, int offset)
     : m_anchorNode(anchorNode)
     , m_offset(offset)
@@ skipping 285 matching lines @@
     if (isNull())
         return true;
     // TODO(yosin) We should use |Strategy::lastOffsetForEditing()| instead of
     // DOM tree version.
     return !Strategy::parent(*anchorNode()) && m_offset >= EditingStrategy::lastOffsetForEditing(anchorNode());
 }
 
 template <typename Strategy>
 void PositionTemplate<Strategy>::debugPosition(const char* msg) const
 {
-    static const char* const anchorTypes[] = {
-        "OffsetInAnchor",
-        "BeforeAnchor",
-        "AfterAnchor",
-        "BeforeChildren",
-        "AfterChildren",
-        "Invalid",
-    };
-
-    if (isNull()) {
-        fprintf(stderr, "Position [%s]: null\n", msg);
-        return;
-    }
-
-    const char* anchorType = anchorTypes[std::min(static_cast<size_t>(m_anchorType), WTF_ARRAY_LENGTH(anchorTypes) - 1)];
-    if (m_anchorNode->isTextNode()) {
-        fprintf(stderr, "Position [%s]: %s [%p] %s, (%s) at %d\n", msg, anchorNode()->nodeName().utf8().data(), anchorNode(), anchorType, m_anchorNode->nodeValue().utf8().data(), m_offset);
-        return;
-    }
-
-    fprintf(stderr, "Position [%s]: %s [%p] %s at %d\n", msg, anchorNode()->nodeName().utf8().data(), anchorNode(), anchorType, m_offset);
+    VLOG(0) << msg << ' ' << *this;
 }
 
 PositionInFlatTree toPositionInFlatTree(const Position& pos)
 {
     if (pos.isNull())
         return PositionInFlatTree();
 
     if (pos.isOffsetInAnchor()) {
         Node* anchor = pos.anchorNode();
         if (anchor->offsetInCharacters())
@@ skipping 60 matching lines @@
         // |child| is null when the position is at the end of the children.
         // <div>foo|</div>
         return Position(anchorNode, PositionAnchorType::AfterChildren);
     }
     default:
         ASSERT_NOT_REACHED();
         return Position();
     }
 }
 
+// |normalize()| returns an equivalent position with |BeforeNode| position, or
+// |OffsetInAnchor| for |Text| node if possible, otherwise |normalize()| returns
+//  - |AfterAnchor| if anchor node has no next siblings.
+//  - |BeforeChildren| if anchor node has no children.
+// |normalized()| never return |AfterChildren| position.
+template <typename Strategy>
+PositionTemplate<Strategy> PositionTemplate<Strategy>::normalize(const PositionTemplate<Strategy>& position)
+{
+    if (position.isNull())
+        return PositionTemplate<Strategy>();
+    Node* const anchorNode = position.anchorNode();
+    switch (position.anchorType()) {
+    case PositionAnchorType::AfterAnchor:
+        if (Node* nextSibling = Strategy::nextSibling(*anchorNode))
+            return normalize(beforeNode(nextSibling));
+        if (anchorNode->isTextNode())
+            return PositionTemplate<Strategy>(anchorNode, toText(anchorNode)->length());
+        return position;
+    case PositionAnchorType::AfterChildren:
+        ASSERT(!anchorNode->isTextNode());
+        if (Node* lastChild = Strategy::lastChild(*anchorNode))
+            return normalize(afterNode(lastChild));
+        return firstPositionInNode(anchorNode);
+    case PositionAnchorType::BeforeAnchor:
+        if (anchorNode->isTextNode())
+            return PositionTemplate<Strategy>(anchorNode, 0);
+        return position;
+    case PositionAnchorType::BeforeChildren:
+        ASSERT(!anchorNode->isTextNode());
+        if (Node* firstChild = Strategy::firstChild(*anchorNode))
+            return normalize(beforeNode(firstChild));
+        return position;
+    case PositionAnchorType::OffsetInAnchor: {
+        const int offsetInContainer = position.offsetInContainerNode();
+        if (anchorNode->isTextNode()) {
+            const Text& textNode = *toText(anchorNode);
+            if (offsetInContainer < static_cast<int>(textNode.length()))
+                return position;
+            return normalize(afterNode(anchorNode));
+        }
+        if (Node* child = Strategy::childAt(*anchorNode, offsetInContainer))
+            return normalize(beforeNode(child));
+        if (Node* lastChild = Strategy::lastChild(*anchorNode))
+            return normalize(afterNode(lastChild));
+        return firstPositionInNode(anchorNode);
+    }
+    }
+    ASSERT_NOT_REACHED();
+    return PositionTemplate<Strategy>();
+}
+
 #ifndef NDEBUG
 
 template <typename Strategy>
 void PositionTemplate<Strategy>::formatForDebugger(char* buffer, unsigned length) const
 {
     StringBuilder result;
 
     if (isNull()) {
         result.appendLiteral("<null>");
     } else {
         char s[1024];
         result.appendLiteral("offset ");
         result.appendNumber(m_offset);
         result.appendLiteral(" of ");
         anchorNode()->formatForDebugger(s, sizeof(s));
         result.append(s);
     }
 
     strncpy(buffer, result.toString().utf8().data(), length - 1);
 }
 
 template <typename Strategy>
-void PositionTemplate<Strategy>::showAnchorTypeAndOffset() const
-{
-    switch (anchorType()) {
-    case PositionAnchorType::OffsetInAnchor:
-        fputs("offset", stderr);
-        break;
-    case PositionAnchorType::BeforeChildren:
-        fputs("beforeChildren", stderr);
-        break;
-    case PositionAnchorType::AfterChildren:
-        fputs("afterChildren", stderr);
-        break;
-    case PositionAnchorType::BeforeAnchor:
-        fputs("before", stderr);
-        break;
-    case PositionAnchorType::AfterAnchor:
-        fputs("after", stderr);
-        break;
-    }
-    fprintf(stderr, ", offset:%d\n", m_offset);
-}
-
-template <typename Strategy>
 void PositionTemplate<Strategy>::showTreeForThis() const
 {
     if (!anchorNode())
         return;
     anchorNode()->showTreeForThis();
-    showAnchorTypeAndOffset();
+    VLOG(0) << *this;
 }
 
 template <typename Strategy>
 void PositionTemplate<Strategy>::showTreeForThisInFlatTree() const
 {
     if (!anchorNode())
         return;
     anchorNode()->showTreeForThisInFlatTree();
-    showAnchorTypeAndOffset();
+    VLOG(0) << *this;
 }
 
 #endif
 
 template <typename PositionType>
 static std::ostream& printPosition(std::ostream& ostream, const PositionType& position)
 {
     if (position.isNull())
         return ostream << "null";
     ostream << position.anchorNode() << "@";
@@ skipping 44 matching lines @@
 
 void showTree(const blink::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
     else
         fprintf(stderr, "Cannot showTree for (nil)\n");
 }
 
 #endif