Add absoluteSelectionBoundsOf() to GranularityStrategy class

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
@@ skipping 2534 matching lines @@
       computeInlineBoxPosition(position.position(), position.affinity());
 
   if (boxPosition.inlineBox)
     layoutObject = LineLayoutAPIShim::layoutObjectFrom(
         boxPosition.inlineBox->getLineLayoutItem());
 
   return layoutObject->localCaretRect(boxPosition.inlineBox,
                                       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());
+
+  InlineTextBox* box = toInlineTextBox(boxPosition.inlineBox);
+  if (layoutObject->style()->isHorizontalWritingMode()) {
+    rect.setY(box->root().selectionTop());
+    rect.setHeight(box->root().selectionHeight());

[yosin_UTC9, 2017/01/10 04:20:01]

nit: early return style is better

if (layoutObject->style()->isHorizontalWritingMode()) {
  rect.setY ...
  rect.stHeight ...
  return rect;
}

rect.setX(box->root().selectionTop());
rect.setWidth(box->root().selectionHeight());
return rect;

[joone, 2017/01/10 18:19:46]

Done.

+  } else {
+    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) {
   return localCaretRectOfPositionTemplate<EditingInFlatTreeStrategy>(
       position, layoutObject);
 }
 
 static LayoutUnit boundingBoxLogicalHeight(LayoutObject* o,
                                            const LayoutRect& rect) {
   return o->style()->isHorizontalWritingMode() ? rect.height() : rect.width();
@@ skipping 653 matching lines @@
     return IntRect();
 
   return layoutObject->localToAbsoluteQuad(FloatRect(localRect))
       .enclosingBoundingBox();
 }
 
 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>(
       visiblePosition);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> skipToEndOfEditingBoundary(
     const VisiblePositionTemplate<Strategy>& pos,
     const PositionTemplate<Strategy>& anchor) {
@@ skipping 604 matching lines @@
 
 VisiblePositionInFlatTree previousPositionOf(
     const VisiblePositionInFlatTree& visiblePosition,
     EditingBoundaryCrossingRule rule) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(
       visiblePosition.deepEquivalent(), rule);
 }
 
 }  // namespace blink