diff --git a/src/core/SkColorMatrixFilterRowMajor255.cpp b/src/core/SkColorMatrixFilterRowMajor255.cpp
index 9c9aa1a..59b3f3c 100644
--- a/src/core/SkColorMatrixFilterRowMajor255.cpp
+++ b/src/core/SkColorMatrixFilterRowMajor255.cpp
@@ -255,9 +255,9 @@
 
     // We could implement the constant input->constant output optimization but haven't. Other
     // optimizations would be matrix-dependent.
-    ColorMatrixEffect(const SkScalar matrix[20]) : INHERITED(kNone_OptimizationFlags) {
+    ColorMatrixEffect(const SkScalar matrix[20])
+    : INHERITED(kColorMatrixEffect_ClassID, kNone_OptimizationFlags) {
         memcpy(fMatrix, matrix, sizeof(SkScalar) * 20);
-        this->initClassID<ColorMatrixEffect>();
     }
 
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
diff --git a/src/effects/GrAlphaThresholdFragmentProcessor.cpp b/src/effects/GrAlphaThresholdFragmentProcessor.cpp
index 34e9cdb..e1badf7 100644
--- a/src/effects/GrAlphaThresholdFragmentProcessor.cpp
+++ b/src/effects/GrAlphaThresholdFragmentProcessor.cpp
@@ -107,7 +107,7 @@
 }
 GrAlphaThresholdFragmentProcessor::GrAlphaThresholdFragmentProcessor(
         const GrAlphaThresholdFragmentProcessor& src)
-        : INHERITED(src.optimizationFlags())
+        : INHERITED(kGrAlphaThresholdFragmentProcessor_ClassID, src.optimizationFlags())
         , fImage(src.fImage)
         , fColorXform(src.fColorXform)
         , fMask(src.fMask)
@@ -115,7 +115,6 @@
         , fOuterThreshold(src.fOuterThreshold)
         , fImageCoordTransform(src.fImageCoordTransform)
         , fMaskCoordTransform(src.fMaskCoordTransform) {
-    this->initClassID<GrAlphaThresholdFragmentProcessor>();
     this->addTextureSampler(&fImage);
     this->addTextureSampler(&fMask);
     this->addCoordTransform(&fImageCoordTransform);
diff --git a/src/effects/GrAlphaThresholdFragmentProcessor.h b/src/effects/GrAlphaThresholdFragmentProcessor.h
index 3b64951..2d2b58a 100644
--- a/src/effects/GrAlphaThresholdFragmentProcessor.h
+++ b/src/effects/GrAlphaThresholdFragmentProcessor.h
@@ -44,7 +44,7 @@
                                       sk_sp<GrColorSpaceXform> colorXform,
                                       sk_sp<GrTextureProxy> mask, float innerThreshold,
                                       float outerThreshold, const SkIRect& bounds)
-            : INHERITED(kNone_OptimizationFlags)
+            : INHERITED(kGrAlphaThresholdFragmentProcessor_ClassID, kNone_OptimizationFlags)
             , fImage(std::move(image))
             , fColorXform(colorXform)
             , fMask(std::move(mask))
@@ -58,7 +58,6 @@
         this->addTextureSampler(&fMask);
         this->addCoordTransform(&fImageCoordTransform);
         this->addCoordTransform(&fMaskCoordTransform);
-        this->initClassID<GrAlphaThresholdFragmentProcessor>();
     }
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
     void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
diff --git a/src/effects/GrCircleBlurFragmentProcessor.cpp b/src/effects/GrCircleBlurFragmentProcessor.cpp
index 68955f2..5a825f4 100644
--- a/src/effects/GrCircleBlurFragmentProcessor.cpp
+++ b/src/effects/GrCircleBlurFragmentProcessor.cpp
@@ -318,12 +318,11 @@
 }
 GrCircleBlurFragmentProcessor::GrCircleBlurFragmentProcessor(
         const GrCircleBlurFragmentProcessor& src)
-        : INHERITED(src.optimizationFlags())
+        : INHERITED(kGrCircleBlurFragmentProcessor_ClassID, src.optimizationFlags())
         , fCircleRect(src.fCircleRect)
         , fTextureRadius(src.fTextureRadius)
         , fSolidRadius(src.fSolidRadius)
         , fBlurProfileSampler(src.fBlurProfileSampler) {
-    this->initClassID<GrCircleBlurFragmentProcessor>();
     this->addTextureSampler(&fBlurProfileSampler);
 }
 std::unique_ptr<GrFragmentProcessor> GrCircleBlurFragmentProcessor::clone() const {
diff --git a/src/effects/GrCircleBlurFragmentProcessor.h b/src/effects/GrCircleBlurFragmentProcessor.h
index e98714b..6f209c9 100644
--- a/src/effects/GrCircleBlurFragmentProcessor.h
+++ b/src/effects/GrCircleBlurFragmentProcessor.h
@@ -31,13 +31,13 @@
     GrCircleBlurFragmentProcessor(SkRect circleRect, float textureRadius, float solidRadius,
                                   sk_sp<GrTextureProxy> blurProfileSampler,
                                   GrResourceProvider* resourceProvider)
-            : INHERITED((OptimizationFlags)kCompatibleWithCoverageAsAlpha_OptimizationFlag)
+            : INHERITED(kGrCircleBlurFragmentProcessor_ClassID,
+                        (OptimizationFlags)kCompatibleWithCoverageAsAlpha_OptimizationFlag)
             , fCircleRect(circleRect)
             , fTextureRadius(textureRadius)
             , fSolidRadius(solidRadius)
             , fBlurProfileSampler(std::move(blurProfileSampler)) {
         this->addTextureSampler(&fBlurProfileSampler);
-        this->initClassID<GrCircleBlurFragmentProcessor>();
     }
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
     void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
diff --git a/src/effects/SkArithmeticImageFilter.cpp b/src/effects/SkArithmeticImageFilter.cpp
index 1bc3d06..27bf28e 100644
--- a/src/effects/SkArithmeticImageFilter.cpp
+++ b/src/effects/SkArithmeticImageFilter.cpp
@@ -350,13 +350,12 @@
     // This could implement the const input -> const output optimization but it's unlikely to help.
     ArithmeticFP(float k1, float k2, float k3, float k4, bool enforcePMColor,
                  std::unique_ptr<GrFragmentProcessor> dst)
-            : INHERITED(kNone_OptimizationFlags)
+            : INHERITED(kArithmeticFP_ClassID, kNone_OptimizationFlags)
             , fK1(k1)
             , fK2(k2)
             , fK3(k3)
             , fK4(k4)
             , fEnforcePMColor(enforcePMColor) {
-        this->initClassID<ArithmeticFP>();
         SkASSERT(dst);
         SkDEBUGCODE(int dstIndex =) this->registerChildProcessor(std::move(dst));
         SkASSERT(0 == dstIndex);
diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index 242b398..ca7de71 100644
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -974,12 +974,11 @@
 GrRectBlurEffect::GrRectBlurEffect(const SkRect& rect, float sigma,
                                    sk_sp<GrTextureProxy> blurProfile,
                                    GrSLPrecision precision)
-        : INHERITED(kCompatibleWithCoverageAsAlpha_OptimizationFlag)
+        : INHERITED(kGrRectBlurEffect_ClassID, kCompatibleWithCoverageAsAlpha_OptimizationFlag)
         , fRect(rect)
         , fSigma(sigma)
         , fBlurProfileSampler(std::move(blurProfile))
         , fPrecision(precision) {
-    this->initClassID<GrRectBlurEffect>();
     this->addTextureSampler(&fBlurProfileSampler);
 }
 
@@ -1206,11 +1205,10 @@
 
 GrRRectBlurEffect::GrRRectBlurEffect(float sigma, const SkRRect& rrect,
                                      sk_sp<GrTextureProxy> ninePatchProxy)
-        : INHERITED(kCompatibleWithCoverageAsAlpha_OptimizationFlag)
+        : INHERITED(kGrRRectBlurEffect_ClassID, kCompatibleWithCoverageAsAlpha_OptimizationFlag)
         , fRRect(rrect)
         , fSigma(sigma)
         , fNinePatchSampler(std::move(ninePatchProxy)) {
-    this->initClassID<GrRRectBlurEffect>();
     this->addTextureSampler(&fNinePatchSampler);
 }
 
diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp
index 97d1831..67db24e 100644
--- a/src/effects/SkDisplacementMapEffect.cpp
+++ b/src/effects/SkDisplacementMapEffect.cpp
@@ -464,7 +464,7 @@
         sk_sp<GrTextureProxy> color,
         sk_sp<GrColorSpaceXform> colorSpaceXform,
         const SkISize& colorDimensions)
-        : INHERITED(OptimizationFlags(color->config()))
+        : INHERITED(kGrDisplacementMapEffect_ClassID, OptimizationFlags(color->config()))
         , fDisplacementTransform(offsetMatrix, displacement.get())
         , fDisplacementSampler(displacement)
         , fColorTransform(color.get())
@@ -475,7 +475,6 @@
         , fXChannelSelector(xChannelSelector)
         , fYChannelSelector(yChannelSelector)
         , fScale(scale) {
-    this->initClassID<GrDisplacementMapEffect>();
     this->addCoordTransform(&fDisplacementTransform);
     this->addTextureSampler(&fDisplacementSampler);
     this->addCoordTransform(&fColorTransform);
@@ -483,7 +482,8 @@
 }
 
 GrDisplacementMapEffect::GrDisplacementMapEffect(const GrDisplacementMapEffect& that)
-        : INHERITED(OptimizationFlags(that.fColorSampler.proxy()->config()))
+        : INHERITED(kGrDisplacementMapEffect_ClassID,
+                    OptimizationFlags(that.fColorSampler.proxy()->config()))
         , fDisplacementTransform(that.fDisplacementTransform)
         , fDisplacementSampler(that.fDisplacementSampler)
         , fColorTransform(that.fColorTransform)
@@ -493,7 +493,6 @@
         , fXChannelSelector(that.fXChannelSelector)
         , fYChannelSelector(that.fYChannelSelector)
         , fScale(that.fScale) {
-    this->initClassID<GrDisplacementMapEffect>();
     this->addCoordTransform(&fDisplacementTransform);
     this->addTextureSampler(&fDisplacementSampler);
     this->addCoordTransform(&fColorTransform);
diff --git a/src/effects/SkHighContrastFilter.cpp b/src/effects/SkHighContrastFilter.cpp
index 7618861..1d67b3f 100644
--- a/src/effects/SkHighContrastFilter.cpp
+++ b/src/effects/SkHighContrastFilter.cpp
@@ -179,9 +179,8 @@
 
 private:
     HighContrastFilterEffect(const SkHighContrastConfig& config)
-        : INHERITED(kNone_OptimizationFlags)
+        : INHERITED(kHighContrastFilterEffect_ClassID, kNone_OptimizationFlags)
         , fConfig(config) {
-        this->initClassID<HighContrastFilterEffect>();
     }
 
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index 37f1c7b..8a8174a 100644
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -602,7 +602,7 @@
     const GrTextureDomain& domain() const { return fDomain; }
 
 protected:
-    GrLightingEffect(sk_sp<GrTextureProxy>, sk_sp<const SkImageFilterLight> light,
+    GrLightingEffect(ClassID classID, sk_sp<GrTextureProxy>, sk_sp<const SkImageFilterLight> light,
                      SkScalar surfaceScale, const SkMatrix& matrix, BoundaryMode boundaryMode,
                      const SkIRect* srcBounds);
 
@@ -1691,14 +1691,15 @@
     }
 }
 
-GrLightingEffect::GrLightingEffect(sk_sp<GrTextureProxy> proxy,
+GrLightingEffect::GrLightingEffect(ClassID classID,
+                                   sk_sp<GrTextureProxy> proxy,
                                    sk_sp<const SkImageFilterLight> light,
                                    SkScalar surfaceScale,
                                    const SkMatrix& matrix,
                                    BoundaryMode boundaryMode,
                                    const SkIRect* srcBounds)
         // Perhaps this could advertise the opaque or coverage-as-alpha optimizations?
-        : INHERITED(kNone_OptimizationFlags)
+        : INHERITED(classID, kNone_OptimizationFlags)
         , fCoordTransform(proxy.get())
         , fDomain(create_domain(proxy.get(), srcBounds, GrTextureDomain::kDecal_Mode))
         , fTextureSampler(std::move(proxy))
@@ -1706,13 +1707,12 @@
         , fSurfaceScale(surfaceScale)
         , fFilterMatrix(matrix)
         , fBoundaryMode(boundaryMode) {
-    this->initClassID<GrLightingEffect>();
     this->addCoordTransform(&fCoordTransform);
     this->addTextureSampler(&fTextureSampler);
 }
 
 GrLightingEffect::GrLightingEffect(const GrLightingEffect& that)
-        : INHERITED(that.optimizationFlags())
+        : INHERITED(that.classID(), that.optimizationFlags())
         , fCoordTransform(that.fCoordTransform)
         , fDomain(that.fDomain)
         , fTextureSampler(that.fTextureSampler)
@@ -1720,7 +1720,6 @@
         , fSurfaceScale(that.fSurfaceScale)
         , fFilterMatrix(that.fFilterMatrix)
         , fBoundaryMode(that.fBoundaryMode) {
-    this->initClassID<GrLightingEffect>();
     this->addCoordTransform(&fCoordTransform);
     this->addTextureSampler(&fTextureSampler);
 }
@@ -1741,16 +1740,12 @@
                                                  SkScalar kd,
                                                  BoundaryMode boundaryMode,
                                                  const SkIRect* srcBounds)
-        : INHERITED(std::move(proxy), std::move(light), surfaceScale, matrix, boundaryMode,
-                    srcBounds)
-        , fKD(kd) {
-    this->initClassID<GrDiffuseLightingEffect>();
-}
+        : INHERITED(kGrDiffuseLightingEffect_ClassID, std::move(proxy), std::move(light),
+                    surfaceScale, matrix, boundaryMode, srcBounds)
+        , fKD(kd) {}
 
 GrDiffuseLightingEffect::GrDiffuseLightingEffect(const GrDiffuseLightingEffect& that)
-        : INHERITED(that), fKD(that.fKD) {
-    this->initClassID<GrDiffuseLightingEffect>();
-}
+        : INHERITED(that), fKD(that.fKD) {}
 
 bool GrDiffuseLightingEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
     const GrDiffuseLightingEffect& s = sBase.cast<GrDiffuseLightingEffect>();
@@ -1986,17 +1981,13 @@
                                                    SkScalar shininess,
                                                    BoundaryMode boundaryMode,
                                                    const SkIRect* srcBounds)
-        : INHERITED(std::move(proxy), std::move(light), surfaceScale, matrix, boundaryMode,
-                    srcBounds)
+        : INHERITED(kGrSpecularLightingEffect_ClassID, std::move(proxy), std::move(light),
+                    surfaceScale, matrix, boundaryMode, srcBounds)
         , fKS(ks)
-        , fShininess(shininess) {
-    this->initClassID<GrSpecularLightingEffect>();
-}
+        , fShininess(shininess) {}
 
 GrSpecularLightingEffect::GrSpecularLightingEffect(const GrSpecularLightingEffect& that)
-        : INHERITED(that), fKS(that.fKS), fShininess(that.fShininess) {
-    this->initClassID<GrSpecularLightingEffect>();
-}
+        : INHERITED(that), fKS(that.fKS), fShininess(that.fShininess) {}
 
 bool GrSpecularLightingEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
     const GrSpecularLightingEffect& s = sBase.cast<GrSpecularLightingEffect>();
diff --git a/src/effects/SkLumaColorFilter.cpp b/src/effects/SkLumaColorFilter.cpp
index ecd1a3a..3b3845e 100644
--- a/src/effects/SkLumaColorFilter.cpp
+++ b/src/effects/SkLumaColorFilter.cpp
@@ -78,8 +78,8 @@
         typedef GrGLSLFragmentProcessor INHERITED;
     };
 
-    LumaColorFilterEffect() : INHERITED(kConstantOutputForConstantInput_OptimizationFlag) {
-        this->initClassID<LumaColorFilterEffect>();
+    LumaColorFilterEffect()
+    : INHERITED(kLumaColorFilterEffect_ClassID, kConstantOutputForConstantInput_OptimizationFlag) {
     }
 
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
diff --git a/src/effects/SkMagnifierImageFilter.cpp b/src/effects/SkMagnifierImageFilter.cpp
index 1c529a9..d08bbae 100644
--- a/src/effects/SkMagnifierImageFilter.cpp
+++ b/src/effects/SkMagnifierImageFilter.cpp
@@ -98,7 +98,8 @@
                       float yInvZoom,
                       float xInvInset,
                       float yInvInset)
-            : INHERITED{ModulateByConfigOptimizationFlags(proxy->config())}
+            : INHERITED{kGrMagnifierEffect_ClassID,
+                        ModulateByConfigOptimizationFlags(proxy->config())}
             // TODO: no GrSamplerState::Filter::kBilerp?
             , fCoordTransform(proxy.get())
             , fTextureSampler(std::move(proxy))
@@ -109,13 +110,12 @@
             , fYInvZoom(yInvZoom)
             , fXInvInset(xInvInset)
             , fYInvInset(yInvInset) {
-        this->initClassID<GrMagnifierEffect>();
         this->addCoordTransform(&fCoordTransform);
         this->addTextureSampler(&fTextureSampler);
     }
 
     explicit GrMagnifierEffect(const GrMagnifierEffect& that)
-            : INHERITED(that.optimizationFlags())
+            : INHERITED(kGrMagnifierEffect_ClassID, that.optimizationFlags())
             , fCoordTransform(that.fCoordTransform)
             , fTextureSampler(that.fTextureSampler)
             , fColorSpaceXform(that.fColorSpaceXform)
@@ -125,7 +125,6 @@
             , fYInvZoom(that.fYInvZoom)
             , fXInvInset(that.fXInvInset)
             , fYInvInset(that.fYInvInset) {
-        this->initClassID<GrMagnifierEffect>();
         this->addCoordTransform(&fCoordTransform);
         this->addTextureSampler(&fTextureSampler);
     }
diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp
index c9b4dc9..3315558 100644
--- a/src/effects/SkMorphologyImageFilter.cpp
+++ b/src/effects/SkMorphologyImageFilter.cpp
@@ -324,14 +324,13 @@
                                        int radius,
                                        Type type,
                                        const float range[2])
-        : INHERITED(ModulateByConfigOptimizationFlags(proxy->config()))
+        : INHERITED(kGrMorphologyEffect_ClassID, ModulateByConfigOptimizationFlags(proxy->config()))
         , fCoordTransform(proxy.get())
         , fTextureSampler(std::move(proxy))
         , fDirection(direction)
         , fRadius(radius)
         , fType(type)
         , fUseRange(SkToBool(range)) {
-    this->initClassID<GrMorphologyEffect>();
     this->addCoordTransform(&fCoordTransform);
     this->addTextureSampler(&fTextureSampler);
     if (fUseRange) {
@@ -341,14 +340,13 @@
 }
 
 GrMorphologyEffect::GrMorphologyEffect(const GrMorphologyEffect& that)
-        : INHERITED(that.optimizationFlags())
+        : INHERITED(kGrMorphologyEffect_ClassID, that.optimizationFlags())
         , fCoordTransform(that.fCoordTransform)
         , fTextureSampler(that.fTextureSampler)
         , fDirection(that.fDirection)
         , fRadius(that.fRadius)
         , fType(that.fType)
         , fUseRange(that.fUseRange) {
-    this->initClassID<GrMorphologyEffect>();
     this->addCoordTransform(&fCoordTransform);
     this->addTextureSampler(&fTextureSampler);
     if (that.fUseRange) {
diff --git a/src/effects/SkOverdrawColorFilter.cpp b/src/effects/SkOverdrawColorFilter.cpp
index be5a623..a4fa070 100644
--- a/src/effects/SkOverdrawColorFilter.cpp
+++ b/src/effects/SkOverdrawColorFilter.cpp
@@ -128,8 +128,7 @@
 // This could implement the constant input -> constant output optimization, but we don't really
 // care given how this is used.
 OverdrawFragmentProcessor::OverdrawFragmentProcessor(const GrColor4f* colors)
-        : INHERITED(kNone_OptimizationFlags) {
-    this->initClassID<OverdrawFragmentProcessor>();
+        : INHERITED(kOverdrawFragmentProcessor_ClassID, kNone_OptimizationFlags) {
     memcpy(fColors, colors, SkOverdrawColorFilter::kNumColors * sizeof(GrColor4f));
 }
 
diff --git a/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp b/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp
index b0e7ca3..2f697a3 100644
--- a/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp
+++ b/src/effects/SkRRectsGaussianEdgeMaskFilter.cpp
@@ -458,23 +458,23 @@
     }
 
     RRectsGaussianEdgeFP(const SkRRect& first, const SkRRect& second, SkScalar radius)
-            : INHERITED(kCompatibleWithCoverageAsAlpha_OptimizationFlag)
+            : INHERITED(kRRectsGaussianEdgeFP_ClassID,
+                        kCompatibleWithCoverageAsAlpha_OptimizationFlag)
             , fFirst(first)
             , fSecond(second)
             , fRadius(radius) {
-        this->initClassID<RRectsGaussianEdgeFP>();
 
         fFirstMode = ComputeMode(fFirst);
         fSecondMode = ComputeMode(fSecond);
     }
     RRectsGaussianEdgeFP(const RRectsGaussianEdgeFP& that)
-            : INHERITED(kCompatibleWithCoverageAsAlpha_OptimizationFlag)
+            : INHERITED(kRRectsGaussianEdgeFP_ClassID,
+                        kCompatibleWithCoverageAsAlpha_OptimizationFlag)
             , fFirst(that.fFirst)
             , fFirstMode(that.fFirstMode)
             , fSecond(that.fSecond)
             , fSecondMode(that.fSecondMode)
             , fRadius(that.fRadius) {
-        this->initClassID<RRectsGaussianEdgeFP>();
     }
 
     static Mode ComputeMode(const SkRRect& rr) {
diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp
index 6ebcfa6..6e4e068 100644
--- a/src/effects/SkTableColorFilter.cpp
+++ b/src/effects/SkTableColorFilter.cpp
@@ -472,11 +472,11 @@
 }
 
 ColorTableEffect::ColorTableEffect(sk_sp<GrTextureProxy> proxy, GrTextureStripAtlas* atlas, int row)
-        : INHERITED(kNone_OptimizationFlags)  // Not bothering with table-specific optimizations.
+        : INHERITED(kColorTableEffect_ClassID,
+                    kNone_OptimizationFlags)  // Not bothering with table-specific optimizations.
         , fTextureSampler(std::move(proxy))
         , fAtlas(atlas)
         , fRow(row) {
-    this->initClassID<ColorTableEffect>();
     this->addTextureSampler(&fTextureSampler);
 }
 
diff --git a/src/gpu/GrDefaultGeoProcFactory.cpp b/src/gpu/GrDefaultGeoProcFactory.cpp
index 32d16ff..a0c1f2a 100644
--- a/src/gpu/GrDefaultGeoProcFactory.cpp
+++ b/src/gpu/GrDefaultGeoProcFactory.cpp
@@ -248,14 +248,14 @@
                    const SkMatrix& localMatrix,
                    uint8_t coverage,
                    bool localCoordsWillBeRead)
-            : fColor(color)
+            : INHERITED(kDefaultGeoProc_ClassID)
+            , fColor(color)
             , fViewMatrix(viewMatrix)
             , fLocalMatrix(localMatrix)
             , fCoverage(coverage)
             , fFlags(gpTypeFlags)
             , fLocalCoordsWillBeRead(localCoordsWillBeRead)
             , fColorSpaceXform(std::move(colorSpaceXform)) {
-        this->initClassID<DefaultGeoProc>();
         fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
         if (fFlags & kColorAttribute_GPFlag) {
             fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType);
diff --git a/src/gpu/GrFragmentProcessor.cpp b/src/gpu/GrFragmentProcessor.cpp
index ca49da8..90bbb33 100644
--- a/src/gpu/GrFragmentProcessor.cpp
+++ b/src/gpu/GrFragmentProcessor.cpp
@@ -123,9 +123,9 @@
 
 private:
     PremulInputFragmentProcessor()
-            : INHERITED(kPreservesOpaqueInput_OptimizationFlag |
+            : INHERITED(kPremulInputFragmentProcessor_ClassID,
+                        kPreservesOpaqueInput_OptimizationFlag |
                         kConstantOutputForConstantInput_OptimizationFlag) {
-        this->initClassID<PremulInputFragmentProcessor>();
     }
 
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
@@ -165,9 +165,9 @@
 
 private:
     UnpremulInputFragmentProcessor()
-            : INHERITED(kPreservesOpaqueInput_OptimizationFlag |
+            : INHERITED(kUnpremulInputFragmentProcessor_ClassID,
+                        kPreservesOpaqueInput_OptimizationFlag |
                         kConstantOutputForConstantInput_OptimizationFlag) {
-        this->initClassID<UnpremulInputFragmentProcessor>();
     }
 
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
@@ -243,9 +243,8 @@
 
     private:
         SwizzleFragmentProcessor(const GrSwizzle& swizzle)
-                : INHERITED(kAll_OptimizationFlags)
+                : INHERITED(kSwizzleFragmentProcessor_ClassID, kAll_OptimizationFlags)
                 , fSwizzle(swizzle) {
-            this->initClassID<SwizzleFragmentProcessor>();
         }
 
         GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
@@ -310,8 +309,7 @@
 
     private:
         PremulFragmentProcessor(std::unique_ptr<GrFragmentProcessor> processor)
-                : INHERITED(OptFlags(processor.get())) {
-            this->initClassID<PremulFragmentProcessor>();
+                : INHERITED(kPremulFragmentProcessor_ClassID, OptFlags(processor.get())) {
             this->registerChildProcessor(std::move(processor));
         }
 
@@ -412,8 +410,8 @@
         }
 
         ReplaceInputFragmentProcessor(std::unique_ptr<GrFragmentProcessor> child, GrColor4f color)
-                : INHERITED(OptFlags(child.get(), color)), fColor(color) {
-            this->initClassID<ReplaceInputFragmentProcessor>();
+                : INHERITED(kReplaceInputFragmentProcessor_ClassID, OptFlags(child.get(), color))
+                , fColor(color) {
             this->registerChildProcessor(std::move(child));
         }
 
@@ -494,9 +492,8 @@
         }
 
         SeriesFragmentProcessor(std::unique_ptr<GrFragmentProcessor>* children, int cnt)
-                : INHERITED(OptFlags(children, cnt)) {
+                : INHERITED(kSeriesFragmentProcessor_ClassID, OptFlags(children, cnt)) {
             SkASSERT(cnt > 1);
-            this->initClassID<SeriesFragmentProcessor>();
             for (int i = 0; i < cnt; ++i) {
                 this->registerChildProcessor(std::move(children[i]));
             }
diff --git a/src/gpu/GrFragmentProcessor.h b/src/gpu/GrFragmentProcessor.h
index 0c3efd1..4ec9262 100644
--- a/src/gpu/GrFragmentProcessor.h
+++ b/src/gpu/GrFragmentProcessor.h
@@ -275,7 +275,9 @@
         }
     }
 
-    GrFragmentProcessor(OptimizationFlags optimizationFlags) : fFlags(optimizationFlags) {
+    GrFragmentProcessor(ClassID classID, OptimizationFlags optimizationFlags)
+    : INHERITED(classID)
+    , fFlags(optimizationFlags) {
         SkASSERT((fFlags & ~kAll_OptimizationFlags) == 0);
     }
 
diff --git a/src/gpu/GrGeometryProcessor.h b/src/gpu/GrGeometryProcessor.h
index d8962c2..acd122e 100644
--- a/src/gpu/GrGeometryProcessor.h
+++ b/src/gpu/GrGeometryProcessor.h
@@ -19,8 +19,9 @@
  */
 class GrGeometryProcessor : public GrPrimitiveProcessor {
 public:
-    GrGeometryProcessor()
-        : fWillUseGeoShader(false)
+    GrGeometryProcessor(ClassID classID)
+        : INHERITED(classID)
+        , fWillUseGeoShader(false)
         , fLocalCoordsType(kUnused_LocalCoordsType)
         , fSampleShading(0.0) {}
 
diff --git a/src/gpu/GrPathProcessor.cpp b/src/gpu/GrPathProcessor.cpp
index 24326e9..49980eb 100644
--- a/src/gpu/GrPathProcessor.cpp
+++ b/src/gpu/GrPathProcessor.cpp
@@ -115,11 +115,10 @@
 GrPathProcessor::GrPathProcessor(GrColor color,
                                  const SkMatrix& viewMatrix,
                                  const SkMatrix& localMatrix)
-        : fColor(color)
+        : INHERITED(kGrPathProcessor_ClassID)
+        , fColor(color)
         , fViewMatrix(viewMatrix)
-        , fLocalMatrix(localMatrix) {
-    this->initClassID<GrPathProcessor>();
-}
+        , fLocalMatrix(localMatrix) {}
 
 void GrPathProcessor::getGLSLProcessorKey(const GrShaderCaps& caps,
                                           GrProcessorKeyBuilder* b) const {
diff --git a/src/gpu/GrPrimitiveProcessor.h b/src/gpu/GrPrimitiveProcessor.h
index eb59d98..375b512 100644
--- a/src/gpu/GrPrimitiveProcessor.h
+++ b/src/gpu/GrPrimitiveProcessor.h
@@ -52,6 +52,9 @@
         InputRate            fInputRate;
     };
 
+    GrPrimitiveProcessor(ClassID classID)
+    : GrResourceIOProcessor(classID) {}
+
     int numAttribs() const { return fAttribs.count(); }
     const Attribute& getAttrib(int index) const { return fAttribs[index]; }
 
diff --git a/src/gpu/GrProcessor.cpp b/src/gpu/GrProcessor.cpp
index b8ca63e..89a3171 100644
--- a/src/gpu/GrProcessor.cpp
+++ b/src/gpu/GrProcessor.cpp
@@ -115,8 +115,6 @@
 };
 }
 
-int32_t GrProcessor::gCurrProcessorClassID = GrProcessor::kIllegalProcessorClassID;
-
 ///////////////////////////////////////////////////////////////////////////////
 
 void* GrProcessor::operator new(size_t size) { return MemoryPoolAccessor().pool()->allocate(size); }
diff --git a/src/gpu/GrProcessor.h b/src/gpu/GrProcessor.h
index de0598f..7f51316 100644
--- a/src/gpu/GrProcessor.h
+++ b/src/gpu/GrProcessor.h
@@ -64,6 +64,96 @@
  */
 class GrProcessor {
 public:
+    enum ClassID {
+        kAARectEffect_ClassID,
+        kArithmeticFP_ClassID,
+        kBigKeyProcessor_ClassID,
+        kBlockInputFragmentProcessor_ClassID,
+        kCircleGeometryProcessor_ClassID,
+        kCircleInside2PtConicalEffect_ClassID,
+        kCircleOutside2PtConicalEffect_ClassID,
+        kCircularRRectEffect_ClassID,
+        kColorMatrixEffect_ClassID,
+        kColorTableEffect_ClassID,
+        kComposeOneFragmentProcessor_ClassID,
+        kComposeTwoFragmentProcessor_ClassID,
+        kCoverageSetOpXP_ClassID,
+        kCustomXP_ClassID,
+        kDashingCircleEffect_ClassID,
+        kDashingLineEffect_ClassID,
+        kDefaultGeoProc_ClassID,
+        kDIEllipseGeometryProcessor_ClassID,
+        kDisableColorXP_ClassID,
+        kEdge2PtConicalEffect_ClassID,
+        kEllipseGeometryProcessor_ClassID,
+        kEllipticalRRectEffect_ClassID,
+        kFocalInside2PtConicalEffect_ClassID,
+        kFocalOutside2PtConicalEffect_ClassID,
+        kGP_ClassID,
+        kGrAlphaThresholdFragmentProcessor_ClassID,
+        kGrBicubicEffect_ClassID,
+        kGrBitmapTextGeoProc_ClassID,
+        kGrBlurredEdgeFragmentProcessor_ClassID,
+        kGrCCPRCoverageProcessor_ClassID,
+        kGrCCPRPathProcessor_ClassID,
+        kGrCircleBlurFragmentProcessor_ClassID,
+        kGrCircleEffect_ClassID,
+        kGrConfigConversionEffect_ClassID,
+        kGrConicEffect_ClassID,
+        kGrConstColorProcessor_ClassID,
+        kGrConvexPolyEffect_ClassID,
+        kGrCubicEffect_ClassID,
+        kGrDeviceSpaceTextureDecalFragmentProcessor_ClassID,
+        kGrDiffuseLightingEffect_ClassID,
+        kGrDisplacementMapEffect_ClassID,
+        kGrDistanceFieldA8TextGeoProc_ClassID,
+        kGrDistanceFieldLCDTextGeoProc_ClassID,
+        kGrDistanceFieldPathGeoProc_ClassID,
+        kGrDitherEffect_ClassID,
+        kGrEllipseEffect_ClassID,
+        kGrGaussianConvolutionFragmentProcessor_ClassID,
+        kGrImprovedPerlinNoiseEffect_ClassID,
+        kGrLightingEffect_ClassID,
+        kGrLinearGradient_ClassID,
+        kGrMagnifierEffect_ClassID,
+        kGrMatrixConvolutionEffect_ClassID,
+        kGrMeshTestProcessor_ClassID,
+        kGrMorphologyEffect_ClassID,
+        kGrNonlinearColorSpaceXformEffect_ClassID,
+        kGrPathProcessor_ClassID,
+        kGrPerlinNoise2Effect_ClassID,
+        kGrPipelineDynamicStateTestProcessor_ClassID,
+        kGrQuadEffect_ClassID,
+        kGrRadialGradient_ClassID,
+        kGrRectBlurEffect_ClassID,
+        kGrRRectBlurEffect_ClassID,
+        kGrRRectShadowGeoProc_ClassID,
+        kGrSimpleTextureEffect_ClassID,
+        kGrSpecularLightingEffect_ClassID,
+        kGrSRGBEffect_ClassID,
+        kGrSweepGradient_ClassID,
+        kGrTextureDomainEffect_ClassID,
+        kHighContrastFilterEffect_ClassID,
+        kInstanceProcessor_ClassID,
+        kLumaColorFilterEffect_ClassID,
+        kMSAAQuadProcessor_ClassID,
+        kOverdrawFragmentProcessor_ClassID,
+        kPDLCDXferProcessor_ClassID,
+        kPorterDuffXferProcessor_ClassID,
+        kPremulFragmentProcessor_ClassID,
+        kPremulInputFragmentProcessor_ClassID,
+        kQuadEdgeEffect_ClassID,
+        kReplaceInputFragmentProcessor_ClassID,
+        kRRectsGaussianEdgeFP_ClassID,
+        kSeriesFragmentProcessor_ClassID,
+        kShaderPDXferProcessor_ClassID,
+        kSwizzleFragmentProcessor_ClassID,
+        kTestFP_ClassID,
+        kTextureGeometryProcessor_ClassID,
+        kUnpremulInputFragmentProcessor_ClassID,
+        kYUVtoRGBEffect_ClassID
+    };
+
     virtual ~GrProcessor() = default;
 
     /** Human-meaningful string to identify this prcoessor; may be embedded in generated shader
@@ -102,10 +192,12 @@
     /** Helper for down-casting to a GrProcessor subclass */
     template <typename T> const T& cast() const { return *static_cast<const T*>(this); }
 
-    uint32_t classID() const { SkASSERT(kIllegalProcessorClassID != fClassID); return fClassID; }
+    ClassID classID() const { return fClassID; }
 
 protected:
-    GrProcessor() : fClassID(kIllegalProcessorClassID), fRequiredFeatures(kNone_RequiredFeatures) {}
+    GrProcessor(ClassID classID)
+    : fClassID(classID)
+    , fRequiredFeatures(kNone_RequiredFeatures) {}
 
     /**
      * If the prcoessor will generate code that uses platform specific built-in features, then it
@@ -118,34 +210,12 @@
         fRequiredFeatures |= other.fRequiredFeatures;
     }
 
-    template <typename PROC_SUBCLASS> void initClassID() {
-         static uint32_t kClassID = GenClassID();
-         fClassID = kClassID;
-    }
-
 private:
     GrProcessor(const GrProcessor&) = delete;
     GrProcessor& operator=(const GrProcessor&) = delete;
 
-    static uint32_t GenClassID() {
-        // fCurrProcessorClassID has been initialized to kIllegalProcessorClassID. The
-        // atomic inc returns the old value not the incremented value. So we add
-        // 1 to the returned value.
-        uint32_t id = static_cast<uint32_t>(sk_atomic_inc(&gCurrProcessorClassID)) + 1;
-        if (!id) {
-            SK_ABORT("This should never wrap as it should only be called once for each GrProcessor "
-                   "subclass.");
-        }
-        return id;
-    }
-
-    enum {
-        kIllegalProcessorClassID = 0,
-    };
-    static int32_t gCurrProcessorClassID;
-
-    uint32_t                                        fClassID;
-    RequiredFeatures                                fRequiredFeatures;
+    ClassID          fClassID;
+    RequiredFeatures fRequiredFeatures;
 };
 
 GR_MAKE_BITFIELD_OPS(GrProcessor::RequiredFeatures);
@@ -180,7 +250,8 @@
     bool instantiate(GrResourceProvider* resourceProvider) const;
 
 protected:
-    GrResourceIOProcessor() {}
+    GrResourceIOProcessor(ClassID classID)
+    : INHERITED(classID) {}
 
     /**
      * Subclasses call these from their constructor to register sampler/image sources. The processor
diff --git a/src/gpu/GrXferProcessor.cpp b/src/gpu/GrXferProcessor.cpp
index c7383f2..8f7377e 100644
--- a/src/gpu/GrXferProcessor.cpp
+++ b/src/gpu/GrXferProcessor.cpp
@@ -9,14 +9,16 @@
 #include "GrPipeline.h"
 #include "gl/GrGLCaps.h"
 
-GrXferProcessor::GrXferProcessor()
-        : fWillReadDstColor(false)
+GrXferProcessor::GrXferProcessor(ClassID classID)
+        : INHERITED(classID)
+        , fWillReadDstColor(false)
         , fDstReadUsesMixedSamples(false)
         , fIsLCD(false) {}
 
-GrXferProcessor::GrXferProcessor(bool willReadDstColor, bool hasMixedSamples,
+GrXferProcessor::GrXferProcessor(ClassID classID, bool willReadDstColor, bool hasMixedSamples,
                                  GrProcessorAnalysisCoverage coverage)
-        : fWillReadDstColor(willReadDstColor)
+        : INHERITED(classID)
+        , fWillReadDstColor(willReadDstColor)
         , fDstReadUsesMixedSamples(willReadDstColor && hasMixedSamples)
         , fIsLCD(GrProcessorAnalysisCoverage::kLCD == coverage) {}
 
diff --git a/src/gpu/GrXferProcessor.h b/src/gpu/GrXferProcessor.h
index 419c83d..90b0de9 100644
--- a/src/gpu/GrXferProcessor.h
+++ b/src/gpu/GrXferProcessor.h
@@ -189,8 +189,9 @@
     }
 
 protected:
-    GrXferProcessor();
-    GrXferProcessor(bool willReadDstColor, bool hasMixedSamples, GrProcessorAnalysisCoverage);
+    GrXferProcessor(ClassID classID);
+    GrXferProcessor(ClassID classID, bool willReadDstColor, bool hasMixedSamples,
+                    GrProcessorAnalysisCoverage);
 
 private:
     /**
@@ -219,7 +220,7 @@
     bool fDstReadUsesMixedSamples;
     bool fIsLCD;
 
-    typedef GrFragmentProcessor INHERITED;
+    typedef GrProcessor INHERITED;
 };
 
 /**
diff --git a/src/gpu/ccpr/GrCCPRCoverageProcessor.cpp b/src/gpu/ccpr/GrCCPRCoverageProcessor.cpp
index 7354c03..d27ea4c 100644
--- a/src/gpu/ccpr/GrCCPRCoverageProcessor.cpp
+++ b/src/gpu/ccpr/GrCCPRCoverageProcessor.cpp
@@ -42,14 +42,13 @@
 }
 
 GrCCPRCoverageProcessor::GrCCPRCoverageProcessor(Mode mode, GrBuffer* pointsBuffer)
-        : fMode(mode)
+        : INHERITED(kGrCCPRCoverageProcessor_ClassID)
+        , fMode(mode)
         , fInstanceAttrib(this->addInstanceAttrib("instance", InstanceArrayFormat(mode))) {
     fPointsBufferAccess.reset(kRG_float_GrPixelConfig, pointsBuffer, kVertex_GrShaderFlag);
     this->addBufferAccess(&fPointsBufferAccess);
 
     this->setWillUseGeoShader();
-
-    this->initClassID<GrCCPRCoverageProcessor>();
 }
 
 void GrCCPRCoverageProcessor::getGLSLProcessorKey(const GrShaderCaps&,
diff --git a/src/gpu/ccpr/GrCCPRPathProcessor.cpp b/src/gpu/ccpr/GrCCPRPathProcessor.cpp
index bac52ce..585f3be 100644
--- a/src/gpu/ccpr/GrCCPRPathProcessor.cpp
+++ b/src/gpu/ccpr/GrCCPRPathProcessor.cpp
@@ -50,7 +50,8 @@
 
 GrCCPRPathProcessor::GrCCPRPathProcessor(GrResourceProvider* rp, sk_sp<GrTextureProxy> atlas,
                                          SkPath::FillType fillType, const GrShaderCaps& shaderCaps)
-        : fFillType(fillType) {
+        : INHERITED(kGrCCPRPathProcessor_ClassID)
+        , fFillType(fillType) {
     this->addInstanceAttrib("devbounds", kFloat4_GrVertexAttribType);
     this->addInstanceAttrib("devbounds45", kFloat4_GrVertexAttribType);
     this->addInstanceAttrib("view_matrix", kFloat4_GrVertexAttribType);
@@ -82,8 +83,6 @@
                        GrSamplerState::WrapMode::kClamp, kFragment_GrShaderFlag);
     fAtlasAccess.instantiate(rp);
     this->addTextureSampler(&fAtlasAccess);
-
-    this->initClassID<GrCCPRPathProcessor>();
 }
 
 void GrCCPRPathProcessor::getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const {
diff --git a/src/gpu/effects/GrBezierEffect.cpp b/src/gpu/effects/GrBezierEffect.cpp
index 354bc67..0b4ee07 100644
--- a/src/gpu/effects/GrBezierEffect.cpp
+++ b/src/gpu/effects/GrBezierEffect.cpp
@@ -234,13 +234,13 @@
 GrConicEffect::GrConicEffect(GrColor color, const SkMatrix& viewMatrix, uint8_t coverage,
                              GrPrimitiveEdgeType edgeType, const SkMatrix& localMatrix,
                              bool usesLocalCoords)
-    : fColor(color)
+    : INHERITED(kGrConicEffect_ClassID)
+    , fColor(color)
     , fViewMatrix(viewMatrix)
     , fLocalMatrix(viewMatrix)
     , fUsesLocalCoords(usesLocalCoords)
     , fCoverageScale(coverage)
     , fEdgeType(edgeType) {
-    this->initClassID<GrConicEffect>();
     fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
     fInConicCoeffs = &this->addVertexAttrib("inConicCoeffs", kHalf4_GrVertexAttribType);
 }
@@ -436,13 +436,13 @@
 GrQuadEffect::GrQuadEffect(GrColor color, const SkMatrix& viewMatrix, uint8_t coverage,
                            GrPrimitiveEdgeType edgeType, const SkMatrix& localMatrix,
                            bool usesLocalCoords)
-    : fColor(color)
+    : INHERITED(kGrQuadEffect_ClassID)
+    , fColor(color)
     , fViewMatrix(viewMatrix)
     , fLocalMatrix(localMatrix)
     , fUsesLocalCoords(usesLocalCoords)
     , fCoverageScale(coverage)
     , fEdgeType(edgeType) {
-    this->initClassID<GrQuadEffect>();
     fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
     fInHairQuadEdge = &this->addVertexAttrib("inHairQuadEdge", kHalf4_GrVertexAttribType);
 }
@@ -663,11 +663,11 @@
 
 GrCubicEffect::GrCubicEffect(GrColor color, const SkMatrix& viewMatrix, const SkMatrix&
                              devKLMMatrix, GrPrimitiveEdgeType edgeType)
-    : fColor(color)
+    : INHERITED(kGrCubicEffect_ClassID)
+    , fColor(color)
     , fViewMatrix(viewMatrix)
     , fDevKLMMatrix(devKLMMatrix)
     , fEdgeType(edgeType) {
-    this->initClassID<GrCubicEffect>();
     fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
 }
 
diff --git a/src/gpu/effects/GrBicubicEffect.cpp b/src/gpu/effects/GrBicubicEffect.cpp
index 1a93977..e95b7a4 100644
--- a/src/gpu/effects/GrBicubicEffect.cpp
+++ b/src/gpu/effects/GrBicubicEffect.cpp
@@ -134,13 +134,12 @@
                                  sk_sp<GrColorSpaceXform> colorSpaceXform,
                                  const SkMatrix& matrix,
                                  const GrSamplerState::WrapMode wrapModes[2])
-        : INHERITED{ModulateByConfigOptimizationFlags(proxy->config())}
+        : INHERITED{kGrBicubicEffect_ClassID, ModulateByConfigOptimizationFlags(proxy->config())}
         , fCoordTransform(matrix, proxy.get())
         , fDomain(GrTextureDomain::IgnoredDomain())
         , fTextureSampler(std::move(proxy),
                           GrSamplerState(wrapModes, GrSamplerState::Filter::kNearest))
         , fColorSpaceXform(std::move(colorSpaceXform)) {
-    this->initClassID<GrBicubicEffect>();
     this->addCoordTransform(&fCoordTransform);
     this->addTextureSampler(&fTextureSampler);
 }
@@ -149,23 +148,21 @@
                                  sk_sp<GrColorSpaceXform> colorSpaceXform,
                                  const SkMatrix& matrix,
                                  const SkRect& domain)
-        : INHERITED(ModulateByConfigOptimizationFlags(proxy->config()))
+        : INHERITED(kGrBicubicEffect_ClassID, ModulateByConfigOptimizationFlags(proxy->config()))
         , fCoordTransform(matrix, proxy.get())
         , fDomain(proxy.get(), domain, GrTextureDomain::kClamp_Mode)
         , fTextureSampler(std::move(proxy))
         , fColorSpaceXform(std::move(colorSpaceXform)) {
-    this->initClassID<GrBicubicEffect>();
     this->addCoordTransform(&fCoordTransform);
     this->addTextureSampler(&fTextureSampler);
 }
 
 GrBicubicEffect::GrBicubicEffect(const GrBicubicEffect& that)
-        : INHERITED(that.optimizationFlags())
+        : INHERITED(kGrBicubicEffect_ClassID, that.optimizationFlags())
         , fCoordTransform(that.fCoordTransform)
         , fDomain(that.fDomain)
         , fTextureSampler(that.fTextureSampler)
         , fColorSpaceXform(that.fColorSpaceXform) {
-    this->initClassID<GrBicubicEffect>();
     this->addCoordTransform(&fCoordTransform);
     this->addTextureSampler(&fTextureSampler);
 }
diff --git a/src/gpu/effects/GrBitmapTextGeoProc.cpp b/src/gpu/effects/GrBitmapTextGeoProc.cpp
index 4370219..ddf882e 100644
--- a/src/gpu/effects/GrBitmapTextGeoProc.cpp
+++ b/src/gpu/effects/GrBitmapTextGeoProc.cpp
@@ -124,12 +124,12 @@
                                          const sk_sp<GrTextureProxy> proxies[kMaxTextures],
                                          const GrSamplerState& params, GrMaskFormat format,
                                          const SkMatrix& localMatrix, bool usesLocalCoords)
-        : fColor(color)
+        : INHERITED(kGrBitmapTextGeoProc_ClassID)
+        , fColor(color)
         , fLocalMatrix(localMatrix)
         , fUsesLocalCoords(usesLocalCoords)
         , fInColor(nullptr)
         , fMaskFormat(format) {
-    this->initClassID<GrBitmapTextGeoProc>();
     fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
 
     bool hasVertexColor = kA8_GrMaskFormat == fMaskFormat ||
diff --git a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp
index 1f894cc..551adea 100644
--- a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp
+++ b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.cpp
@@ -52,9 +52,8 @@
 }
 GrBlurredEdgeFragmentProcessor::GrBlurredEdgeFragmentProcessor(
         const GrBlurredEdgeFragmentProcessor& src)
-        : INHERITED(src.optimizationFlags()), fMode(src.fMode) {
-    this->initClassID<GrBlurredEdgeFragmentProcessor>();
-}
+        : INHERITED(kGrBlurredEdgeFragmentProcessor_ClassID, src.optimizationFlags())
+        , fMode(src.fMode) {}
 std::unique_ptr<GrFragmentProcessor> GrBlurredEdgeFragmentProcessor::clone() const {
     return std::unique_ptr<GrFragmentProcessor>(new GrBlurredEdgeFragmentProcessor(*this));
 }
diff --git a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.h b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.h
index 61cc53b..e27905c 100644
--- a/src/gpu/effects/GrBlurredEdgeFragmentProcessor.h
+++ b/src/gpu/effects/GrBlurredEdgeFragmentProcessor.h
@@ -27,9 +27,9 @@
     const char* name() const override { return "BlurredEdgeFragmentProcessor"; }
 
 private:
-    GrBlurredEdgeFragmentProcessor(int mode) : INHERITED(kNone_OptimizationFlags), fMode(mode) {
-        this->initClassID<GrBlurredEdgeFragmentProcessor>();
-    }
+    GrBlurredEdgeFragmentProcessor(int mode)
+            : INHERITED(kGrBlurredEdgeFragmentProcessor_ClassID, kNone_OptimizationFlags)
+            , fMode(mode) {}
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
     void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
     bool onIsEqual(const GrFragmentProcessor&) const override;
diff --git a/src/gpu/effects/GrCircleEffect.cpp b/src/gpu/effects/GrCircleEffect.cpp
index ef4f913..3c0e11b 100644
--- a/src/gpu/effects/GrCircleEffect.cpp
+++ b/src/gpu/effects/GrCircleEffect.cpp
@@ -90,12 +90,10 @@
     return true;
 }
 GrCircleEffect::GrCircleEffect(const GrCircleEffect& src)
-        : INHERITED(src.optimizationFlags())
+        : INHERITED(kGrCircleEffect_ClassID, src.optimizationFlags())
         , fEdgeType(src.fEdgeType)
         , fCenter(src.fCenter)
-        , fRadius(src.fRadius) {
-    this->initClassID<GrCircleEffect>();
-}
+        , fRadius(src.fRadius) {}
 std::unique_ptr<GrFragmentProcessor> GrCircleEffect::clone() const {
     return std::unique_ptr<GrFragmentProcessor>(new GrCircleEffect(*this));
 }
diff --git a/src/gpu/effects/GrCircleEffect.h b/src/gpu/effects/GrCircleEffect.h
index 0d88dcb..7f11505 100644
--- a/src/gpu/effects/GrCircleEffect.h
+++ b/src/gpu/effects/GrCircleEffect.h
@@ -29,12 +29,11 @@
 
 private:
     GrCircleEffect(int edgeType, SkPoint center, float radius)
-            : INHERITED((OptimizationFlags)kCompatibleWithCoverageAsAlpha_OptimizationFlag)
+            : INHERITED(kGrCircleEffect_ClassID,
+                        (OptimizationFlags)kCompatibleWithCoverageAsAlpha_OptimizationFlag)
             , fEdgeType(edgeType)
             , fCenter(center)
-            , fRadius(radius) {
-        this->initClassID<GrCircleEffect>();
-    }
+            , fRadius(radius) {}
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
     void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
     bool onIsEqual(const GrFragmentProcessor&) const override;
diff --git a/src/gpu/effects/GrConfigConversionEffect.cpp b/src/gpu/effects/GrConfigConversionEffect.cpp
index 2c12c7e..0d2a139 100644
--- a/src/gpu/effects/GrConfigConversionEffect.cpp
+++ b/src/gpu/effects/GrConfigConversionEffect.cpp
@@ -54,9 +54,8 @@
     return true;
 }
 GrConfigConversionEffect::GrConfigConversionEffect(const GrConfigConversionEffect& src)
-        : INHERITED(src.optimizationFlags()), fPmConversion(src.fPmConversion) {
-    this->initClassID<GrConfigConversionEffect>();
-}
+        : INHERITED(kGrConfigConversionEffect_ClassID, src.optimizationFlags())
+        , fPmConversion(src.fPmConversion) {}
 std::unique_ptr<GrFragmentProcessor> GrConfigConversionEffect::clone() const {
     return std::unique_ptr<GrFragmentProcessor>(new GrConfigConversionEffect(*this));
 }
diff --git a/src/gpu/effects/GrConfigConversionEffect.h b/src/gpu/effects/GrConfigConversionEffect.h
index f17b32f..470f060 100644
--- a/src/gpu/effects/GrConfigConversionEffect.h
+++ b/src/gpu/effects/GrConfigConversionEffect.h
@@ -139,9 +139,8 @@
 
 private:
     GrConfigConversionEffect(int pmConversion)
-            : INHERITED(kNone_OptimizationFlags), fPmConversion(pmConversion) {
-        this->initClassID<GrConfigConversionEffect>();
-    }
+            : INHERITED(kGrConfigConversionEffect_ClassID, kNone_OptimizationFlags)
+            , fPmConversion(pmConversion) {}
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
     void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
     bool onIsEqual(const GrFragmentProcessor&) const override;
diff --git a/src/gpu/effects/GrConstColorProcessor.h b/src/gpu/effects/GrConstColorProcessor.h
index 7079a8d..1429e9b 100644
--- a/src/gpu/effects/GrConstColorProcessor.h
+++ b/src/gpu/effects/GrConstColorProcessor.h
@@ -57,8 +57,10 @@
     }
 
     GrConstColorProcessor(GrColor4f color, InputMode mode)
-            : INHERITED(OptFlags(color, mode)), fColor(color), fMode(mode) {
-        this->initClassID<GrConstColorProcessor>();
+            : INHERITED(kGrConstColorProcessor_ClassID
+            , OptFlags(color, mode))
+            , fColor(color)
+            , fMode(mode) {
     }
 
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
diff --git a/src/gpu/effects/GrConvexPolyEffect.cpp b/src/gpu/effects/GrConvexPolyEffect.cpp
index 97f4569..8528384 100644
--- a/src/gpu/effects/GrConvexPolyEffect.cpp
+++ b/src/gpu/effects/GrConvexPolyEffect.cpp
@@ -34,10 +34,9 @@
     void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
 
     AARectEffect(GrPrimitiveEdgeType edgeType, const SkRect& rect)
-            : INHERITED(kCompatibleWithCoverageAsAlpha_OptimizationFlag)
+            : INHERITED(kAARectEffect_ClassID, kCompatibleWithCoverageAsAlpha_OptimizationFlag)
             , fRect(rect)
             , fEdgeType(edgeType) {
-        this->initClassID<AARectEffect>();
     }
 
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
@@ -326,10 +325,9 @@
 }
 
 GrConvexPolyEffect::GrConvexPolyEffect(GrPrimitiveEdgeType edgeType, int n, const SkScalar edges[])
-        : INHERITED(kCompatibleWithCoverageAsAlpha_OptimizationFlag)
+        : INHERITED(kGrConvexPolyEffect_ClassID, kCompatibleWithCoverageAsAlpha_OptimizationFlag)
         , fEdgeType(edgeType)
         , fEdgeCount(n) {
-    this->initClassID<GrConvexPolyEffect>();
     // Factory function should have already ensured this.
     SkASSERT(n <= kMaxEdges);
     memcpy(fEdges, edges, 3 * n * sizeof(SkScalar));
@@ -341,10 +339,9 @@
 }
 
 GrConvexPolyEffect::GrConvexPolyEffect(const GrConvexPolyEffect& that)
-        : INHERITED(kCompatibleWithCoverageAsAlpha_OptimizationFlag)
+        : INHERITED(kGrConvexPolyEffect_ClassID, kCompatibleWithCoverageAsAlpha_OptimizationFlag)
         , fEdgeType(that.fEdgeType)
         , fEdgeCount(that.fEdgeCount) {
-    this->initClassID<GrConvexPolyEffect>();
     memcpy(fEdges, that.fEdges, 3 * that.fEdgeCount * sizeof(SkScalar));
 }
 
diff --git a/src/gpu/effects/GrCoverageSetOpXP.cpp b/src/gpu/effects/GrCoverageSetOpXP.cpp
index 0e7dcf7..2524c9c 100644
--- a/src/gpu/effects/GrCoverageSetOpXP.cpp
+++ b/src/gpu/effects/GrCoverageSetOpXP.cpp
@@ -19,9 +19,9 @@
 class CoverageSetOpXP : public GrXferProcessor {
 public:
     CoverageSetOpXP(SkRegion::Op regionOp, bool invertCoverage)
-            : fRegionOp(regionOp), fInvertCoverage(invertCoverage) {
-        this->initClassID<CoverageSetOpXP>();
-    }
+            : INHERITED(kCoverageSetOpXP_ClassID)
+            , fRegionOp(regionOp)
+            , fInvertCoverage(invertCoverage) {}
 
     const char* name() const override { return "Coverage Set Op"; }
 
diff --git a/src/gpu/effects/GrCustomXfermode.cpp b/src/gpu/effects/GrCustomXfermode.cpp
index 94d8ce2..98bda3e 100644
--- a/src/gpu/effects/GrCustomXfermode.cpp
+++ b/src/gpu/effects/GrCustomXfermode.cpp
@@ -72,16 +72,14 @@
 class CustomXP : public GrXferProcessor {
 public:
     CustomXP(SkBlendMode mode, GrBlendEquation hwBlendEquation)
-        : fMode(mode)
-        , fHWBlendEquation(hwBlendEquation) {
-        this->initClassID<CustomXP>();
-    }
+        : INHERITED(kCustomXP_ClassID)
+        , fMode(mode)
+        , fHWBlendEquation(hwBlendEquation) {}
 
     CustomXP(bool hasMixedSamples, SkBlendMode mode, GrProcessorAnalysisCoverage coverage)
-            : INHERITED(true, hasMixedSamples, coverage)
+            : INHERITED(kCustomXP_ClassID, true, hasMixedSamples, coverage)
             , fMode(mode)
             , fHWBlendEquation(static_cast<GrBlendEquation>(-1)) {
-        this->initClassID<CustomXP>();
     }
 
     const char* name() const override { return "Custom Xfermode"; }
diff --git a/src/gpu/effects/GrDisableColorXP.cpp b/src/gpu/effects/GrDisableColorXP.cpp
index a0beecd..314be6e 100644
--- a/src/gpu/effects/GrDisableColorXP.cpp
+++ b/src/gpu/effects/GrDisableColorXP.cpp
@@ -18,7 +18,8 @@
  */
 class DisableColorXP : public GrXferProcessor {
 public:
-    DisableColorXP() { this->initClassID<DisableColorXP>(); }
+    DisableColorXP()
+    : INHERITED(kDisableColorXP_ClassID) {}
 
     const char* name() const override { return "Disable Color"; }
 
diff --git a/src/gpu/effects/GrDistanceFieldGeoProc.cpp b/src/gpu/effects/GrDistanceFieldGeoProc.cpp
index dcbb5d5..6cffd9d 100644
--- a/src/gpu/effects/GrDistanceFieldGeoProc.cpp
+++ b/src/gpu/effects/GrDistanceFieldGeoProc.cpp
@@ -237,7 +237,8 @@
 #endif
                                                  uint32_t flags,
                                                  bool usesLocalCoords)
-        : fColor(color)
+        : INHERITED(kGrDistanceFieldA8TextGeoProc_ClassID)
+        , fColor(color)
         , fViewMatrix(viewMatrix)
 #ifdef SK_GAMMA_APPLY_TO_A8
         , fDistanceAdjust(distanceAdjust)
@@ -246,7 +247,6 @@
         , fInColor(nullptr)
         , fUsesLocalCoords(usesLocalCoords) {
     SkASSERT(!(flags & ~kNonLCD_DistanceFieldEffectMask));
-    this->initClassID<GrDistanceFieldA8TextGeoProc>();
     fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
     fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType);
     fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kUShort2_GrVertexAttribType);
@@ -498,13 +498,13 @@
                                                  const GrSamplerState& params,
                                                  uint32_t flags,
                                                  bool usesLocalCoords)
-        : fColor(color)
+        : INHERITED(kGrDistanceFieldPathGeoProc_ClassID)
+        , fColor(color)
         , fViewMatrix(viewMatrix)
         , fFlags(flags & kNonLCD_DistanceFieldEffectMask)
         , fInColor(nullptr)
         , fUsesLocalCoords(usesLocalCoords) {
     SkASSERT(!(flags & ~kNonLCD_DistanceFieldEffectMask));
-    this->initClassID<GrDistanceFieldPathGeoProc>();
     fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
     fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType);
     fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kUShort2_GrVertexAttribType);
@@ -817,13 +817,13 @@
                                                  const GrSamplerState& params,
                                                  DistanceAdjust distanceAdjust,
                                                  uint32_t flags, bool usesLocalCoords)
-        : fColor(color)
+        : INHERITED(kGrDistanceFieldLCDTextGeoProc_ClassID)
+        , fColor(color)
         , fViewMatrix(viewMatrix)
         , fDistanceAdjust(distanceAdjust)
         , fFlags(flags & kLCD_DistanceFieldEffectMask)
         , fUsesLocalCoords(usesLocalCoords) {
     SkASSERT(!(flags & ~kLCD_DistanceFieldEffectMask) && (flags & kUseLCD_DistanceFieldEffectFlag));
-    this->initClassID<GrDistanceFieldLCDTextGeoProc>();
     fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
     fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType);
     fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kUShort2_GrVertexAttribType);
diff --git a/src/gpu/effects/GrDitherEffect.cpp b/src/gpu/effects/GrDitherEffect.cpp
index 158c47e..53aa0d2 100644
--- a/src/gpu/effects/GrDitherEffect.cpp
+++ b/src/gpu/effects/GrDitherEffect.cpp
@@ -60,9 +60,7 @@
     return true;
 }
 GrDitherEffect::GrDitherEffect(const GrDitherEffect& src)
-        : INHERITED(src.optimizationFlags()), fRangeType(src.fRangeType) {
-    this->initClassID<GrDitherEffect>();
-}
+        : INHERITED(kGrDitherEffect_ClassID, src.optimizationFlags()), fRangeType(src.fRangeType) {}
 std::unique_ptr<GrFragmentProcessor> GrDitherEffect::clone() const {
     return std::unique_ptr<GrFragmentProcessor>(new GrDitherEffect(*this));
 }
diff --git a/src/gpu/effects/GrDitherEffect.h b/src/gpu/effects/GrDitherEffect.h
index d428c3c..fb60b5a 100644
--- a/src/gpu/effects/GrDitherEffect.h
+++ b/src/gpu/effects/GrDitherEffect.h
@@ -51,9 +51,8 @@
     const char* name() const override { return "DitherEffect"; }
 
 private:
-    GrDitherEffect(int rangeType) : INHERITED(kNone_OptimizationFlags), fRangeType(rangeType) {
-        this->initClassID<GrDitherEffect>();
-    }
+    GrDitherEffect(int rangeType)
+            : INHERITED(kGrDitherEffect_ClassID, kNone_OptimizationFlags), fRangeType(rangeType) {}
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
     void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
     bool onIsEqual(const GrFragmentProcessor&) const override;
diff --git a/src/gpu/effects/GrEllipseEffect.cpp b/src/gpu/effects/GrEllipseEffect.cpp
index 0790211..a79ec1c 100644
--- a/src/gpu/effects/GrEllipseEffect.cpp
+++ b/src/gpu/effects/GrEllipseEffect.cpp
@@ -114,12 +114,10 @@
     return true;
 }
 GrEllipseEffect::GrEllipseEffect(const GrEllipseEffect& src)
-        : INHERITED(src.optimizationFlags())
+        : INHERITED(kGrEllipseEffect_ClassID, src.optimizationFlags())
         , fEdgeType(src.fEdgeType)
         , fCenter(src.fCenter)
-        , fRadii(src.fRadii) {
-    this->initClassID<GrEllipseEffect>();
-}
+        , fRadii(src.fRadii) {}
 std::unique_ptr<GrFragmentProcessor> GrEllipseEffect::clone() const {
     return std::unique_ptr<GrFragmentProcessor>(new GrEllipseEffect(*this));
 }
diff --git a/src/gpu/effects/GrEllipseEffect.h b/src/gpu/effects/GrEllipseEffect.h
index 1425f39..98f44a9 100644
--- a/src/gpu/effects/GrEllipseEffect.h
+++ b/src/gpu/effects/GrEllipseEffect.h
@@ -29,12 +29,11 @@
 
 private:
     GrEllipseEffect(int edgeType, SkPoint center, SkPoint radii)
-            : INHERITED((OptimizationFlags)kCompatibleWithCoverageAsAlpha_OptimizationFlag)
+            : INHERITED(kGrEllipseEffect_ClassID,
+                        (OptimizationFlags)kCompatibleWithCoverageAsAlpha_OptimizationFlag)
             , fEdgeType(edgeType)
             , fCenter(center)
-            , fRadii(radii) {
-        this->initClassID<GrEllipseEffect>();
-    }
+            , fRadii(radii) {}
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
     void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
     bool onIsEqual(const GrFragmentProcessor&) const override;
diff --git a/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp b/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp
index ee27aa8..5fae103 100644
--- a/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp
+++ b/src/gpu/effects/GrGaussianConvolutionFragmentProcessor.cpp
@@ -201,13 +201,13 @@
                                                             float gaussianSigma,
                                                             GrTextureDomain::Mode mode,
                                                             int bounds[2])
-        : INHERITED(ModulateByConfigOptimizationFlags(proxy->config()))
+        : INHERITED(kGrGaussianConvolutionFragmentProcessor_ClassID,
+                    ModulateByConfigOptimizationFlags(proxy->config()))
         , fCoordTransform(proxy.get())
         , fTextureSampler(std::move(proxy))
         , fRadius(radius)
         , fDirection(direction)
         , fMode(mode) {
-    this->initClassID<GrGaussianConvolutionFragmentProcessor>();
     this->addCoordTransform(&fCoordTransform);
     this->addTextureSampler(&fTextureSampler);
     SkASSERT(radius <= kMaxKernelRadius);
@@ -219,13 +219,12 @@
 
 GrGaussianConvolutionFragmentProcessor::GrGaussianConvolutionFragmentProcessor(
         const GrGaussianConvolutionFragmentProcessor& that)
-        : INHERITED(that.optimizationFlags())
+        : INHERITED(kGrGaussianConvolutionFragmentProcessor_ClassID, that.optimizationFlags())
         , fCoordTransform(that.fCoordTransform)
         , fTextureSampler(that.fTextureSampler)
         , fRadius(that.fRadius)
         , fDirection(that.fDirection)
         , fMode(that.fMode) {
-    this->initClassID<GrGaussianConvolutionFragmentProcessor>();
     this->addCoordTransform(&fCoordTransform);
     this->addTextureSampler(&fTextureSampler);
     memcpy(fKernel, that.fKernel, that.width() * sizeof(float));
diff --git a/src/gpu/effects/GrMatrixConvolutionEffect.cpp b/src/gpu/effects/GrMatrixConvolutionEffect.cpp
index 73fce4d..ffbcf50 100644
--- a/src/gpu/effects/GrMatrixConvolutionEffect.cpp
+++ b/src/gpu/effects/GrMatrixConvolutionEffect.cpp
@@ -155,7 +155,7 @@
                                                      bool convolveAlpha)
         // To advertise either the modulation or opaqueness optimizations we'd have to examine the
         // parameters.
-        : INHERITED(kNone_OptimizationFlags)
+        : INHERITED(kGrMatrixConvolutionEffect_ClassID, kNone_OptimizationFlags)
         , fCoordTransform(proxy.get())
         , fDomain(proxy.get(), GrTextureDomain::MakeTexelDomainForMode(bounds, tileMode), tileMode)
         , fTextureSampler(std::move(proxy))
@@ -163,7 +163,6 @@
         , fGain(SkScalarToFloat(gain))
         , fBias(SkScalarToFloat(bias) / 255.0f)
         , fConvolveAlpha(convolveAlpha) {
-    this->initClassID<GrMatrixConvolutionEffect>();
     this->addCoordTransform(&fCoordTransform);
     this->addTextureSampler(&fTextureSampler);
     for (int i = 0; i < kernelSize.width() * kernelSize.height(); i++) {
@@ -174,7 +173,7 @@
 }
 
 GrMatrixConvolutionEffect::GrMatrixConvolutionEffect(const GrMatrixConvolutionEffect& that)
-        : INHERITED(kNone_OptimizationFlags)
+        : INHERITED(kGrMatrixConvolutionEffect_ClassID, kNone_OptimizationFlags)
         , fCoordTransform(that.fCoordTransform)
         , fDomain(that.fDomain)
         , fTextureSampler(that.fTextureSampler)
@@ -182,7 +181,6 @@
         , fGain(that.fGain)
         , fBias(that.fBias)
         , fConvolveAlpha(that.fConvolveAlpha) {
-    this->initClassID<GrMatrixConvolutionEffect>();
     this->addCoordTransform(&fCoordTransform);
     this->addTextureSampler(&fTextureSampler);
     memcpy(fKernel, that.fKernel, sizeof(float) * fKernelSize.width() * fKernelSize.height());
diff --git a/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp b/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp
index fee7f17..7bdb04e 100644
--- a/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp
+++ b/src/gpu/effects/GrNonlinearColorSpaceXformEffect.cpp
@@ -138,10 +138,10 @@
 GrNonlinearColorSpaceXformEffect::GrNonlinearColorSpaceXformEffect(
     uint32_t ops, const SkColorSpaceTransferFn& srcTransferFn,
     const SkColorSpaceTransferFn& dstTransferFn, const SkMatrix44& gamutXform)
-        : INHERITED(kPreservesOpaqueInput_OptimizationFlag)
+        : INHERITED(kGrNonlinearColorSpaceXformEffect_ClassID,
+                    kPreservesOpaqueInput_OptimizationFlag)
         , fGamutXform(gamutXform)
         , fOps(ops) {
-    this->initClassID<GrNonlinearColorSpaceXformEffect>();
 
     fSrcTransferFnCoeffs[0] = srcTransferFn.fA;
     fSrcTransferFnCoeffs[1] = srcTransferFn.fB;
@@ -162,10 +162,10 @@
 
 GrNonlinearColorSpaceXformEffect::GrNonlinearColorSpaceXformEffect(
         const GrNonlinearColorSpaceXformEffect& that)
-        : INHERITED(kPreservesOpaqueInput_OptimizationFlag)
+        : INHERITED(kGrNonlinearColorSpaceXformEffect_ClassID,
+                    kPreservesOpaqueInput_OptimizationFlag)
         , fGamutXform(that.fGamutXform)
         , fOps(that.fOps) {
-    this->initClassID<GrNonlinearColorSpaceXformEffect>();
     memcpy(fSrcTransferFnCoeffs, that.fSrcTransferFnCoeffs, sizeof(fSrcTransferFnCoeffs));
     memcpy(fDstTransferFnCoeffs, that.fDstTransferFnCoeffs, sizeof(fDstTransferFnCoeffs));
 }
diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.cpp b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
index 4f23bdc..f4af7a4 100644
--- a/src/gpu/effects/GrPorterDuffXferProcessor.cpp
+++ b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
@@ -397,9 +397,8 @@
 class PorterDuffXferProcessor : public GrXferProcessor {
 public:
     PorterDuffXferProcessor(BlendFormula blendFormula, GrProcessorAnalysisCoverage coverage)
-            : INHERITED(false, false, coverage)
+            : INHERITED(kPorterDuffXferProcessor_ClassID, false, false, coverage)
             , fBlendFormula(blendFormula) {
-        this->initClassID<PorterDuffXferProcessor>();
     }
 
     const char* name() const override { return "Porter Duff"; }
@@ -509,8 +508,8 @@
 public:
     ShaderPDXferProcessor(bool hasMixedSamples, SkBlendMode xfermode,
                           GrProcessorAnalysisCoverage coverage)
-            : INHERITED(true, hasMixedSamples, coverage), fXfermode(xfermode) {
-        this->initClassID<ShaderPDXferProcessor>();
+            : INHERITED(kShaderPDXferProcessor_ClassID, true, hasMixedSamples, coverage)
+            , fXfermode(xfermode) {
     }
 
     const char* name() const override { return "Porter Duff Shader"; }
@@ -656,10 +655,9 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 PDLCDXferProcessor::PDLCDXferProcessor(GrColor blendConstant, uint8_t alpha)
-    : INHERITED(false, false, GrProcessorAnalysisCoverage::kLCD)
+    : INHERITED(kPDLCDXferProcessor_ClassID, false, false, GrProcessorAnalysisCoverage::kLCD)
     , fBlendConstant(blendConstant)
     , fAlpha(alpha) {
-    this->initClassID<PDLCDXferProcessor>();
 }
 
 sk_sp<const GrXferProcessor> PDLCDXferProcessor::Make(SkBlendMode mode,
diff --git a/src/gpu/effects/GrRRectEffect.cpp b/src/gpu/effects/GrRRectEffect.cpp
index 7ad354c..8df9bcb 100644
--- a/src/gpu/effects/GrRRectEffect.cpp
+++ b/src/gpu/effects/GrRRectEffect.cpp
@@ -90,11 +90,10 @@
 
 CircularRRectEffect::CircularRRectEffect(GrPrimitiveEdgeType edgeType, uint32_t circularCornerFlags,
                                          const SkRRect& rrect)
-        : INHERITED(kCompatibleWithCoverageAsAlpha_OptimizationFlag)
+        : INHERITED(kCircularRRectEffect_ClassID, kCompatibleWithCoverageAsAlpha_OptimizationFlag)
         , fRRect(rrect)
         , fEdgeType(edgeType)
         , fCircularCornerFlags(circularCornerFlags) {
-    this->initClassID<CircularRRectEffect>();
 }
 
 std::unique_ptr<GrFragmentProcessor> CircularRRectEffect::clone() const {
@@ -425,10 +424,9 @@
 }
 
 EllipticalRRectEffect::EllipticalRRectEffect(GrPrimitiveEdgeType edgeType, const SkRRect& rrect)
-        : INHERITED(kCompatibleWithCoverageAsAlpha_OptimizationFlag)
+        : INHERITED(kEllipticalRRectEffect_ClassID, kCompatibleWithCoverageAsAlpha_OptimizationFlag)
         , fRRect(rrect)
         , fEdgeType(edgeType) {
-    this->initClassID<EllipticalRRectEffect>();
 }
 
 std::unique_ptr<GrFragmentProcessor> EllipticalRRectEffect::clone() const {
diff --git a/src/gpu/effects/GrSRGBEffect.cpp b/src/gpu/effects/GrSRGBEffect.cpp
index 0e56dfc..7e823ea 100644
--- a/src/gpu/effects/GrSRGBEffect.cpp
+++ b/src/gpu/effects/GrSRGBEffect.cpp
@@ -77,12 +77,11 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 GrSRGBEffect::GrSRGBEffect(Mode mode, Alpha alpha)
-    : INHERITED(kPreservesOpaqueInput_OptimizationFlag |
+    : INHERITED(kGrSRGBEffect_ClassID, kPreservesOpaqueInput_OptimizationFlag |
                 kConstantOutputForConstantInput_OptimizationFlag)
     , fMode(mode)
     , fAlpha(alpha)
 {
-    this->initClassID<GrSRGBEffect>();
 }
 
 std::unique_ptr<GrFragmentProcessor> GrSRGBEffect::clone() const { return Make(fMode, fAlpha); }
diff --git a/src/gpu/effects/GrShadowGeoProc.cpp b/src/gpu/effects/GrShadowGeoProc.cpp
index 3217f46..682486b 100644
--- a/src/gpu/effects/GrShadowGeoProc.cpp
+++ b/src/gpu/effects/GrShadowGeoProc.cpp
@@ -63,8 +63,8 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrRRectShadowGeoProc::GrRRectShadowGeoProc() {
-    this->initClassID<GrRRectShadowGeoProc>();
+GrRRectShadowGeoProc::GrRRectShadowGeoProc()
+: INHERITED(kGrRRectShadowGeoProc_ClassID) {
     fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
     fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType);
     fInShadowParams = &this->addVertexAttrib("inShadowParams", kHalf4_GrVertexAttribType);
diff --git a/src/gpu/effects/GrSimpleTextureEffect.cpp b/src/gpu/effects/GrSimpleTextureEffect.cpp
index ad2a533..2c44ce4 100644
--- a/src/gpu/effects/GrSimpleTextureEffect.cpp
+++ b/src/gpu/effects/GrSimpleTextureEffect.cpp
@@ -70,12 +70,11 @@
     return true;
 }
 GrSimpleTextureEffect::GrSimpleTextureEffect(const GrSimpleTextureEffect& src)
-        : INHERITED(src.optimizationFlags())
+        : INHERITED(kGrSimpleTextureEffect_ClassID, src.optimizationFlags())
         , fImage(src.fImage)
         , fColorXform(src.fColorXform)
         , fMatrix(src.fMatrix)
         , fImageCoordTransform(src.fImageCoordTransform) {
-    this->initClassID<GrSimpleTextureEffect>();
     this->addTextureSampler(&fImage);
     this->addCoordTransform(&fImageCoordTransform);
 }
diff --git a/src/gpu/effects/GrSimpleTextureEffect.h b/src/gpu/effects/GrSimpleTextureEffect.h
index 6e8fa28..7f98b13 100644
--- a/src/gpu/effects/GrSimpleTextureEffect.h
+++ b/src/gpu/effects/GrSimpleTextureEffect.h
@@ -56,17 +56,17 @@
 private:
     GrSimpleTextureEffect(sk_sp<GrTextureProxy> image, sk_sp<GrColorSpaceXform> colorXform,
                           SkMatrix44 matrix, GrSamplerState samplerParams)
-            : INHERITED((OptimizationFlags)kCompatibleWithCoverageAsAlpha_OptimizationFlag |
-                        (GrPixelConfigIsOpaque(image->config())
-                                 ? kPreservesOpaqueInput_OptimizationFlag
-                                 : kNone_OptimizationFlags))
+            : INHERITED(kGrSimpleTextureEffect_ClassID,
+                        (OptimizationFlags)kCompatibleWithCoverageAsAlpha_OptimizationFlag |
+                                (GrPixelConfigIsOpaque(image->config())
+                                         ? kPreservesOpaqueInput_OptimizationFlag
+                                         : kNone_OptimizationFlags))
             , fImage(std::move(image), samplerParams)
             , fColorXform(colorXform)
             , fMatrix(matrix)
             , fImageCoordTransform(matrix, fImage.proxy()) {
         this->addTextureSampler(&fImage);
         this->addCoordTransform(&fImageCoordTransform);
-        this->initClassID<GrSimpleTextureEffect>();
     }
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
     void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override;
diff --git a/src/gpu/effects/GrTextureDomain.cpp b/src/gpu/effects/GrTextureDomain.cpp
index 671bec6..9e4abeb 100644
--- a/src/gpu/effects/GrTextureDomain.cpp
+++ b/src/gpu/effects/GrTextureDomain.cpp
@@ -228,25 +228,23 @@
                                              const SkRect& domain,
                                              GrTextureDomain::Mode mode,
                                              GrSamplerState::Filter filterMode)
-        : INHERITED(OptFlags(proxy->config(), mode))
+        : INHERITED(kGrTextureDomainEffect_ClassID, OptFlags(proxy->config(), mode))
         , fCoordTransform(matrix, proxy.get())
         , fTextureDomain(proxy.get(), domain, mode)
         , fTextureSampler(std::move(proxy), filterMode)
         , fColorSpaceXform(std::move(colorSpaceXform)) {
     SkASSERT(mode != GrTextureDomain::kRepeat_Mode ||
              filterMode == GrSamplerState::Filter::kNearest);
-    this->initClassID<GrTextureDomainEffect>();
     this->addCoordTransform(&fCoordTransform);
     this->addTextureSampler(&fTextureSampler);
 }
 
 GrTextureDomainEffect::GrTextureDomainEffect(const GrTextureDomainEffect& that)
-        : INHERITED(that.optimizationFlags())
+        : INHERITED(kGrTextureDomainEffect_ClassID, that.optimizationFlags())
         , fCoordTransform(that.fCoordTransform)
         , fTextureDomain(that.fTextureDomain)
         , fTextureSampler(that.fTextureSampler)
         , fColorSpaceXform(that.fColorSpaceXform) {
-    this->initClassID<GrTextureDomainEffect>();
     this->addCoordTransform(&fCoordTransform);
     this->addTextureSampler(&fTextureSampler);
 }
@@ -343,23 +341,23 @@
 
 GrDeviceSpaceTextureDecalFragmentProcessor::GrDeviceSpaceTextureDecalFragmentProcessor(
         sk_sp<GrTextureProxy> proxy, const SkIRect& subset, const SkIPoint& deviceSpaceOffset)
-        : INHERITED(kCompatibleWithCoverageAsAlpha_OptimizationFlag)
+        : INHERITED(kGrDeviceSpaceTextureDecalFragmentProcessor_ClassID,
+                    kCompatibleWithCoverageAsAlpha_OptimizationFlag)
         , fTextureSampler(proxy, GrSamplerState::ClampNearest())
         , fTextureDomain(proxy.get(), GrTextureDomain::MakeTexelDomain(subset),
                          GrTextureDomain::kDecal_Mode) {
     this->addTextureSampler(&fTextureSampler);
     fDeviceSpaceOffset.fX = deviceSpaceOffset.fX - subset.fLeft;
     fDeviceSpaceOffset.fY = deviceSpaceOffset.fY - subset.fTop;
-    this->initClassID<GrDeviceSpaceTextureDecalFragmentProcessor>();
 }
 
 GrDeviceSpaceTextureDecalFragmentProcessor::GrDeviceSpaceTextureDecalFragmentProcessor(
         const GrDeviceSpaceTextureDecalFragmentProcessor& that)
-        : INHERITED(kCompatibleWithCoverageAsAlpha_OptimizationFlag)
+        : INHERITED(kGrDeviceSpaceTextureDecalFragmentProcessor_ClassID,
+                    kCompatibleWithCoverageAsAlpha_OptimizationFlag)
         , fTextureSampler(that.fTextureSampler)
         , fTextureDomain(that.fTextureDomain)
         , fDeviceSpaceOffset(that.fDeviceSpaceOffset) {
-    this->initClassID<GrDeviceSpaceTextureDecalFragmentProcessor>();
     this->addTextureSampler(&fTextureSampler);
 }
 
diff --git a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
index 11dee67..4a92289 100644
--- a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
+++ b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
@@ -58,8 +58,8 @@
     ComposeTwoFragmentProcessor(std::unique_ptr<GrFragmentProcessor> src,
                                 std::unique_ptr<GrFragmentProcessor> dst,
                                 SkBlendMode mode)
-            : INHERITED(OptFlags(src.get(), dst.get(), mode)), fMode(mode) {
-        this->initClassID<ComposeTwoFragmentProcessor>();
+            : INHERITED(kComposeTwoFragmentProcessor_ClassID, OptFlags(src.get(), dst.get(), mode))
+            , fMode(mode) {
         SkDEBUGCODE(int shaderAChildIndex = )this->registerChildProcessor(std::move(src));
         SkDEBUGCODE(int shaderBChildIndex = )this->registerChildProcessor(std::move(dst));
         SkASSERT(0 == shaderAChildIndex);
@@ -421,8 +421,9 @@
 private:
     ComposeOneFragmentProcessor(std::unique_ptr<GrFragmentProcessor> fp, SkBlendMode mode,
                                 Child child)
-            : INHERITED(OptFlags(fp.get(), mode, child)), fMode(mode), fChild(child) {
-        this->initClassID<ComposeOneFragmentProcessor>();
+            : INHERITED(kComposeOneFragmentProcessor_ClassID, OptFlags(fp.get(), mode, child))
+            , fMode(mode)
+            , fChild(child) {
         SkDEBUGCODE(int dstIndex =) this->registerChildProcessor(std::move(fp));
         SkASSERT(0 == dstIndex);
     }
diff --git a/src/gpu/effects/GrYUVEffect.cpp b/src/gpu/effects/GrYUVEffect.cpp
index bf9e94f..6e0f766 100644
--- a/src/gpu/effects/GrYUVEffect.cpp
+++ b/src/gpu/effects/GrYUVEffect.cpp
@@ -138,7 +138,7 @@
     YUVtoRGBEffect(sk_sp<GrTextureProxy> yProxy, sk_sp<GrTextureProxy> uProxy,
                    sk_sp<GrTextureProxy> vProxy, const SkMatrix yuvMatrix[3],
                    GrSamplerState::Filter uvFilterMode, SkYUVColorSpace colorSpace, bool nv12)
-            : INHERITED(kPreservesOpaqueInput_OptimizationFlag)
+            : INHERITED(kYUVtoRGBEffect_ClassID, kPreservesOpaqueInput_OptimizationFlag)
             , fYTransform(yuvMatrix[0], yProxy.get())
             , fYSampler(std::move(yProxy))
             , fUTransform(yuvMatrix[1], uProxy.get())
@@ -146,7 +146,6 @@
             , fVSampler(vProxy, uvFilterMode)
             , fColorSpace(colorSpace)
             , fNV12(nv12) {
-        this->initClassID<YUVtoRGBEffect>();
         this->addCoordTransform(&fYTransform);
         this->addTextureSampler(&fYSampler);
         this->addCoordTransform(&fUTransform);
@@ -159,7 +158,7 @@
     }
 
     YUVtoRGBEffect(const YUVtoRGBEffect& that)
-            : INHERITED(kPreservesOpaqueInput_OptimizationFlag)
+            : INHERITED(kYUVtoRGBEffect_ClassID, kPreservesOpaqueInput_OptimizationFlag)
             , fYTransform(that.fYTransform)
             , fYSampler(that.fYSampler)
             , fUTransform(that.fUTransform)
@@ -168,7 +167,6 @@
             , fVSampler(that.fVSampler)
             , fColorSpace(that.fColorSpace)
             , fNV12(that.fNV12) {
-        this->initClassID<YUVtoRGBEffect>();
         this->addCoordTransform(&fYTransform);
         this->addTextureSampler(&fYSampler);
         this->addCoordTransform(&fUTransform);
diff --git a/src/gpu/instanced/InstanceProcessor.cpp b/src/gpu/instanced/InstanceProcessor.cpp
index 5890028..5332e2d 100644
--- a/src/gpu/instanced/InstanceProcessor.cpp
+++ b/src/gpu/instanced/InstanceProcessor.cpp
@@ -40,9 +40,9 @@
     return GrCaps::InstancedSupport::kMixedSampled;
 }
 
-InstanceProcessor::InstanceProcessor(OpInfo opInfo, GrBuffer* paramsBuffer) : fOpInfo(opInfo) {
-    this->initClassID<InstanceProcessor>();
-
+InstanceProcessor::InstanceProcessor(OpInfo opInfo, GrBuffer* paramsBuffer)
+: INHERITED(kInstanceProcessor_ClassID)
+, fOpInfo(opInfo) {
     this->addVertexAttrib("shapeCoords", kFloat2_GrVertexAttribType);
     this->addVertexAttrib("vertexAttrs", kInt_GrVertexAttribType);
     this->addVertexAttrib("instanceInfo", kUint_GrVertexAttribType);
diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp
index 292f594..47c4045 100644
--- a/src/gpu/ops/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp
@@ -634,8 +634,9 @@
 
 private:
     QuadEdgeEffect(const SkMatrix& localMatrix, bool usesLocalCoords)
-            : fLocalMatrix(localMatrix), fUsesLocalCoords(usesLocalCoords) {
-        this->initClassID<QuadEdgeEffect>();
+            : INHERITED(kQuadEdgeEffect_ClassID)
+            , fLocalMatrix(localMatrix)
+            , fUsesLocalCoords(usesLocalCoords) {
         fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
         fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType);
         fInQuadEdge = &this->addVertexAttrib("inQuadEdge", kHalf4_GrVertexAttribType);
diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp
index 8090f43..ee87f20 100644
--- a/src/gpu/ops/GrDashOp.cpp
+++ b/src/gpu/ops/GrDashOp.cpp
@@ -978,11 +978,11 @@
                                          AAMode aaMode,
                                          const SkMatrix& localMatrix,
                                          bool usesLocalCoords)
-    : fColor(color)
+    : INHERITED(kDashingCircleEffect_ClassID)
+    , fColor(color)
     , fLocalMatrix(localMatrix)
     , fUsesLocalCoords(usesLocalCoords)
     , fAAMode(aaMode) {
-    this->initClassID<DashingCircleEffect>();
     fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
     fInDashParams = &this->addVertexAttrib("inDashParams", kHalf3_GrVertexAttribType);
     fInCircleParams = &this->addVertexAttrib("inCircleParams", kHalf2_GrVertexAttribType);
@@ -1200,11 +1200,11 @@
                                      AAMode aaMode,
                                      const SkMatrix& localMatrix,
                                      bool usesLocalCoords)
-    : fColor(color)
+    : INHERITED(kDashingLineEffect_ClassID)
+    , fColor(color)
     , fLocalMatrix(localMatrix)
     , fUsesLocalCoords(usesLocalCoords)
     , fAAMode(aaMode) {
-    this->initClassID<DashingLineEffect>();
     fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
     fInDashParams = &this->addVertexAttrib("inDashParams", kHalf3_GrVertexAttribType);
     fInRectParams = &this->addVertexAttrib("inRect", kHalf4_GrVertexAttribType);
diff --git a/src/gpu/ops/GrMSAAPathRenderer.cpp b/src/gpu/ops/GrMSAAPathRenderer.cpp
index 5c46563..9021587 100644
--- a/src/gpu/ops/GrMSAAPathRenderer.cpp
+++ b/src/gpu/ops/GrMSAAPathRenderer.cpp
@@ -197,8 +197,8 @@
 
 private:
     MSAAQuadProcessor(const SkMatrix& viewMatrix)
-        : fViewMatrix(viewMatrix) {
-        this->initClassID<MSAAQuadProcessor>();
+        : INHERITED(kMSAAQuadProcessor_ClassID)
+        , fViewMatrix(viewMatrix) {
         fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
         fInUV = &this->addVertexAttrib("inUV", kFloat2_GrVertexAttribType);
         fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType);
diff --git a/src/gpu/ops/GrOvalOpFactory.cpp b/src/gpu/ops/GrOvalOpFactory.cpp
index b29ecf7..da4668f 100644
--- a/src/gpu/ops/GrOvalOpFactory.cpp
+++ b/src/gpu/ops/GrOvalOpFactory.cpp
@@ -68,8 +68,8 @@
 public:
     CircleGeometryProcessor(bool stroke, bool clipPlane, bool isectPlane, bool unionPlane,
                             const SkMatrix& localMatrix)
-            : fLocalMatrix(localMatrix) {
-        this->initClassID<CircleGeometryProcessor>();
+            : INHERITED(kCircleGeometryProcessor_ClassID)
+            , fLocalMatrix(localMatrix) {
         fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
         fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType);
         fInCircleEdge = &this->addVertexAttrib("inCircleEdge", kFloat4_GrVertexAttribType);
@@ -238,8 +238,9 @@
 
 class EllipseGeometryProcessor : public GrGeometryProcessor {
 public:
-    EllipseGeometryProcessor(bool stroke, const SkMatrix& localMatrix) : fLocalMatrix(localMatrix) {
-        this->initClassID<EllipseGeometryProcessor>();
+    EllipseGeometryProcessor(bool stroke, const SkMatrix& localMatrix)
+    : INHERITED(kEllipseGeometryProcessor_ClassID)
+    , fLocalMatrix(localMatrix) {
         fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
         fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType);
         fInEllipseOffset = &this->addVertexAttrib("inEllipseOffset", kHalf2_GrVertexAttribType);
@@ -379,8 +380,8 @@
 class DIEllipseGeometryProcessor : public GrGeometryProcessor {
 public:
     DIEllipseGeometryProcessor(const SkMatrix& viewMatrix, DIEllipseStyle style)
-            : fViewMatrix(viewMatrix) {
-        this->initClassID<DIEllipseGeometryProcessor>();
+            : INHERITED(kDIEllipseGeometryProcessor_ClassID)
+            , fViewMatrix(viewMatrix) {
         fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
         fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType);
         fInEllipseOffsets0 = &this->addVertexAttrib("inEllipseOffsets0", kHalf2_GrVertexAttribType);
diff --git a/src/gpu/ops/GrTextureOp.cpp b/src/gpu/ops/GrTextureOp.cpp
index 7ef7757..ab82a9c 100644
--- a/src/gpu/ops/GrTextureOp.cpp
+++ b/src/gpu/ops/GrTextureOp.cpp
@@ -174,9 +174,9 @@
     TextureGeometryProcessor(sk_sp<GrTextureProxy> proxies[], int proxyCnt, int samplerCnt,
                              sk_sp<GrColorSpaceXform> csxf, const GrSamplerState::Filter filters[],
                              const GrShaderCaps& caps)
-            : fColorSpaceXform(std::move(csxf)) {
+            : INHERITED(kTextureGeometryProcessor_ClassID)
+            , fColorSpaceXform(std::move(csxf)) {
         SkASSERT(proxyCnt > 0 && samplerCnt >= proxyCnt);
-        this->initClassID<TextureGeometryProcessor>();
         fPositions = this->addVertexAttrib("position", kFloat2_GrVertexAttribType);
         fSamplers[0].reset(std::move(proxies[0]), filters[0]);
         this->addTextureSampler(&fSamplers[0]);
@@ -208,6 +208,8 @@
     Attribute fColors;
     sk_sp<GrColorSpaceXform> fColorSpaceXform;
     TextureSampler fSamplers[1];
+
+    typedef GrGeometryProcessor INHERITED;
 };
 
 /**
diff --git a/src/shaders/SkPerlinNoiseShader.cpp b/src/shaders/SkPerlinNoiseShader.cpp
index 1f70d50..b1ef1f0 100644
--- a/src/shaders/SkPerlinNoiseShader.cpp
+++ b/src/shaders/SkPerlinNoiseShader.cpp
@@ -741,14 +741,13 @@
                          sk_sp<GrTextureProxy> permutationsProxy,
                          sk_sp<GrTextureProxy> noiseProxy,
                          const SkMatrix& matrix)
-            : INHERITED(kNone_OptimizationFlags)
+            : INHERITED(kGrPerlinNoise2Effect_ClassID, kNone_OptimizationFlags)
             , fType(type)
             , fNumOctaves(numOctaves)
             , fStitchTiles(stitchTiles)
             , fPermutationsSampler(std::move(permutationsProxy))
             , fNoiseSampler(std::move(noiseProxy))
             , fPaintingData(std::move(paintingData)) {
-        this->initClassID<GrPerlinNoise2Effect>();
         this->addTextureSampler(&fPermutationsSampler);
         this->addTextureSampler(&fNoiseSampler);
         fCoordTransform.reset(matrix);
@@ -756,7 +755,7 @@
     }
 
     GrPerlinNoise2Effect(const GrPerlinNoise2Effect& that)
-            : INHERITED(kNone_OptimizationFlags)
+            : INHERITED(kGrPerlinNoise2Effect_ClassID, kNone_OptimizationFlags)
             , fType(that.fType)
             , fCoordTransform(that.fCoordTransform)
             , fNumOctaves(that.fNumOctaves)
@@ -764,7 +763,6 @@
             , fPermutationsSampler(that.fPermutationsSampler)
             , fNoiseSampler(that.fNoiseSampler)
             , fPaintingData(new SkPerlinNoiseShaderImpl::PaintingData(*that.fPaintingData)) {
-        this->initClassID<GrPerlinNoise2Effect>();
         this->addTextureSampler(&fPermutationsSampler);
         this->addTextureSampler(&fNoiseSampler);
         this->addCoordTransform(&fCoordTransform);
@@ -1165,13 +1163,12 @@
                                 sk_sp<GrTextureProxy> permutationsProxy,
                                 sk_sp<GrTextureProxy> gradientProxy,
                                 const SkMatrix& matrix)
-            : INHERITED(kNone_OptimizationFlags)
+            : INHERITED(kGrImprovedPerlinNoiseEffect_ClassID, kNone_OptimizationFlags)
             , fOctaves(octaves)
             , fZ(z)
             , fPermutationsSampler(std::move(permutationsProxy))
             , fGradientSampler(std::move(gradientProxy))
             , fPaintingData(std::move(paintingData)) {
-        this->initClassID<GrImprovedPerlinNoiseEffect>();
         this->addTextureSampler(&fPermutationsSampler);
         this->addTextureSampler(&fGradientSampler);
         fCoordTransform.reset(matrix);
@@ -1179,14 +1176,13 @@
     }
 
     GrImprovedPerlinNoiseEffect(const GrImprovedPerlinNoiseEffect& that)
-            : INHERITED(kNone_OptimizationFlags)
+            : INHERITED(kGrImprovedPerlinNoiseEffect_ClassID, kNone_OptimizationFlags)
             , fCoordTransform(that.fCoordTransform)
             , fOctaves(that.fOctaves)
             , fZ(that.fZ)
             , fPermutationsSampler(that.fPermutationsSampler)
             , fGradientSampler(that.fGradientSampler)
             , fPaintingData(new SkPerlinNoiseShaderImpl::PaintingData(*that.fPaintingData)) {
-        this->initClassID<GrImprovedPerlinNoiseEffect>();
         this->addTextureSampler(&fPermutationsSampler);
         this->addTextureSampler(&fGradientSampler);
         this->addCoordTransform(&fCoordTransform);
diff --git a/src/shaders/gradients/SkGradientShader.cpp b/src/shaders/gradients/SkGradientShader.cpp
index 88990c7..87f1910 100644
--- a/src/shaders/gradients/SkGradientShader.cpp
+++ b/src/shaders/gradients/SkGradientShader.cpp
@@ -1697,8 +1697,8 @@
                    : kCompatibleWithCoverageAsAlpha_OptimizationFlag;
 }
 
-GrGradientEffect::GrGradientEffect(const CreateArgs& args, bool isOpaque)
-        : INHERITED(OptFlags(isOpaque)) {
+GrGradientEffect::GrGradientEffect(ClassID classID, const CreateArgs& args, bool isOpaque)
+        : INHERITED(classID, OptFlags(isOpaque)) {
     const SkGradientShaderBase& shader(*args.fShader);
 
     fIsOpaque = shader.isOpaque();
@@ -1815,7 +1815,7 @@
 }
 
 GrGradientEffect::GrGradientEffect(const GrGradientEffect& that)
-        : INHERITED(OptFlags(that.fIsOpaque))
+        : INHERITED(that.classID(), OptFlags(that.fIsOpaque))
         , fColors(that.fColors)
         , fColors4f(that.fColors4f)
         , fColorSpaceXform(that.fColorSpaceXform)
diff --git a/src/shaders/gradients/SkGradientShaderPriv.h b/src/shaders/gradients/SkGradientShaderPriv.h
index c5a9b17..30e9440 100644
--- a/src/shaders/gradients/SkGradientShaderPriv.h
+++ b/src/shaders/gradients/SkGradientShaderPriv.h
@@ -426,7 +426,7 @@
     }
 
 protected:
-    GrGradientEffect(const CreateArgs&, bool isOpaque);
+    GrGradientEffect(ClassID classID, const CreateArgs&, bool isOpaque);
     explicit GrGradientEffect(const GrGradientEffect&);  // facilitates clone() implementations
 
     #if GR_TEST_UTILS
diff --git a/src/shaders/gradients/SkLinearGradient.cpp b/src/shaders/gradients/SkLinearGradient.cpp
index 04e8282..8b439ce 100644
--- a/src/shaders/gradients/SkLinearGradient.cpp
+++ b/src/shaders/gradients/SkLinearGradient.cpp
@@ -112,13 +112,10 @@
 
 private:
     explicit GrLinearGradient(const CreateArgs& args)
-            : INHERITED(args, args.fShader->colorsAreOpaque()) {
-        this->initClassID<GrLinearGradient>();
+            : INHERITED(kGrLinearGradient_ClassID, args, args.fShader->colorsAreOpaque()) {
     }
 
-    explicit GrLinearGradient(const GrLinearGradient& that) : INHERITED(that) {
-        this->initClassID<GrLinearGradient>();
-    }
+    explicit GrLinearGradient(const GrLinearGradient& that) : INHERITED(that) {}
 
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
 
diff --git a/src/shaders/gradients/SkRadialGradient.cpp b/src/shaders/gradients/SkRadialGradient.cpp
index 94d823c..5c31688 100644
--- a/src/shaders/gradients/SkRadialGradient.cpp
+++ b/src/shaders/gradients/SkRadialGradient.cpp
@@ -81,13 +81,9 @@
 
 private:
     explicit GrRadialGradient(const CreateArgs& args)
-            : INHERITED(args, args.fShader->colorsAreOpaque()) {
-        this->initClassID<GrRadialGradient>();
-    }
+            : INHERITED(kGrRadialGradient_ClassID, args, args.fShader->colorsAreOpaque()) {}
 
-    explicit GrRadialGradient(const GrRadialGradient& that) : INHERITED(that) {
-        this->initClassID<GrRadialGradient>();
-    }
+    explicit GrRadialGradient(const GrRadialGradient& that) : INHERITED(that) {}
 
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
 
diff --git a/src/shaders/gradients/SkSweepGradient.cpp b/src/shaders/gradients/SkSweepGradient.cpp
index 0e2b785a..792024f 100644
--- a/src/shaders/gradients/SkSweepGradient.cpp
+++ b/src/shaders/gradients/SkSweepGradient.cpp
@@ -88,18 +88,14 @@
 
 private:
     explicit GrSweepGradient(const CreateArgs& args, SkScalar tBias, SkScalar tScale)
-            : INHERITED(args, args.fShader->colorsAreOpaque())
+            : INHERITED(kGrSweepGradient_ClassID, args, args.fShader->colorsAreOpaque())
             , fTBias(tBias)
-            , fTScale(tScale){
-        this->initClassID<GrSweepGradient>();
-    }
+            , fTScale(tScale) {}
 
     explicit GrSweepGradient(const GrSweepGradient& that)
             : INHERITED(that)
             , fTBias(that.fTBias)
-            , fTScale(that.fTScale) {
-        this->initClassID<GrSweepGradient>();
-    }
+            , fTScale(that.fTScale) {}
 
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
 
diff --git a/src/shaders/gradients/SkTwoPointConicalGradient_gpu.cpp b/src/shaders/gradients/SkTwoPointConicalGradient_gpu.cpp
index 37e0708..a08addb 100644
--- a/src/shaders/gradients/SkTwoPointConicalGradient_gpu.cpp
+++ b/src/shaders/gradients/SkTwoPointConicalGradient_gpu.cpp
@@ -93,13 +93,13 @@
     }
 
     explicit Edge2PtConicalEffect(const CreateArgs& args)
-            : INHERITED(args, false /* opaque: draws transparent black outside of the cone. */) {
+            : INHERITED(kEdge2PtConicalEffect_ClassID, args,
+                        false /* opaque: draws transparent black outside of the cone. */) {
         const SkTwoPointConicalGradient& shader =
             *static_cast<const SkTwoPointConicalGradient*>(args.fShader);
         fCenterX1 = shader.getCenterX1();
         fRadius0 = shader.getStartRadius();
         fDiffRadius = shader.getDiffRadius();
-        this->initClassID<Edge2PtConicalEffect>();
         // We should only be calling this shader if we are degenerate case with touching circles
         // When deciding if we are in edge case, we scaled by the end radius for cases when the
         // start radius was close to zero, otherwise we scaled by the start radius.  In addition
@@ -129,7 +129,6 @@
             , fCenterX1(that.fCenterX1)
             , fRadius0(that.fRadius0)
             , fDiffRadius(that.fDiffRadius) {
-        this->initClassID<Edge2PtConicalEffect>();
         this->addCoordTransform(&fBTransform);
     }
 
@@ -415,15 +414,14 @@
     }
 
     FocalOutside2PtConicalEffect(const CreateArgs& args, SkScalar focalX)
-            : INHERITED(args, false /* opaque: draws transparent black outside of the cone. */)
+            : INHERITED(kFocalOutside2PtConicalEffect_ClassID, args,
+                        false /* opaque: draws transparent black outside of the cone. */)
             , fFocalX(focalX)
             , fIsFlipped(IsFlipped(args)) {
-        this->initClassID<FocalOutside2PtConicalEffect>();
     }
 
     explicit FocalOutside2PtConicalEffect(const FocalOutside2PtConicalEffect& that)
             : INHERITED(that), fFocalX(that.fFocalX), fIsFlipped(that.fIsFlipped) {
-        this->initClassID<FocalOutside2PtConicalEffect>();
     }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
@@ -630,14 +628,11 @@
     }
 
     FocalInside2PtConicalEffect(const CreateArgs& args, SkScalar focalX)
-            : INHERITED(args, args.fShader->colorsAreOpaque()), fFocalX(focalX) {
-        this->initClassID<FocalInside2PtConicalEffect>();
-    }
+            : INHERITED(kFocalInside2PtConicalEffect_ClassID, args,
+                        args.fShader->colorsAreOpaque()), fFocalX(focalX) {}
 
     explicit FocalInside2PtConicalEffect(const FocalInside2PtConicalEffect& that)
-            : INHERITED(that), fFocalX(that.fFocalX) {
-        this->initClassID<FocalInside2PtConicalEffect>();
-    }
+            : INHERITED(that), fFocalX(that.fFocalX) {}
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
 
@@ -880,14 +875,12 @@
     }
 
     CircleInside2PtConicalEffect(const CreateArgs& args, const CircleConicalInfo& info)
-            : INHERITED(args, args.fShader->colorsAreOpaque()), fInfo(info) {
-        this->initClassID<CircleInside2PtConicalEffect>();
+            : INHERITED(kCircleInside2PtConicalEffect_ClassID, args,
+                        args.fShader->colorsAreOpaque()), fInfo(info) {
     }
 
     explicit CircleInside2PtConicalEffect(const CircleInside2PtConicalEffect& that)
-            : INHERITED(that), fInfo(that.fInfo) {
-        this->initClassID<CircleInside2PtConicalEffect>();
-    }
+            : INHERITED(that), fInfo(that.fInfo) {}
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
 
@@ -1103,9 +1096,9 @@
     }
 
     CircleOutside2PtConicalEffect(const CreateArgs& args, const CircleConicalInfo& info)
-            : INHERITED(args, false /* opaque: draws transparent black outside of the cone. */)
+            : INHERITED(kCircleOutside2PtConicalEffect_ClassID, args,
+                        false /* opaque: draws transparent black outside of the cone. */)
             , fInfo(info) {
-        this->initClassID<CircleOutside2PtConicalEffect>();
         const SkTwoPointConicalGradient& shader =
             *static_cast<const SkTwoPointConicalGradient*>(args.fShader);
         if (shader.getStartRadius() != shader.getEndRadius()) {
@@ -1121,9 +1114,7 @@
             : INHERITED(that)
             , fInfo(that.fInfo)
             , fTLimit(that.fTLimit)
-            , fIsFlipped(that.fIsFlipped) {
-        this->initClassID<CircleOutside2PtConicalEffect>();
-    }
+            , fIsFlipped(that.fIsFlipped) {}
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST
 
diff --git a/src/sksl/SkSLCPPCodeGenerator.cpp b/src/sksl/SkSLCPPCodeGenerator.cpp
index b2227c2..3066130 100644
--- a/src/sksl/SkSLCPPCodeGenerator.cpp
+++ b/src/sksl/SkSLCPPCodeGenerator.cpp
@@ -523,8 +523,8 @@
                              "@clone");
         }
         this->writef("%s::%s(const %s& src)\n"
-                     ": INHERITED(src.optimizationFlags())", fFullName.c_str(), fFullName.c_str(),
-                     fFullName.c_str());
+                     ": INHERITED(k%s_ClassID, src.optimizationFlags())", fFullName.c_str(),
+                     fFullName.c_str(), fFullName.c_str(), fFullName.c_str());
         for (const auto& param : fSectionAndParameterHelper.getParameters()) {
             String fieldName = HCodeGenerator::FieldName(String(param->fName).c_str());
             this->writef("\n, %s(%s)",
@@ -536,9 +536,7 @@
             this->writef("\n, %sCoordTransform(src.%sCoordTransform)", fieldName.c_str(),
                          fieldName.c_str());
         }
-        this->writef(" {\n"
-                     "    this->initClassID<%s>();\n",
-                     fFullName.c_str());
+        this->writef(" {\n");
         for (const auto& param : fSectionAndParameterHelper.getParameters()) {
             if (param->fType.kind() == Type::kSampler_Kind) {
                 this->writef("    this->addTextureSampler(&%s);\n",
diff --git a/src/sksl/SkSLHCodeGenerator.cpp b/src/sksl/SkSLHCodeGenerator.cpp
index b06cd0b..eb82631 100644
--- a/src/sksl/SkSLHCodeGenerator.cpp
+++ b/src/sksl/SkSLHCodeGenerator.cpp
@@ -172,9 +172,9 @@
     }
     this->writeSection(CONSTRUCTOR_PARAMS_SECTION, separator);
     this->writef(")\n"
-                 "    : INHERITED(");
-    if (!this->writeSection(OPTIMIZATION_FLAGS_SECTION, "(OptimizationFlags) ")) {
-        this->writef("kNone_OptimizationFlags");
+                 "    : INHERITED(k%s_ClassID", fFullName.c_str());
+    if (!this->writeSection(OPTIMIZATION_FLAGS_SECTION, ", (OptimizationFlags) ")) {
+        this->writef(", kNone_OptimizationFlags");
     }
     this->writef(")");
     this->writeSection(INITIALIZERS_SECTION, "\n    , ");
@@ -211,9 +211,7 @@
         String field = FieldName(s->fArgument.c_str());
         this->writef("        this->addCoordTransform(&%sCoordTransform);\n", field.c_str());
     }
-    this->writef("        this->initClassID<%s>();\n"
-                 "    }\n",
-                 fFullName.c_str());
+    this->writef("    }\n");
 }
 
 void HCodeGenerator::writeFields() {