fix more tricky-float cases in SkRRect validate

src/core/SkRRect.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkRRect.h"
 #include "SkMatrix.h"
 
@@ skipping 99 matching lines @@
  *  TODO: clean this guy up and possibly add to SkScalar.h
  */
 static inline SkScalar SkScalarDecULP(SkScalar value) {
 #if SK_SCALAR_IS_FLOAT
         return SkBits2Float(SkFloat2Bits(value) - 1);
 #else
     #error "need impl for doubles"
 #endif
 }
 
-static SkScalar clamp_radius_add(SkScalar rad, SkScalar min, SkScalar max) {
-    SkASSERT(rad <= max - min);
-    if (min + rad > max) {
+ /**

[robertphillips, 2015/02/13 22:31:03]

missing spaces here ?

+ *  We need all combinations of predicates to be true to have a "safe" radius value.
+ */
+static SkScalar clamp_radius_check_predicates(SkScalar rad, SkScalar min, SkScalar max) {
+    SkASSERT(min < max);
+    if (rad > max - min || min + rad > max || max - rad < min) {
         rad = SkScalarDecULP(rad);
     }
     return rad;
-}
-
-static SkScalar clamp_radius_sub(SkScalar rad, SkScalar min, SkScalar max) {
-    SkASSERT(rad <= max - min);
-    if (max - rad < min) {
-        rad = SkScalarDecULP(rad);
-    }
-    return rad;
 }
 
 void SkRRect::setRectRadii(const SkRect& rect, const SkVector radii[4]) {
     if (rect.isEmpty() || !rect.isFinite()) {
         this->setEmpty();
         return;
     }
 
     if (!SkScalarsAreFinite(&radii[0].fX, 8)) {
         this->setRect(rect);    // devolve into a simple rect
@@ skipping 60 matching lines @@
         }
     }
 
     // skbug.com/3239 -- its possible that we can hit the following inconsistency:
     //     rad == bounds.bottom - bounds.top
     //     bounds.bottom - radius < bounds.top
     //     YIKES
     // We need to detect and "fix" this now, otherwise we can have the following wackiness:
     //     path.addRRect(rrect);
     //     rrect.rect() != path.getBounds()
-    fRadii[0].fX = clamp_radius_add(fRadii[0].fX, rect.fLeft, rect.fRight);
-    fRadii[0].fY = clamp_radius_add(fRadii[0].fY, rect.fTop, rect.fBottom);
-    fRadii[1].fX = clamp_radius_sub(fRadii[1].fX, rect.fLeft, rect.fRight);
-    fRadii[1].fY = clamp_radius_add(fRadii[1].fY, rect.fTop, rect.fBottom);
-    fRadii[2].fX = clamp_radius_sub(fRadii[2].fX, rect.fLeft, rect.fRight);
-    fRadii[2].fY = clamp_radius_sub(fRadii[2].fY, rect.fTop, rect.fBottom);
-    fRadii[3].fX = clamp_radius_add(fRadii[3].fX, rect.fLeft, rect.fRight);
-    fRadii[3].fY = clamp_radius_sub(fRadii[3].fY, rect.fTop, rect.fBottom);
-
+    for (int i = 0; i < 4; ++i) {
+        fRadii[i].fX = clamp_radius_check_predicates(fRadii[i].fX, rect.fLeft, rect.fRight);
+        fRadii[i].fY = clamp_radius_check_predicates(fRadii[i].fY, rect.fTop, rect.fBottom);
+    }
     // At this point we're either oval, simple, or complex (not empty or rect).
     this->computeType();
 
     SkDEBUGCODE(this->validate();)
 }
 
 // This method determines if a point known to be inside the RRect's bounds is
 // inside all the corners.
 bool SkRRect::checkCornerContainment(SkScalar x, SkScalar y) const {
     SkPoint canonicalPt; // (x,y) translated to one of the quadrants
@@ skipping 157 matching lines @@
     // use SkMatrix::rectStaysRect() to check for a valid transformation.
     if (!matrix_only_scale_and_translate(matrix)) {
         return false;
     }
 
     SkRect newRect;
     if (!matrix.mapRect(&newRect, fRect)) {
         return false;
     }
 
+    // The matrix may have scaled us to zero (or due to float madness, we now have collapsed

[robertphillips, 2015/02/13 22:31:03]

',' -> ')' ?

+    // some dimension of the rect, so we need to check for that.
+    if (newRect.isEmpty()) {
+        dst->setEmpty();
+        return true;
+    }
+
     // At this point, this is guaranteed to succeed, so we can modify dst.
     dst->fRect = newRect;
 
     // Since the only transforms that were allowed are scale and translate, the type
     // remains unchanged.
     dst->fType = fType;
 
     if (kOval_Type == fType) {
         for (int i = 0; i < 4; ++i) {
             dst->fRadii[i].fX = SkScalarHalf(newRect.width());
@@ skipping 111 matching lines @@
         }
         line.append("\n");
     }
     line.append("};");
     SkDebugf("%s\n", line.c_str());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
+/**
+ *  We need all combinations of predicates to be true to have a "safe" radius value.
+ */
+static void validate_radius_check_predicates(SkScalar rad, SkScalar min, SkScalar max) {
+    SkASSERT(min <= max);
+    SkASSERT(rad <= max - min);
+    SkASSERT(min + rad <= max);
+    SkASSERT(max - rad >= min);
+}
+
 void SkRRect::validate() const {
     bool allRadiiZero = (0 == fRadii[0].fX && 0 == fRadii[0].fY);
     bool allCornersSquare = (0 == fRadii[0].fX || 0 == fRadii[0].fY);
     bool allRadiiSame = true;
 
     for (int i = 1; i < 4; ++i) {
         if (0 != fRadii[i].fX || 0 != fRadii[i].fY) {
             allRadiiZero = false;
         }
 
@@ skipping 33 matching lines @@
             SkASSERT(!fRect.isEmpty());
             SkASSERT(!allRadiiZero && !allRadiiSame && !allCornersSquare);
             SkASSERT(patchesOfNine);
             break;
         case kComplex_Type:
             SkASSERT(!fRect.isEmpty());
             SkASSERT(!allRadiiZero && !allRadiiSame && !allCornersSquare);
             SkASSERT(!patchesOfNine);
             break;
     }
+
+    for (int i = 0; i < 4; ++i) {
+        validate_radius_check_predicates(fRadii[i].fX, fRect.fLeft, fRect.fRight);
+        validate_radius_check_predicates(fRadii[i].fY, fRect.fTop, fRect.fBottom);
+    }
 }
 #endif // SK_DEBUG
 
 ///////////////////////////////////////////////////////////////////////////////