Implement FloatRect::squaredDistanceTo function

third_party/WebKit/Source/platform/geometry/FloatRect.cpp

 /*
  * Copyright (C) 2003, 2006, 2007 Apple Inc.  All rights reserved.
  * Copyright (C) 2005 Nokia.  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 153 matching lines @@
 }
 
 void FloatRect::scale(float sx, float sy)
 {
     m_location.setX(x() * sx);
     m_location.setY(y() * sy);
     m_size.setWidth(width() * sx);
     m_size.setHeight(height() * sy);
 }
 
+float FloatRect::distanceTo(const FloatPoint& point)
+{
+    float distance = 0.f;
+    if (point.x() < this->x()) {

[fs, 2016/01/13 10:22:03]

I don't see the need for explicit this - here and elsewhere.

+        if (point.y() < this->y())
+            distance = (point - FloatPoint(this->x(), this->y())).diagonalLengthSquared();

[fs, 2016/01/13 10:22:03]

FloatRect has minXMinYCorner (etc.) which would make these slightly easier to
read IMHO.

+        else if (point.y() > this->maxY())
+            distance = (point - FloatPoint(this->x(), this->maxY())).diagonalLengthSquared();

[fs, 2016/01/13 10:22:03]

The 'corner' areas compute the squared distance while the other areas compute
"proper" distances. Squared distances often makes sense, but regardless all
cases should use the same convention. Calling the method just "distanceTo" I'd
expect the Euclidian norm though (else "squaredDistanceTo" if a squared distance
was returned.)

+        else
+            distance = this->x() - point.x();
+    } else if (point.x() > this->maxX()) {
+        if (point.y() < this->y())
+            distance = (point - FloatPoint(this->maxX(), this->y())).diagonalLengthSquared();
+        else if (point.y() > this->maxY())
+            distance = (point - FloatPoint(this->maxX(), this->maxY())).diagonalLengthSquared();
+        else
+            distance = point.x() - this->maxX();
+    } else {
+        if (point.y() < this->y())
+            distance = this->y() - point.y();
+        else if (point.y() > this->maxY())
+            distance = point.y() - this->maxY();
+        else
+            distance = 0.f;
+    }
+
+    return distance;
+}
+
 FloatRect unionRect(const Vector<FloatRect>& rects)
 {
     FloatRect result;
 
     size_t count = rects.size();
     for (size_t i = 0; i < count; ++i)
         result.unite(rects[i]);
 
     return result;
 }
@@ skipping 34 matching lines @@
         return FloatRect();
 
     float widthScale = destRect.width() / srcRect.width();
     float heightScale = destRect.height() / srcRect.height();
     return FloatRect(destRect.x() + (r.x() - srcRect.x()) * widthScale,
         destRect.y() + (r.y() - srcRect.y()) * heightScale,
         r.width() * widthScale, r.height() * heightScale);
 }
 
 }