Introduce visiblePositionOf() for Position and PositionInComposedTree

Source/core/editing/VisiblePosition.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Portions Copyright (c) 2011 Motorola Mobility, 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
@@ skipping 31 matching lines @@
 #include "wtf/text/CString.h"
 
 #ifndef NDEBUG
 #include <stdio.h>
 #endif
 
 namespace blink {
 
 using namespace HTMLNames;
 
-VisiblePosition::VisiblePosition(const Position &pos, TextAffinity affinity)
+VisiblePosition::VisiblePosition(const Position& position, TextAffinity affinity)
 {
-    init(pos, affinity);
-}
-
-VisiblePosition::VisiblePosition(const PositionInComposedTree& pos, TextAffinity affinity)
-{
-    init(pos, affinity);
+    // TODO(yosin) We should make |VisiblePosition| private and make this
+    // constructor to populate member variables by using |visiblePositionOf()|.
+    *this = visiblePositionOf(position, affinity);
 }
 
 VisiblePosition::VisiblePosition(const PositionWithAffinity& positionWithAffinity)
+    : VisiblePosition(positionWithAffinity.position(), positionWithAffinity.affinity())
 {
-    init(positionWithAffinity.position(), positionWithAffinity.affinity());
+}
+
+VisiblePosition VisiblePosition::createWithoutCanonicalization(const PositionWithAffinity& canonicalized)
+{
+    VisiblePosition visiblePosition;
+    visiblePosition.m_deepPosition = canonicalized.position();
+    visiblePosition.m_affinity = canonicalized.affinity();
+    return visiblePosition;
 }
 
 // TODO(yosin) We should move implementation of |skipToEndOfEditingBoundary()|
 // here to avoid forward declaration.
 static VisiblePosition skipToEndOfEditingBoundary(const VisiblePosition&, const Position& anchor);
 
 // TODO(yosin) We should move |nextPositionOf()| to "VisibleUnits.cpp".
 VisiblePosition nextPositionOf(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     VisiblePosition next(nextVisuallyDistinctCandidate(visiblePosition.deepEquivalent()), visiblePosition.affinity());
@@ skipping 580 matching lines @@
 {
     return canonicalPosition(position);
 }
 
 PositionInComposedTree canonicalPositionOf(const PositionInComposedTree& position)
 {
     return canonicalPosition(position);
 }
 
 template<typename Strategy>
-void VisiblePosition::init(const PositionAlgorithm<Strategy>& position, TextAffinity affinity)
+static PositionWithAffinityTemplate<Strategy> visiblePositionOfAlgorithm(const PositionAlgorithm<Strategy>& position, TextAffinity affinity)
 {
-    m_affinity = affinity;
-
-    PositionAlgorithm<Strategy> deepPosition = canonicalPosition(position);
-    m_deepPosition = toPositionInDOMTree(deepPosition);
-
-    if (m_affinity != TextAffinity::Upstream)
-        return;
-
-    if (isNull()) {
-        m_affinity = TextAffinity::Downstream;
-        return;
-    }
+    const PositionAlgorithm<Strategy> deepPosition = canonicalPosition(position);
+    if (deepPosition.isNull())
+        return PositionWithAffinityTemplate<Strategy>();
+    if (affinity == TextAffinity::Downstream)
+        return PositionWithAffinityTemplate<Strategy>(deepPosition);
 
     // When not at a line wrap, make sure to end up with
     // |TextAffinity::Downstream| affinity.
-    if (!inSameLine(PositionWithAffinityTemplate<Strategy>(deepPosition), PositionWithAffinityTemplate<Strategy>(deepPosition, TextAffinity::Upstream)))
-        return;
-    m_affinity = TextAffinity::Downstream;
+    if (inSameLine(PositionWithAffinityTemplate<Strategy>(deepPosition), PositionWithAffinityTemplate<Strategy>(deepPosition, TextAffinity::Upstream)))
+        return PositionWithAffinityTemplate<Strategy>(deepPosition);
+    return PositionWithAffinityTemplate<Strategy>(deepPosition, TextAffinity::Upstream);
+}
+
+VisiblePosition visiblePositionOf(const Position& position, TextAffinity affinity)
+{
+    return VisiblePosition::createWithoutCanonicalization(visiblePositionOfAlgorithm<EditingStrategy>(position, affinity));
+}
+
+VisiblePosition visiblePositionOf(const PositionInComposedTree& position, TextAffinity affinity)
+{
+    PositionInComposedTreeWithAffinity canonicalized = visiblePositionOfAlgorithm<EditingInComposedTreeStrategy>(position, affinity);
+    return VisiblePosition::createWithoutCanonicalization(PositionWithAffinity(toPositionInDOMTree(canonicalized.position()), canonicalized.affinity()));
 }
 
 UChar32 characterAfter(const VisiblePosition& visiblePosition)
 {
     // We canonicalize to the first of two equivalent candidates, but the second
     // of the two candidates is the one that will be inside the text node
     // containing the character after this visible position.
     Position pos = mostForwardCaretPosition(visiblePosition.deepEquivalent());
     if (!pos.isOffsetInAnchor())
         return 0;
@@ skipping 93 matching lines @@
     else
         fprintf(stderr, "Cannot showTree for (nil) VisiblePosition.\n");
 }
 
 void showTree(const blink::VisiblePosition& vpos)
 {
     vpos.showTreeForThis();
 }
 
 #endif