Make inSameLine() in VisibleUnits.cpp to work with positions in composed tree

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 760 matching lines @@
     }
 
     return honorEditingBoundaryAtOrBeforeOf(visPos, c.position());
 }
 
 static PositionWithAffinity startOfLine(const PositionWithAffinity& currentPosition)
 {
     return startOfLine(currentPosition, UseInlineBoxOrdering);
 }
 
+static PositionInComposedTreeWithAffinity startOfLine(const PositionInComposedTreeWithAffinity& currentPosition)
+{
+    return startOfLine(currentPosition, UseInlineBoxOrdering);
+}
+
 // FIXME: Rename this function to reflect the fact it ignores bidi levels.
 VisiblePosition startOfLine(const VisiblePosition& currentPosition)
 {
     return VisiblePosition(startOfLine(PositionWithAffinity(currentPosition.deepEquivalent(), currentPosition.affinity()), UseInlineBoxOrdering));
 }
 
 VisiblePosition logicalStartOfLine(const VisiblePosition& currentPosition)
 {
     return VisiblePosition(startOfLine(PositionWithAffinity(currentPosition.deepEquivalent(), currentPosition.affinity()), UseLogicalOrdering));
 }
@@ skipping 102 matching lines @@
 VisiblePosition logicalEndOfLine(const VisiblePosition& currentPosition)
 {
     return endOfLine(currentPosition, UseLogicalOrdering);
 }
 
 template <typename PositionWithAffinityType>
 bool inSameLineAlgorithm(const PositionWithAffinityType& position1, const PositionWithAffinityType& position2)
 {
     if (position1.isNull() || position2.isNull())
         return false;
-    PositionWithAffinity startOfLine1 = startOfLine(position1);
-    PositionWithAffinity startOfLine2 = startOfLine(position2);
+    PositionWithAffinityType startOfLine1 = startOfLine(position1);
+    PositionWithAffinityType startOfLine2 = startOfLine(position2);
     if (startOfLine1 == startOfLine2)
         return true;
     typename PositionWithAffinityType::PositionType canonicalized1 = canonicalPositionOf(startOfLine1.position());
     if (canonicalized1 == startOfLine2.position())
         return true;
     return canonicalized1 == canonicalPositionOf(startOfLine2.position());
 }
 
 bool inSameLine(const PositionWithAffinity& a, const PositionWithAffinity& b)
 {
     return inSameLineAlgorithm(a, b);
 }
 
+bool inSameLine(const PositionInComposedTreeWithAffinity& position1, const PositionInComposedTreeWithAffinity& position2)
+{
+    return inSameLineAlgorithm(position1, position2);
+}
+
 bool inSameLine(const VisiblePosition &a, const VisiblePosition &b)
 {
     return inSameLine(PositionWithAffinity(a.deepEquivalent(), a.affinity()), PositionWithAffinity(b.deepEquivalent(), b.affinity()));
 }
 
 bool isStartOfLine(const VisiblePosition &p)
 {
     return p.isNotNull() && p == startOfLine(p);
 }
 
@@ skipping 524 matching lines @@
     HitTestRequest request = HitTestRequest::Move | HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::IgnoreClipping;
     HitTestResult result(request, contentsPoint);
     frame->document()->layoutView()->hitTest(result);
 
     if (Node* node = result.innerNode())
         return frame->selection().selection().visiblePositionRespectingEditingBoundary(result.localPoint(), node);
     return VisiblePosition();
 }
 
 }