Improve caching of dashed paths in GrStencilAndCoverPathRenderer

src/gpu/GrStrokeInfo.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrStrokeInfo_DEFINED
 #define GrStrokeInfo_DEFINED
 
 #include "SkStrokeRec.h"
 #include "SkPathEffect.h"
 
+class GrUniqueKey;
+
 /*
  * GrStrokeInfo encapsulates all the pertinent infomation regarding the stroke. The SkStrokeRec
  * which holds information on fill style, width, miter, cap, and join. It also holds information
  * about the dash like intervals, count, and phase.
  */
 class GrStrokeInfo : public SkStrokeRec {
 public:
     GrStrokeInfo(SkStrokeRec::InitStyle style)
         : INHERITED(style)
         , fDashType(SkPathEffect::kNone_DashType) {
@@ skipping 29 matching lines @@
             fDashPhase = other.fDashPhase;
             fIntervals.reset(other.getDashCount());
             memcpy(fIntervals.get(), other.fIntervals.get(), fIntervals.count() * sizeof(SkScalar));
         } else {
             this->removeDash();
         }
         this->INHERITED::operator=(other);
         return *this;
     }
 
+    bool hasEqualEffect(const GrStrokeInfo& other) const {
+        if (this->isDashed() != other.isDashed()) {
+            return false;
+        }
+        if (this->isDashed()) {
+            if (fDashPhase != other.fDashPhase ||
+                fIntervals.count() != other.fIntervals.count() ||
+                memcmp(fIntervals.get(), other.fIntervals.get(),
+                       fIntervals.count() * sizeof(SkScalar)) != 0) {
+                return false;
+            }
+        }
+        return this->INHERITED::hasEqualEffect(other);
+    }
+
     /*
      * This functions takes in a patheffect and updates the dashing information if the path effect
      * is a Dash type. Returns true if the path effect is a dashed effect and we are stroking,
      * otherwise it returns false.
      */
     bool setDashInfo(const SkPathEffect* pe) {
         if (pe && !this->isFillStyle()) {
             SkPathEffect::DashInfo dashInfo;
             fDashType = pe->asADash(&dashInfo);
             if (SkPathEffect::kDash_DashType == fDashType) {
@@ skipping 47 matching lines @@
     }
 
     /** Applies the dash to a path, if the stroke info has dashing.
      * @return true if the dashing was applied (dst and dstStrokeInfo will be modified).
      *         false if the stroke info did not have dashing. The dst and dstStrokeInfo
      *               will be unmodified. The stroking in the SkStrokeRec might still
      *               be applicable.
      */
     bool applyDashToPath(SkPath* dst, GrStrokeInfo* dstStrokeInfo, const SkPath& src) const;
 
+    /**
+     * Computes the length of the data that will be written by asUniqueKeyFragment() function.
+     */
+    int computeUniqueKeyFragmentData32Cnt() const {
+        const int kSkScalarData32Cnt = sizeof(SkScalar) / sizeof(uint32_t);
+        // SkStrokeRec data: 32 bits for style+join+cap and 2 scalars for miter and width.
+        int strokeKeyData32Cnt = 1 + 2 * kSkScalarData32Cnt;
+
+        if (this->isDashed()) {
+            // One scalar for dash phase and one for each dash value.
+            strokeKeyData32Cnt += (1 + this->getDashCount()) * kSkScalarData32Cnt;
+        }
+        return strokeKeyData32Cnt;
+    }
+
+    /**
+     * Writes the object contents as uint32_t data, to be used with GrUniqueKey.
+     * Note: the data written does not encode the length, so care must be taken to ensure
+     * that the full unique key data is encoded properly. For example, GrStrokeInfo
+     * fragment can be placed last in the sequence, at fixed index.
+     */
+    void asUniqueKeyFragment(uint32_t*) const;
+
 private:
-    // Prevent accidental usage, not implemented for GrStrokeInfos.
+    // Prevent accidental usage, should use GrStrokeInfo::hasEqualEffect.
     bool hasEqualEffect(const SkStrokeRec& other) const;
 
     void init(const SkPaint& paint) {
         const SkPathEffect* pe = paint.getPathEffect();
         this->setDashInfo(pe);
     }
 
     SkPathEffect::DashType fDashType;
     SkScalar               fDashPhase;
     SkAutoSTArray<2, SkScalar> fIntervals;
     typedef SkStrokeRec INHERITED;
 };
 
 #endif