Detect empty (r)rects in GrShape.

src/gpu/GrShape.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrShape_DEFINED
 #define GrShape_DEFINED
 
@@ skipping 15 matching lines @@
  * to geometric information and is included in the new shape's key. When the same style is applied
  * to two shapes that reflect the same underlying geometry the computed keys of the stylized shapes
  * will be the same.
  *
  * Currently this can only be constructed from a rrect, though it can become a path by applying
  * style to the geometry. The idea is to expand this to cover most or all of the geometries that
  * have SkCanvas::draw APIs.
  */
 class GrShape {
 public:
-    GrShape(const SkPath& path)
+    GrShape() : fType(Type::kEmpty) {}
+
+    explicit GrShape(const SkPath& path)
             : fType(Type::kPath)
             , fPath(&path) {
         this->attemptToReduceFromPath();
     }
 
-    GrShape() : fType(Type::kEmpty) {}
+    explicit GrShape(const SkRRect& rrect)
+        : fType(Type::kRRect)
+        , fRRect(rrect) {
+        this->attemptToReduceFromRRect();
+    }
 
-    explicit GrShape(const SkRRect& rrect) : fType(Type::kRRect), fRRect(rrect) {}
-    explicit GrShape(const SkRect& rect) : fType(Type::kRRect), fRRect(SkRRect::MakeRect(rect)) {}
+    explicit GrShape(const SkRect& rect)
+        : fType(Type::kRRect)
+        , fRRect(SkRRect::MakeRect(rect)) {
+        this->attemptToReduceFromRRect();
+    }
 
     GrShape(const SkPath& path, const GrStyle& style)
         : fType(Type::kPath)
         , fPath(&path)
         , fStyle(style) {
         this->attemptToReduceFromPath();
     }
 
     GrShape(const SkRRect& rrect, const GrStyle& style)
         : fType(Type::kRRect)
         , fRRect(rrect)
-        , fStyle(style) {}
+        , fStyle(style) {
+        this->attemptToReduceFromRRect();
+    }
 
     GrShape(const SkRect& rect, const GrStyle& style)
         : fType(Type::kRRect)
         , fRRect(SkRRect::MakeRect(rect))
-        , fStyle(style) {}
+        , fStyle(style) {
+        this->attemptToReduceFromRRect();
+    }
 
     GrShape(const SkPath& path, const SkPaint& paint)
         : fType(Type::kPath)
         , fPath(&path)
         , fStyle(paint) {
         this->attemptToReduceFromPath();
     }
 
     GrShape(const SkRRect& rrect, const SkPaint& paint)
         : fType(Type::kRRect)
         , fRRect(rrect)
-        , fStyle(paint) {}
+        , fStyle(paint) {
+        this->attemptToReduceFromRRect();
+    }
 
     GrShape(const SkRect& rect, const SkPaint& paint)
         : fType(Type::kRRect)
         , fRRect(SkRRect::MakeRect(rect))
-        , fStyle(paint) {}
+        , fStyle(paint) {
+        this->attemptToReduceFromRRect();
+    }
 
     GrShape(const GrShape&);
     GrShape& operator=(const GrShape& that);
 
     ~GrShape() {
         if (Type::kPath == fType) {
             fPath.reset();
         }
     }
 
@@ skipping 85 matching lines @@
     void attemptToReduceFromPath() {
         SkASSERT(Type::kPath == fType);
         fType = AttemptToReduceFromPathImpl(*fPath.get(), &fRRect, fStyle.pathEffect(),
                                             fStyle.strokeRec());
         if (Type::kPath != fType) {
             fPath.reset();
             fInheritedKey.reset(0);
         }
     }
 
+    void attemptToReduceFromRRect() {
+        SkASSERT(Type::kRRect == fType);
+        SkASSERT(!fInheritedKey.count());
+        if (fRRect.isEmpty()) {
+            fType = Type::kEmpty;
+        }
+    }
+
     static Type AttemptToReduceFromPathImpl(const SkPath& path, SkRRect* rrect,
                                             const SkPathEffect* pe, const SkStrokeRec& strokeRec) {
         if (path.isEmpty()) {
             return Type::kEmpty;
         }
         if (path.isRRect(rrect)) {
+            SkASSERT(!rrect->isEmpty());
             return Type::kRRect;
         }
         SkRect rect;
         if (path.isOval(&rect)) {
             rrect->setOval(rect);
             return Type::kRRect;
         }
         bool closed;
         if (path.isRect(&rect, &closed, nullptr)) {
             if (closed || (!pe && strokeRec.isFillStyle())) {
                 rrect->setRect(rect);
                 return Type::kRRect;
             }
         }
         return Type::kPath;
     }
 
     Type                        fType;
     SkRRect                     fRRect;
     SkTLazy<SkPath>             fPath;
     GrStyle                     fStyle;
     SkAutoSTArray<8, uint32_t>  fInheritedKey;
 };
 #endif