Ensure valid VisiblePosition input for absoluteCaretBoundsOf

third_party/WebKit/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 2918 matching lines @@
 }
 
 bool isVisuallyEquivalentCandidate(const PositionInFlatTree& position)
 {
     return isVisuallyEquivalentCandidateAlgorithm<EditingInFlatTreeStrategy>(position);
 }
 
 template <typename Strategy>
 static IntRect absoluteCaretBoundsOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
-    // TODO(xiaochengh): Ensure that this function is called with a valid
-    // |visiblePosition|, and add |DCHECK(visiblePosition.isValid())|;
+    DCHECK(visiblePosition.isValid()) << visiblePosition;
     LayoutObject* layoutObject;
     LayoutRect localRect = localCaretRectOfPosition(visiblePosition.toPositionWithAffinity(), layoutObject);
     if (localRect.isEmpty() || !layoutObject)
         return IntRect();
 
     return layoutObject->localToAbsoluteQuad(FloatRect(localRect)).enclosingBoundingBox();
 }
 
 IntRect absoluteCaretBoundsOf(const VisiblePosition& visiblePosition)
 {
     return absoluteCaretBoundsOfAlgorithm<EditingStrategy>(visiblePosition);
 }
 
 IntRect absoluteCaretBoundsOf(const VisiblePositionInFlatTree& visiblePosition)
 {
     return absoluteCaretBoundsOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition);
 }
 
 template <typename Strategy>
+static IntRect absoluteCaretBoundsOfAlgorithmDeprecated(const VisiblePositionTemplate<Strategy>& visiblePosition)

[yosin_UTC9, 2016/09/27 10:09:50]

Let's make absoluteCaretBoundsOfAlgorithm to take PositionWithAffinity to avoid
copy & paste.


IntRect absoluteCaretBoundsOf(const VisiblePosition& visiblePosition)
{
  DCHECK(visiblePosition.isValid()) << visiblePositon;
  return
absoluteCaretBoundsOfAlgorithm<EditingStrategy>(visiblePosition.toPositionWithAffinity());
}

IntRect absoluteCaretBoundsOfDeprecated(const VisiblePosition& visiblePosition)
{
  return
absoluteCaretBoundsOfAlgorithm<EditingStrategy>(visiblePosition.toPositionWithAffinity());
}


When we have VP::toPositionWithAffiniktyDeprecated(), we could write:

IntRect absoluteCaretBoundsOf(const VisiblePosition& visiblePosition)
{
  return
absoluteCaretBoundsOfAlgorithm<EditingStrategy>(visiblePosition.toPositionWithAffinity());
}

IntRect absoluteCaretBoundsOfDeprecated(const VisiblePosition& visiblePosition)
{
  return
absoluteCaretBoundsOfAlgorithm<EditingStrategy>(visiblePosition.toPositionWithAffinityDeprecated());
}

+{
+    LayoutObject* layoutObject;
+    LayoutRect localRect = localCaretRectOfPosition(visiblePosition.toPositionWithAffinity(), layoutObject);
+    if (localRect.isEmpty() || !layoutObject)
+        return IntRect();
+
+    return layoutObject->localToAbsoluteQuad(FloatRect(localRect)).enclosingBoundingBox();
+}
+
+IntRect absoluteCaretBoundsOfDeprecated(const VisiblePosition& visiblePosition)
+{
+    return absoluteCaretBoundsOfAlgorithmDeprecated<EditingStrategy>(visiblePosition);
+}
+
+template <typename Strategy>
 static VisiblePositionTemplate<Strategy> skipToEndOfEditingBoundary(const VisiblePositionTemplate<Strategy>& pos, const PositionTemplate<Strategy>& anchor)
 {
     DCHECK(pos.isValid()) << pos;
     if (pos.isNull())
         return pos;
 
     ContainerNode* highestRoot = highestEditableRoot(anchor);
     ContainerNode* highestRootOfPos = highestEditableRoot(pos.deepEquivalent());
 
     // Return |pos| itself if the two are from the very same editable region,
@@ skipping 510 matching lines @@
 {
     return previousPositionOfAlgorithm<EditingStrategy>(visiblePosition, rule);
 }
 
 VisiblePositionInFlatTree previousPositionOf(const VisiblePositionInFlatTree& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition, rule);
 }
 
 } // namespace blink