Initial error handling code

include/core/SkRect.h

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkRect_DEFINED
@@ skipping 82 matching lines @@
      *  This is a specific "truncation" of the average, which is different than
      *  (bottom + top) / 2 when the sum is negative.
      */
     int centerY() const { return (fBottom + fTop) >> 1; }
 
     /**
      *  Return true if the rectangle's width or height are <= 0
      */
     bool isEmpty() const { return fLeft >= fRight || fTop >= fBottom; }
 
+    bool isInverted() const { return fLeft > fRight || fTop > fBottom; }
+
+    bool isValid() const {

[reed1, 2013/09/04 18:49:36]

Is this the same as

return this->width() >= 0 && this->height() >= 0;

[reed1, 2013/09/04 18:49:36]

Suggest we move this into SkValidatingUtils.h

[sugoi1, 2013/09/04 20:14:52]

Done.

[sugoi1, 2013/09/04 20:14:52]

Hmmm... I'm not sure. In the case of width(), for example, if "fRight - fLeft" >
SK_MaxS32, in the case where fRight is a valid large positive number and fLeft
is a valid large negative number, then the arithmetic should overflow into
negative numbers and make the width() test work, but is that behavior guaranteed
on all platforms ? Can we rely on common behavior for integer overflow and
should we trigger one on purpose when we can avoid it ?

+        return !isInverted() &&
+               // Make sure width() and height() are also valid
+               ((fLeft >= 0) || (fRight <= 0) || ((fRight - SK_MaxS32) <= fLeft)) &&
+               ((fTop >= 0) || (fBottom <= 0) || ((fBottom - SK_MaxS32) <= fTop));
+    }
+
     bool isLargest() const { return SK_MinS32 == fLeft &&
                                     SK_MinS32 == fTop &&
                                     SK_MaxS32 == fRight &&
                                     SK_MaxS32 == fBottom; }
 
     friend bool operator==(const SkIRect& a, const SkIRect& b) {
         return !memcmp(&a, &b, sizeof(a));
     }
 
     friend bool operator!=(const SkIRect& a, const SkIRect& b) {
@@ skipping 299 matching lines @@
               SkIntToScalar(irect.fRight),
               SkIntToScalar(irect.fBottom));
         return r;
     }
 
     /**
      *  Return true if the rectangle's width or height are <= 0
      */
     bool isEmpty() const { return fLeft >= fRight || fTop >= fBottom; }
 
+    bool isInverted() const { return fLeft > fRight || fTop > fBottom; }
+
+    bool isValid() const {

[reed1, 2013/09/04 18:49:36]

Given the size an somewhat arbitrary nature of "valid" for a rect, I suggest
this be moved into SkValidatinUtils.h. There we can explicitly document all of
the aspects of "validness" we care about.

[sugoi1, 2013/09/04 20:14:52]

Done.

+        return SkScalarIsFinite(fLeft) &&
+               SkScalarIsFinite(fTop) &&
+               SkScalarIsFinite(fRight) &&
+               SkScalarIsFinite(fBottom) &&
+               !isInverted() &&
+               // Make sure width() and height() are also valid
+               ((fLeft >= 0) || (fRight <= 0) || ((fRight - SK_ScalarMax) <= fLeft)) &&
+               ((fTop >= 0) || (fBottom <= 0) || ((fBottom - SK_ScalarMax) <= fTop)); }
     /**
      *  Returns true iff all values in the rect are finite. If any are
      *  infinite or NaN (or SK_FixedNaN when SkScalar is fixed) then this
      *  returns false.
      */
     bool isFinite() const {
 #ifdef SK_SCALAR_IS_FLOAT
         float accum = 0;
         accum *= fLeft;
         accum *= fTop;
@@ skipping 365 matching lines @@
      */
     void sort();
 
     /**
      *  cast-safe way to treat the rect as an array of (4) SkScalars.
      */
     const SkScalar* asScalars() const { return &fLeft; }
 };
 
 #endif