Add absoluteSelectionBoundsOf() to GranularityStrategy class

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

Index: third_party/WebKit/Source/core/editing/VisibleUnits.cpp
diff --git a/third_party/WebKit/Source/core/editing/VisibleUnits.cpp b/third_party/WebKit/Source/core/editing/VisibleUnits.cpp
index 57dbb38ee7f74be217967fe113e58c6c2b01d9e5..0848cf9a17b34b007c51fe4327b1721751adc429 100644
--- a/third_party/WebKit/Source/core/editing/VisibleUnits.cpp
+++ b/third_party/WebKit/Source/core/editing/VisibleUnits.cpp
@@ -2552,12 +2552,44 @@ LayoutRect localCaretRectOfPositionTemplate(
                                       boxPosition.offsetInBox);
 }
 
+// This function was added because the caret rect that will be calcaulated by
+// using the line top value instead of the selection top.
+template <typename Strategy>
+LayoutRect localSelectionRectOfPositionTemplate(
+    const PositionWithAffinityTemplate<Strategy>& position,
+    LayoutObject*& layoutObject) {
+  LayoutRect rect = localCaretRectOfPositionTemplate(position, layoutObject);
+
+  if (rect.isEmpty())
+    return rect;
+
+  InlineBoxPosition boxPosition =
+      computeInlineBoxPosition(position.position(), position.affinity());

[yosin_UTC9, 2017/01/19 06:28:21]

This is second call of |computeInlineBoxPosition()| which is also called in
|localCaretRectOfPositionTemplate(position, layoutObject)| at L2561.
Since |computeInlineBoxPosition()| is expensive function we should avoid to call
twice.
Also, in ||localCaretRectOfPositionTemplate()|, we check nullability of
boxPosition.inlineBox

  InlineBoxPosition boxPosition =
      computeInlineBoxPosition(position.position(), position.affinity());
  if (boxPosition.inlineBox)
    layoutObject = LineLayoutAPIShim::layoutObjectFrom(
        boxPosition.inlineBox->getLineLayoutItem());

Given that, localSelectionRectOfPositionTemplate() should be something like
below:
Expand localCaretRectOfPositionTemplate() into
localSelectionRectOfPositionTemplate() and calculate BoxPosition once.
I'm not sure when BoxPosition.inlineBox isn't InlineTextBox.

  if (position.isNull()) {
    layoutObject = nullptr;
    return LayoutRect();
  }
  Node* node = position.anchorNode();
  layoutObject = node->layoutObject();
  if (!layoutObject)
    return LayoutRect();
  InlineBoxPosition boxPosition =
      computeInlineBoxPosition(position.position(), position.affinity());
  if (boxPosition.inlineBox)
    layoutObject = LineLayoutAPIShim::layoutObjectFrom(
        boxPosition.inlineBox->getLineLayoutItem());
  Rect rect = layoutObject->localCaretRect(boxPosition.inlineBox,
                                      boxPosition.offsetInBox);

  // What should we do if |boxPosition.inlineBox| isn't InlineTextBox?
  InlineTextBox* box = toInlineTextBox(boxPosition.inlineBox);

  if (layoutObject->style()->isHorizontalWritingMode()) {
    rect.setY(box->root().selectionTop());
    rect.setHeight(box->root().selectionHeight());
    return rect;
  }
  rect.setX(box->root().selectionTop());
  rect.setWidth(box->root().selectionHeight());
  return rect;
}

+
+  InlineTextBox* box = toInlineTextBox(boxPosition.inlineBox);
+  if (layoutObject->style()->isHorizontalWritingMode()) {
+    rect.setY(box->root().selectionTop());
+    rect.setHeight(box->root().selectionHeight());
+    return rect;
+  }
+
+  rect.setX(box->root().selectionTop());
+  rect.setWidth(box->root().selectionHeight());
+  return rect;
+}
+
 LayoutRect localCaretRectOfPosition(const PositionWithAffinity& position,
                                     LayoutObject*& layoutObject) {
   return localCaretRectOfPositionTemplate<EditingStrategy>(position,
                                                            layoutObject);
 }
 
+LayoutRect localSelectionRectOfPosition(const PositionWithAffinity& position,
+                                        LayoutObject*& layoutObject) {
+  return localSelectionRectOfPositionTemplate<EditingStrategy>(position,
+                                                               layoutObject);
+}
+
 LayoutRect localCaretRectOfPosition(
     const PositionInFlatTreeWithAffinity& position,
     LayoutObject*& layoutObject) {
@@ -3231,6 +3263,24 @@ IntRect absoluteCaretBoundsOf(const VisiblePosition& visiblePosition) {
   return absoluteCaretBoundsOfAlgorithm<EditingStrategy>(visiblePosition);
 }
 
+template <typename Strategy>
+static IntRect absoluteSelectionBoundsOfAlgorithm(
+    const VisiblePositionTemplate<Strategy>& visiblePosition) {
+  DCHECK(visiblePosition.isValid()) << visiblePosition;
+  LayoutObject* layoutObject;
+  LayoutRect localRect = localSelectionRectOfPosition(
+      visiblePosition.toPositionWithAffinity(), layoutObject);
+  if (localRect.isEmpty() || !layoutObject)
+    return IntRect();
+
+  return layoutObject->localToAbsoluteQuad(FloatRect(localRect))
+      .enclosingBoundingBox();
+}
+
+IntRect absoluteSelectionBoundsOf(const VisiblePosition& visiblePosition) {
+  return absoluteSelectionBoundsOfAlgorithm<EditingStrategy>(visiblePosition);
+}
+
 IntRect absoluteCaretBoundsOf(
     const VisiblePositionInFlatTree& visiblePosition) {
   return absoluteCaretBoundsOfAlgorithm<EditingInFlatTreeStrategy>(