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

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

 /*
  * Copyright (C) 2007, 2008 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Google, Inc.  All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 458 matching lines @@
     ASSERT(layoutObject);
 
     // FIXME: trying to compute a device space transform at record time is wrong. All clients
     // should be updated to avoid relying on this information, and the method should be removed.
     AffineTransform ctm = deprecatedCalculateTransformToLayer(layoutObject) * SubtreeContentTransformScope::currentContentTransformation();
     ctm.scale(layoutObject->document().frameHost()->deviceScaleFactor());
 
     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;
 }
+
+}