It is dangerous to ignore SkRect::intersect's return value

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
 #define SkRect_DEFINED
 
@@ skipping 249 matching lines @@
     }
 
     bool containsNoEmptyCheck(const SkIRect& r) const {
         return containsNoEmptyCheck(r.fLeft, r.fTop, r.fRight, r.fBottom);
     }
 
     /** If r intersects this rectangle, return true and set this rectangle to that
         intersection, otherwise return false and do not change this rectangle.
         If either rectangle is empty, do nothing and return false.
     */
-    bool intersect(const SkIRect& r) {
+    bool SK_WARN_UNUSED_RESULT intersect(const SkIRect& r) {
         SkASSERT(&r);
         return this->intersect(r.fLeft, r.fTop, r.fRight, r.fBottom);
     }
 
     /** If rectangles a and b intersect, return true and set this rectangle to
         that intersection, otherwise return false and do not change this
         rectangle. If either rectangle is empty, do nothing and return false.
     */
-    bool intersect(const SkIRect& a, const SkIRect& b) {
+    bool SK_WARN_UNUSED_RESULT intersect(const SkIRect& a, const SkIRect& b) {
 
         if (!a.isEmpty() && !b.isEmpty() &&
                 a.fLeft < b.fRight && b.fLeft < a.fRight &&
                 a.fTop < b.fBottom && b.fTop < a.fBottom) {
             fLeft   = SkMax32(a.fLeft,   b.fLeft);
             fTop    = SkMax32(a.fTop,    b.fTop);
             fRight  = SkMin32(a.fRight,  b.fRight);
             fBottom = SkMin32(a.fBottom, b.fBottom);
             return true;
         }
         return false;
     }
 
     /** If rectangles a and b intersect, return true and set this rectangle to
         that intersection, otherwise return false and do not change this
         rectangle. For speed, no check to see if a or b are empty is performed.
         If either is, then the return result is undefined. In the debug build,
         we assert that both rectangles are non-empty.
     */
-    bool intersectNoEmptyCheck(const SkIRect& a, const SkIRect& b) {
+    bool SK_WARN_UNUSED_RESULT intersectNoEmptyCheck(const SkIRect& a, const SkIRect& b) {
         SkASSERT(!a.isEmpty() && !b.isEmpty());
 
         if (a.fLeft < b.fRight && b.fLeft < a.fRight &&
                 a.fTop < b.fBottom && b.fTop < a.fBottom) {
             fLeft   = SkMax32(a.fLeft,   b.fLeft);
             fTop    = SkMax32(a.fTop,    b.fTop);
             fRight  = SkMin32(a.fRight,  b.fRight);
             fBottom = SkMin32(a.fBottom, b.fBottom);
             return true;
         }
         return false;
     }
 
     /** If the rectangle specified by left,top,right,bottom intersects this rectangle,
         return true and set this rectangle to that intersection,
         otherwise return false and do not change this rectangle.
         If either rectangle is empty, do nothing and return false.
     */
-    bool intersect(int32_t left, int32_t top, int32_t right, int32_t bottom) {
+    bool SK_WARN_UNUSED_RESULT intersect(int32_t left, int32_t top, 
+                                         int32_t right, int32_t bottom) {
         if (left < right && top < bottom && !this->isEmpty() &&
                 fLeft < right && left < fRight && fTop < bottom && top < fBottom) {
             if (fLeft < left) fLeft = left;
             if (fTop < top) fTop = top;
             if (fRight > right) fRight = right;
             if (fBottom > bottom) fBottom = bottom;
             return true;
         }
         return false;
     }
 
     /** Returns true if a and b are not empty, and they intersect
      */
     static bool Intersects(const SkIRect& a, const SkIRect& b) {
         return  !a.isEmpty() && !b.isEmpty() &&              // check for empties
-        a.fLeft < b.fRight && b.fLeft < a.fRight &&
-        a.fTop < b.fBottom && b.fTop < a.fBottom;
+                a.fLeft < b.fRight && b.fLeft < a.fRight &&
+                a.fTop < b.fBottom && b.fTop < a.fBottom;
     }
 
     /**
      *  Returns true if a and b intersect. debug-asserts that neither are empty.
      */
     static bool IntersectsNoEmptyCheck(const SkIRect& a, const SkIRect& b) {
         SkASSERT(!a.isEmpty());
         SkASSERT(!b.isEmpty());
         return  a.fLeft < b.fRight && b.fLeft < a.fRight &&
                 a.fTop < b.fBottom && b.fTop < a.fBottom;
@@ skipping 303 matching lines @@
        moved outwards, making the rectangle wider. If dx is negative, then the
        sides are moved inwards, making the rectangle narrower. The same holds
        true for dy and the top and bottom.
     */
     void outset(SkScalar dx, SkScalar dy)  { this->inset(-dx, -dy); }
 
     /** If this rectangle intersects r, return true and set this rectangle to that
         intersection, otherwise return false and do not change this rectangle.
         If either rectangle is empty, do nothing and return false.
     */
-    bool intersect(const SkRect& r);
+    bool SK_WARN_UNUSED_RESULT intersect(const SkRect& r);
 
     /** If this rectangle intersects the rectangle specified by left, top, right, bottom,
         return true and set this rectangle to that intersection, otherwise return false
         and do not change this rectangle.
         If either rectangle is empty, do nothing and return false.
     */
-    bool intersect(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom);
+    bool SK_WARN_UNUSED_RESULT intersect(SkScalar left, SkScalar top, 
+                                         SkScalar right, SkScalar bottom);
 
     /**
      *  If rectangles a and b intersect, return true and set this rectangle to
      *  that intersection, otherwise return false and do not change this
      *  rectangle. If either rectangle is empty, do nothing and return false.
      */
-    bool intersect(const SkRect& a, const SkRect& b);
+    bool SK_WARN_UNUSED_RESULT intersect(const SkRect& a, const SkRect& b);
 
 
 private:
     static bool Intersects(SkScalar al, SkScalar at, SkScalar ar, SkScalar ab,
                            SkScalar bl, SkScalar bt, SkScalar br, SkScalar bb) {
         SkScalar L = SkMaxScalar(al, bl);
         SkScalar R = SkMinScalar(ar, br);
         SkScalar T = SkMaxScalar(at, bt);
         SkScalar B = SkMinScalar(ab, bb);
         return L < R && T < B;
@@ skipping 188 matching lines @@
      *  cast-safe way to treat the rect as an array of (4) SkScalars.
      */
     const SkScalar* asScalars() const { return &fLeft; }
 
     void dump(bool asHex) const;
     void dump() const { this->dump(false); }
     void dumpHex() const { this->dump(true); }
 };
 
 #endif