Don't compute path keys for volatile paths in GrShape.

src/gpu/GrShape.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrShape.h"
 
 GrShape& GrShape::operator=(const GrShape& that) {
@@ skipping 114 matching lines @@
         case Type::kRRect:
             SkASSERT(!fInheritedKey.count());
             SkASSERT(0 == SkRRect::kSizeInMemory % sizeof(uint32_t));
             // + 1 for the direction, start index, and inverseness.
             return SkRRect::kSizeInMemory / sizeof(uint32_t) + 1;
         case Type::kLine:
             GR_STATIC_ASSERT(2 * sizeof(uint32_t) == sizeof(SkPoint));
             // 4 for the end points and 1 for the inverseness
             return 5;
         case Type::kPath: {
+            if (0 == fPathData.fGenID) {
+                return -1;
+            }
             int dataKeySize = path_key_from_data_size(fPathData.fPath);
             if (dataKeySize >= 0) {
                 return dataKeySize;
             }
-            if (0 == fPathData.fGenID) {
-                return -1;
-            }
             // The key is the path ID and fill type.
             return 2;
         }
     }
     SkFAIL("Should never get here.");
     return 0;
 }
 
 void GrShape::writeUnstyledKey(uint32_t* key) const {
     SkASSERT(this->unstyledKeySize());
@@ skipping 13 matching lines @@
                 *key |= fRRectData.fInverted ? (1 << 30) : 0;
                 *key++ |= fRRectData.fStart;
                 SkASSERT(fRRectData.fStart < 8);
                 break;
             case Type::kLine:
                 memcpy(key, fLineData.fPts, 2 * sizeof(SkPoint));
                 key += 4;
                 *key++ = fLineData.fInverted ? 1 : 0;
                 break;
             case Type::kPath: {
+                SkASSERT(fPathData.fGenID);
                 int dataKeySize = path_key_from_data_size(fPathData.fPath);
                 if (dataKeySize >= 0) {
                     write_path_key_from_data(fPathData.fPath, key);
                     return;
                 }
-                SkASSERT(fPathData.fGenID);
                 *key++ = fPathData.fGenID;
                 // We could canonicalize the fill rule for paths that don't differentiate between
                 // even/odd or winding fill (e.g. convex).
                 *key++ = this->path().getFillType();
                 break;
             }
         }
     }
     SkASSERT(key - origKey == this->unstyledKeySize());
 }
@@ skipping 340 matching lines @@
             fStyle = GrStyle::SimpleFill();
             return;
         }
     }
     // Only path effects could care about the order of the points. Otherwise canonicalize
     // the point order.
     if (pts[1].fY < pts[0].fY || (pts[1].fY == pts[0].fY && pts[1].fX < pts[0].fX)) {
         SkTSwap(pts[0], pts[1]);
     }
 }