more threading of GrShaderDataManager

src/effects/SkAlphaThresholdFilter.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAlphaThresholdFilter.h"
 #include "SkBitmap.h"
 #include "SkReadBuffer.h"
@@ skipping 44 matching lines @@
 #include "effects/GrPorterDuffXferProcessor.h"
 
 #include "SkGr.h"
 
 #include "gl/GrGLProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 class AlphaThresholdEffect : public GrFragmentProcessor {
 
 public:
-    static GrFragmentProcessor* Create(GrTexture* texture,
+    static GrFragmentProcessor* Create(GrShaderDataManager* shaderDataManager,
+                                       GrTexture* texture,
                                        GrTexture* maskTexture,
                                        float innerThreshold,
                                        float outerThreshold) {
-        return SkNEW_ARGS(AlphaThresholdEffect, (texture,
+        return SkNEW_ARGS(AlphaThresholdEffect, (shaderDataManager,
+                                                 texture,
                                                  maskTexture,
                                                  innerThreshold,
                                                  outerThreshold));
     }
 
     virtual ~AlphaThresholdEffect() {};
 
     const char* name() const override { return "Alpha Threshold"; }
 
     float innerThreshold() const { return fInnerThreshold; }
     float outerThreshold() const { return fOuterThreshold; }
 
     void getGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
 
     GrGLFragmentProcessor* createGLInstance() const override;
 
 private:
-    AlphaThresholdEffect(GrTexture* texture,
+    AlphaThresholdEffect(GrShaderDataManager*,
+                         GrTexture* texture,
                          GrTexture* maskTexture,
                          float innerThreshold,
                          float outerThreshold)
         : fInnerThreshold(innerThreshold)
         , fOuterThreshold(outerThreshold)
         , fImageCoordTransform(kLocal_GrCoordSet,
                                GrCoordTransform::MakeDivByTextureWHMatrix(texture), texture,
                                GrTextureParams::kNone_FilterMode)
         , fImageTextureAccess(texture)
         , fMaskCoordTransform(kLocal_GrCoordSet,
@@ skipping 107 matching lines @@
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(AlphaThresholdEffect);
 
 GrFragmentProcessor* AlphaThresholdEffect::TestCreate(SkRandom* random,
                                            GrContext* context,
                                            const GrCaps&,
                                            GrTexture** textures) {
     GrTexture* bmpTex = textures[GrProcessorUnitTest::kSkiaPMTextureIdx];
     GrTexture* maskTex = textures[GrProcessorUnitTest::kAlphaTextureIdx];
     float inner_thresh = random->nextUScalar1();
     float outer_thresh = random->nextUScalar1();
-    return AlphaThresholdEffect::Create(bmpTex, maskTex, inner_thresh, outer_thresh);
+    GrShaderDataManager shaderDataManager;
+    return AlphaThresholdEffect::Create(&shaderDataManager, bmpTex, maskTex, inner_thresh,
+                                        outer_thresh);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void AlphaThresholdEffect::getGLProcessorKey(const GrGLSLCaps& caps,
                                              GrProcessorKeyBuilder* b) const {
     GrGLAlphaThresholdEffect::GenKey(*this, caps, b);
 }
 
 GrGLFragmentProcessor* AlphaThresholdEffect::createGLInstance() const {
@@ skipping 32 matching lines @@
                                                        SkScalar outerThreshold,
                                                        SkImageFilter* input)
     : INHERITED(1, &input)
     , fRegion(region)
     , fInnerThreshold(innerThreshold)
     , fOuterThreshold(outerThreshold) {
 }
 
 #if SK_SUPPORT_GPU
 bool SkAlphaThresholdFilterImpl::asFragmentProcessor(GrFragmentProcessor** fp,
-                                                     GrShaderDataManager*,
+                                                     GrShaderDataManager* shaderDataManager,
                                                      GrTexture* texture,
                                                      const SkMatrix& in_matrix,
                                                      const SkIRect&) const {
     if (fp) {
         GrContext* context = texture->getContext();
         GrSurfaceDesc maskDesc;
         if (context->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
             maskDesc.fConfig = kAlpha_8_GrPixelConfig;
         } else {
             maskDesc.fConfig = kRGBA_8888_GrPixelConfig;
@@ skipping 17 matching lines @@
             drawContext->clear(maskTexture->asRenderTarget(), NULL, 0x0, true);
 
             while (!iter.done()) {
                 SkRect rect = SkRect::Make(iter.rect());
                 drawContext->drawRect(maskTexture->asRenderTarget(), GrClip::WideOpen(), grPaint,
                                       in_matrix, rect);
                 iter.next();
             }
         }
 
-        *fp = AlphaThresholdEffect::Create(texture,
+        *fp = AlphaThresholdEffect::Create(shaderDataManager,
+                                           texture,
                                            maskTexture,
                                            fInnerThreshold,
                                            fOuterThreshold);
     }
     return true;
 }
 #endif
 
 void SkAlphaThresholdFilterImpl::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
@@ skipping 65 matching lines @@
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkAlphaThresholdFilterImpl::toString(SkString* str) const {
     str->appendf("SkAlphaThresholdImageFilter: (");
     str->appendf("inner: %f outer: %f", fInnerThreshold, fOuterThreshold);
     str->append(")");
 }
 #endif