Fix invalid selection produced when dragging mouse outside the SVG text element

third_party/WebKit/Source/core/layout/svg/SVGLayoutSupport.cpp

Index: third_party/WebKit/Source/core/layout/svg/SVGLayoutSupport.cpp
diff --git a/third_party/WebKit/Source/core/layout/svg/SVGLayoutSupport.cpp b/third_party/WebKit/Source/core/layout/svg/SVGLayoutSupport.cpp
index 32073042bd914cd8999f8fd2c593feade0f70a23..568ebd694085286b1009ecd107a99b76b57dee73 100644
--- a/third_party/WebKit/Source/core/layout/svg/SVGLayoutSupport.cpp
+++ b/third_party/WebKit/Source/core/layout/svg/SVGLayoutSupport.cpp
@@ -476,4 +476,58 @@ float SVGLayoutSupport::calculateScreenFontSizeScalingFactor(const LayoutObject*
     return narrowPrecisionToFloat(sqrt((pow(ctm.xScale(), 2) + pow(ctm.yScale(), 2)) / 2));
 }
 
+LayoutObject* SVGLayoutSupport::findClosestLayoutSVGText(LayoutObject* layoutObject, const FloatPoint& point)
+{
+    // Try to search closest LayoutSVGText on sub-tree of `layoutObject`.

[fs, 2016/01/19 16:12:46]

"Try to find the closest LayoutSVGText in the subtree rooted at |layoutObject|."

+    // When closest LayoutObject hasn't LayoutSVGText object, try to search on other LayoutObjects

[fs, 2016/01/19 16:12:46]

LayoutSVGText's are not treat specially in any way, it's just that if a
LayoutSVGText is the closest on this level, then no further search is required.
At least that's how the code is currently written.

+    // overlapped which store on the vector called `overlappedObjects` that they are candidates.
+    // If not find LayoutSVGText object on candidates, After all return nullptr.
+    LayoutObject* closestLayoutObject = nullptr;
+    float closestDistance = std::numeric_limits<float>::max();
+    Vector<LayoutObject*> overlappedObjects;
+    for (LayoutObject* child = layoutObject->slowLastChild(); child; child = child->previousSibling()) {
+        if (!child->isSVGContainer() && !child->isSVGText())
+            continue;
+        if (child->isSVGHiddenContainer())
+            continue;
+        if (!child->localToParentTransform().isInvertible())
+            continue;
+
+        FloatRect boundingBox = child->objectBoundingBox();
+        FloatPoint childLocalPoint = child->localToParentTransform().inverse().mapPoint(point);
+        float distance = boundingBox.squaredDistanceTo(childLocalPoint);
+
+        if (distance <= closestDistance) {
+            // The reason is that if the closest LayoutObject is not found LayoutSVGText, try to find
+            // LayoutSVGText object on other LayoutObjects overlapped by closest LayoutObject
+            if (closestLayoutObject && boundingBox.contains(closestLayoutObject->objectBoundingBox())) {

[fs, 2016/01/19 16:12:46]

To re-iterate: I don't think that 'overlaps' is a very interesting metric if
searching "globally".

(Also, this would only be interesting for containers - right? Suggest that the
Vector should store only container references.)

Maybe it would be easier to just "queue" containers that are closer than any
LayoutSVGText and then sort the vector on <distance, child-index> (hopefully
using a stable sort means only the first is needed as a sort key.)

So a structure like:

for (...) {
  if (child->isSVGText()) {
    <compute distance>
    if (distance >= closestDistance)
      continue;
    <clear set of containers with potentially closer LayoutSVGTexts>
    <update distance and closest>
    continue;
  }
  if (child->isSVGContainer() && !child->isSVGHiddenContainer()) {
    <compute distance>
    if (distance >= closestDistance)
      continue;
    <add to set of containers with potentially closer LayoutSVGTexts>
  }
}
... return LayoutSVGText if closest ...
... sort set of containers by increasing distance ...
iterate (containers)
  recurse into container

Does that match your intention by any chance? (The top comment sounds a bit like
it.)

+                overlappedObjects.append(child);
+                continue;
+            }
+
+            overlappedObjects.clear();
+
+            closestLayoutObject = child;
+            closestDistance = distance;
+        }
+    }
+
+    if (!closestLayoutObject || closestLayoutObject->isSVGText())
+        return closestLayoutObject;
+
+    FloatPoint childLocalPoint = closestLayoutObject->localToParentTransform().inverse().mapPoint(point);
+    if (LayoutObject* result = findClosestLayoutSVGText(closestLayoutObject, childLocalPoint))
+        return result;
+
+    // No find LayoutSVGText on closest LayoutObject, after all try to search on other LayoutObjects which store
+    // on vector called `overlappedObjects`.
+    for (LayoutObject* overlappedObject : overlappedObjects) {
+        childLocalPoint = overlappedObject->localToParentTransform().inverse().mapPoint(point);
+        if (LayoutObject* result = findClosestLayoutSVGText(overlappedObject, childLocalPoint))
+            return result;
+    }
+
+    return nullptr;
+}
+
 }