Bye bye processor data manager

src/effects/SkMagnifierImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkMagnifierImageFilter.h"
 #include "SkColorPriv.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkValidationUtils.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 #if SK_SUPPORT_GPU
 #include "GrInvariantOutput.h"
 #include "effects/GrSingleTextureEffect.h"
 #include "gl/GrGLFragmentProcessor.h"
 #include "gl/GrGLTexture.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 class GrMagnifierEffect : public GrSingleTextureEffect {
 
 public:
-    static GrFragmentProcessor* Create(GrProcessorDataManager* procDataManager,
-                                       GrTexture* texture,
+    static GrFragmentProcessor* Create(GrTexture* texture,
                                        const SkRect& bounds,
                                        float xOffset,
                                        float yOffset,
                                        float xInvZoom,
                                        float yInvZoom,
                                        float xInvInset,
                                        float yInvInset) {
-        return new GrMagnifierEffect(procDataManager, texture, bounds, xOffset, yOffset, xInvZoom,
-                                     yInvZoom, xInvInset, yInvInset);
+        return new GrMagnifierEffect(texture, bounds, xOffset, yOffset, xInvZoom, yInvZoom, xInvInset,
+                                     yInvInset);
     }
 
     virtual ~GrMagnifierEffect() {};
 
     const char* name() const override { return "Magnifier"; }
 
     const SkRect& bounds() const { return fBounds; }    // Bounds of source image.
     // Offset to apply to zoomed pixels, (srcRect position / texture size).
     float x_offset() const { return fXOffset; }
     float y_offset() const { return fYOffset; }
 
     // Scale to apply to zoomed pixels (srcRect size / bounds size).
     float x_inv_zoom() const { return fXInvZoom; }
     float y_inv_zoom() const { return fYInvZoom; }
 
     // 1/radius over which to transition from unzoomed to zoomed pixels (bounds size / inset).
     float x_inv_inset() const { return fXInvInset; }
     float y_inv_inset() const { return fYInvInset; }
 
 private:
-    GrMagnifierEffect(GrProcessorDataManager* procDataManager,
-                      GrTexture* texture,
+    GrMagnifierEffect(GrTexture* texture,
                       const SkRect& bounds,
                       float xOffset,
                       float yOffset,
                       float xInvZoom,
                       float yInvZoom,
                       float xInvInset,
                       float yInvInset)
-        : INHERITED(procDataManager, texture, GrCoordTransform::MakeDivByTextureWHMatrix(texture))
+        : INHERITED(texture, GrCoordTransform::MakeDivByTextureWHMatrix(texture))
         , fBounds(bounds)
         , fXOffset(xOffset)
         , fYOffset(yOffset)
         , fXInvZoom(xInvZoom)
         , fYInvZoom(yInvZoom)
         , fXInvInset(xInvInset)
         , fYInvInset(yInvInset) {
         this->initClassID<GrMagnifierEffect>();
     }
 
@@ skipping 123 matching lines @@
     const int kMaxWidth = 200;
     const int kMaxHeight = 200;
     const int kMaxInset = 20;
     uint32_t width = d->fRandom->nextULessThan(kMaxWidth);
     uint32_t height = d->fRandom->nextULessThan(kMaxHeight);
     uint32_t x = d->fRandom->nextULessThan(kMaxWidth - width);
     uint32_t y = d->fRandom->nextULessThan(kMaxHeight - height);
     uint32_t inset = d->fRandom->nextULessThan(kMaxInset);
 
     GrFragmentProcessor* effect = GrMagnifierEffect::Create(
-        d->fProcDataManager,
         texture,
         SkRect::MakeWH(SkIntToScalar(kMaxWidth), SkIntToScalar(kMaxHeight)),
         (float) width / texture->width(),
         (float) height / texture->height(),
         texture->width() / (float) x,
         texture->height() / (float) y,
         (float) inset / texture->width(),
         (float) inset / texture->height());
     SkASSERT(effect);
     return effect;
@@ skipping 35 matching lines @@
 
 
 SkMagnifierImageFilter::SkMagnifierImageFilter(const SkRect& srcRect, SkScalar inset,
                                                SkImageFilter* input)
     : INHERITED(1, &input), fSrcRect(srcRect), fInset(inset) {
     SkASSERT(srcRect.x() >= 0 && srcRect.y() >= 0 && inset >= 0);
 }
 
 #if SK_SUPPORT_GPU
 bool SkMagnifierImageFilter::asFragmentProcessor(GrFragmentProcessor** fp,
-                                                 GrProcessorDataManager* procDataManager,
                                                  GrTexture* texture, const SkMatrix&,
                                                  const SkIRect&bounds) const {
     if (fp) {
         SkScalar yOffset = texture->origin() == kTopLeft_GrSurfaceOrigin ? fSrcRect.y() :
            texture->height() - fSrcRect.height() * texture->height() / bounds.height()
                              - fSrcRect.y();
         int boundsY = (texture->origin() == kTopLeft_GrSurfaceOrigin) ? bounds.y() :
                       (texture->height() - bounds.height());
         SkRect effectBounds = SkRect::MakeXYWH(
             SkIntToScalar(bounds.x()) / texture->width(),
             SkIntToScalar(boundsY) / texture->height(),
             SkIntToScalar(texture->width()) / bounds.width(),
             SkIntToScalar(texture->height()) / bounds.height());
         SkScalar invInset = fInset > 0 ? SkScalarInvert(fInset) : SK_Scalar1;
-        *fp = GrMagnifierEffect::Create(procDataManager,
-                                        texture,
+        *fp = GrMagnifierEffect::Create(texture,
                                         effectBounds,
                                         fSrcRect.x() / texture->width(),
                                         yOffset / texture->height(),
                                         fSrcRect.width() / bounds.width(),
                                         fSrcRect.height() / bounds.height(),
                                         bounds.width() * invInset,
                                         bounds.height() * invInset);
     }
     return true;
 }
@@ skipping 80 matching lines @@
 
 #ifndef SK_IGNORE_TO_STRING
 void SkMagnifierImageFilter::toString(SkString* str) const {
     str->appendf("SkMagnifierImageFilter: (");
     str->appendf("src: (%f,%f,%f,%f) ",
                  fSrcRect.fLeft, fSrcRect.fTop, fSrcRect.fRight, fSrcRect.fBottom);
     str->appendf("inset: %f", fInset);
     str->append(")");
 }
 #endif