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;
 
+
+    int computeUniqueKeyFragmentData32Cnt() const {

[egdaniel, 2015/05/15 15:28:53]

This function definitely needs some comments

[Kimmo Kinnunen, 2015/05/18 06:48:40]

Done.

+        const int kSkScalarData32Cnt = sizeof(SkScalar) / sizeof(uint32_t);
+        int strokeKeyData32Cnt = 1 + 2 * kSkScalarData32Cnt;

[egdaniel, 2015/05/15 15:28:53]

Is this trying to account for values that are is SkStrokeRec?

[Kimmo Kinnunen, 2015/05/18 06:48:40]

Yeah. I'll add the comments

+        if (this->isDashed()) {
+            strokeKeyData32Cnt += (1 + this->getDashCount()) * kSkScalarData32Cnt;

[egdaniel, 2015/05/15 15:28:53]

is the 1 for the phase here?

[Kimmo Kinnunen, 2015/05/18 06:48:40]

Yeah

+        }
+        return strokeKeyData32Cnt;
+    }
+
+    void asUniqueKeyFragment(uint32_t*) const;
+
 private:
 
     void init(const SkPaint& paint) {
         const SkPathEffect* pe = paint.getPathEffect();
         this->setDashInfo(pe);
     }
 
-    bool operator==(const SkStrokeRec& other) const;
-    bool operator!=(const SkStrokeRec& other) const;
-
     SkPathEffect::DashType fDashType;
     SkScalar               fDashPhase;
     SkAutoSTArray<2, SkScalar> fIntervals;
     typedef SkStrokeRec INHERITED;
 };
 
 #endif