Begin making SkPerlinNoiseShader const.

src/effects/SkPerlinNoiseShader.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 "SkDither.h"
 #include "SkPerlinNoiseShader.h"
 #include "SkColorFilter.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkShader.h"
 #include "SkUnPreMultiply.h"
 #include "SkString.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrCoordTransform.h"
 #include "gl/GrGLEffect.h"
 #include "GrTBackendEffectFactory.h"
 #include "SkGr.h"
 #endif
 
-static const int kBlockSize = 256;
-static const int kBlockMask = kBlockSize - 1;
+const int SkPerlinNoiseShader::kBlockSize;
+const int SkPerlinNoiseShader::kBlockMask;
 static const int kPerlinNoise = 4096;
 static const int kRandMaximum = SK_MaxS32; // 2**31 - 1
 
 namespace {
 
 // noiseValue is the color component's value (or color)
 // limitValue is the maximum perlin noise array index value allowed
 // newValue is the current noise dimension (either width or height)
 inline int checkNoise(int noiseValue, int limitValue, int newValue) {
     // If the noise value would bring us out of bounds of the current noise array while we are
@@ skipping 15 matching lines @@
     return SkScalarMul(SkScalarSquare(t), SK_Scalar3 - 2 * t);
 }
 
 bool perlin_noise_type_is_valid(SkPerlinNoiseShader::Type type) {
     return (SkPerlinNoiseShader::kFractalNoise_Type == type) ||
            (SkPerlinNoiseShader::kTurbulence_Type == type);
 }
 
 } // end namespace
 
-struct SkPerlinNoiseShader::StitchData {
-    StitchData()
-      : fWidth(0)
-      , fWrapX(0)
-      , fHeight(0)
-      , fWrapY(0)
-    {}
+inline int random(int* seed)  {
+    static const int gRandAmplitude = 16807; // 7**5; primitive root of m
+    static const int gRandQ = 127773; // m / a
+    static const int gRandR = 2836; // m % a
 
-    bool operator==(const StitchData& other) const {
-        return fWidth == other.fWidth &&
-               fWrapX == other.fWrapX &&
-               fHeight == other.fHeight &&
-               fWrapY == other.fWrapY;
+    int result = gRandAmplitude * (*seed % gRandQ) - gRandR * (*seed / gRandQ);
+    if (result <= 0) {
+        result += kRandMaximum;
+    }
+    *seed = result;
+    return result;
+}
+
+// Only called once. Could be part of the constructor.
+void SkPerlinNoiseShader::init()
+{
+    static const SkScalar gInvBlockSizef = SkScalarInvert(SkIntToScalar(kBlockSize));
+
+    // The seed value clamp to the range [1, kRandMaximum - 1].
+    if (fSeed <= 0) {
+        fSeed = -(fSeed % (kRandMaximum - 1)) + 1;
+    }
+    if (fSeed > kRandMaximum - 1) {
+        fSeed = kRandMaximum - 1;
+    }
+    for (int channel = 0; channel < 4; ++channel) {
+        for (int i = 0; i < kBlockSize; ++i) {
+            fLatticeSelector[i] = i;
+            fNoise[channel][i][0] = (random(&fSeed) % (2 * kBlockSize));
+            fNoise[channel][i][1] = (random(&fSeed) % (2 * kBlockSize));
+        }
+    }
+    for (int i = kBlockSize - 1; i > 0; --i) {
+        int k = fLatticeSelector[i];
+        int j = random(&fSeed) % kBlockSize;
+        SkASSERT(j >= 0);
+        SkASSERT(j < kBlockSize);
+        fLatticeSelector[i] = fLatticeSelector[j];
+        fLatticeSelector[j] = k;
     }
 
-    int fWidth; // How much to subtract to wrap for stitching.
-    int fWrapX; // Minimum value to wrap.
-    int fHeight;
-    int fWrapY;
-};
-
-struct SkPerlinNoiseShader::PaintingData {
-    PaintingData(const SkISize& tileSize)
-      : fSeed(0)
-      , fTileSize(tileSize)
-      , fPermutationsBitmap(NULL)
-      , fNoiseBitmap(NULL)
-    {}
-
-    ~PaintingData()
+    // Perform the permutations now
     {
-        SkDELETE(fPermutationsBitmap);
-        SkDELETE(fNoiseBitmap);
-    }
-
-    int         fSeed;
-    uint8_t     fLatticeSelector[kBlockSize];
-    uint16_t    fNoise[4][kBlockSize][2];
-    SkPoint     fGradient[4][kBlockSize];
-    SkISize     fTileSize;
-    SkVector    fBaseFrequency;
-    StitchData  fStitchDataInit;
-
-private:
-
-    SkBitmap*    fPermutationsBitmap;
-    SkBitmap*    fNoiseBitmap;
-
-public:
-
-    inline int random()  {
-        static const int gRandAmplitude = 16807; // 7**5; primitive root of m
-        static const int gRandQ = 127773; // m / a
-        static const int gRandR = 2836; // m % a
-
-        int result = gRandAmplitude * (fSeed % gRandQ) - gRandR * (fSeed / gRandQ);
-        if (result <= 0)
-            result += kRandMaximum;
-        fSeed = result;
-        return result;
-    }
-
-    void init(SkScalar seed)
-    {
-        static const SkScalar gInvBlockSizef = SkScalarInvert(SkIntToScalar(kBlockSize));
-
-        // According to the SVG spec, we must truncate (not round) the seed value.
-        fSeed = SkScalarTruncToInt(seed);
-        // The seed value clamp to the range [1, kRandMaximum - 1].
-        if (fSeed <= 0) {
-            fSeed = -(fSeed % (kRandMaximum - 1)) + 1;
-        }
-        if (fSeed > kRandMaximum - 1) {
-            fSeed = kRandMaximum - 1;
-        }
-        for (int channel = 0; channel < 4; ++channel) {
-            for (int i = 0; i < kBlockSize; ++i) {
-                fLatticeSelector[i] = i;
-                fNoise[channel][i][0] = (random() % (2 * kBlockSize));
-                fNoise[channel][i][1] = (random() % (2 * kBlockSize));
-            }
-        }
-        for (int i = kBlockSize - 1; i > 0; --i) {
-            int k = fLatticeSelector[i];
-            int j = random() % kBlockSize;
-            SkASSERT(j >= 0);
-            SkASSERT(j < kBlockSize);
-            fLatticeSelector[i] = fLatticeSelector[j];
-            fLatticeSelector[j] = k;
-        }
-
-        // Perform the permutations now
-        {
-            // Copy noise data
-            uint16_t noise[4][kBlockSize][2];
-            for (int i = 0; i < kBlockSize; ++i) {
-                for (int channel = 0; channel < 4; ++channel) {
-                    for (int j = 0; j < 2; ++j) {
-                        noise[channel][i][j] = fNoise[channel][i][j];
-                    }
-                }
-            }
-            // Do permutations on noise data
-            for (int i = 0; i < kBlockSize; ++i) {
-                for (int channel = 0; channel < 4; ++channel) {
-                    for (int j = 0; j < 2; ++j) {
-                        fNoise[channel][i][j] = noise[channel][fLatticeSelector[i]][j];
-                    }
+        // Copy noise data
+        uint16_t noise[4][kBlockSize][2];
+        for (int i = 0; i < kBlockSize; ++i) {
+            for (int channel = 0; channel < 4; ++channel) {
+                for (int j = 0; j < 2; ++j) {
+                    noise[channel][i][j] = fNoise[channel][i][j];
                 }
             }
         }
+        // Do permutations on noise data
+        for (int i = 0; i < kBlockSize; ++i) {
+            for (int channel = 0; channel < 4; ++channel) {
+                for (int j = 0; j < 2; ++j) {
+                        fNoise[channel][i][j] = noise[channel][fLatticeSelector[i]][j];
+                }
+            }
+        }
+    }
 
-        // Half of the largest possible value for 16 bit unsigned int
-        static const SkScalar gHalfMax16bits = 32767.5f;
+    // Half of the largest possible value for 16 bit unsigned int
+    static const SkScalar gHalfMax16bits = 32767.5f;
 
-        // Compute gradients from permutated noise data
-        for (int channel = 0; channel < 4; ++channel) {
-            for (int i = 0; i < kBlockSize; ++i) {
-                fGradient[channel][i] = SkPoint::Make(
+    // Compute gradients from permutated noise data
+    for (int channel = 0; channel < 4; ++channel) {
+        for (int i = 0; i < kBlockSize; ++i) {
+            fGradient[channel][i] = SkPoint::Make(
                     SkScalarMul(SkIntToScalar(fNoise[channel][i][0] - kBlockSize),
                                 gInvBlockSizef),
                     SkScalarMul(SkIntToScalar(fNoise[channel][i][1] - kBlockSize),
                                 gInvBlockSizef));
-                fGradient[channel][i].normalize();
+            fGradient[channel][i].normalize();
                 // Put the normalized gradient back into the noise data
-                fNoise[channel][i][0] = SkScalarRoundToInt(SkScalarMul(
+            fNoise[channel][i][0] = SkScalarRoundToInt(SkScalarMul(
                     fGradient[channel][i].fX + SK_Scalar1, gHalfMax16bits));
-                fNoise[channel][i][1] = SkScalarRoundToInt(SkScalarMul(
+            fNoise[channel][i][1] = SkScalarRoundToInt(SkScalarMul(
                     fGradient[channel][i].fY + SK_Scalar1, gHalfMax16bits));
-            }
         }
-
-        // Invalidate bitmaps
-        SkDELETE(fPermutationsBitmap);
-        fPermutationsBitmap = NULL;
-        SkDELETE(fNoiseBitmap);
-        fNoiseBitmap = NULL;
     }
 
-    void stitch() {
-        SkScalar tileWidth  = SkIntToScalar(fTileSize.width());
-        SkScalar tileHeight = SkIntToScalar(fTileSize.height());
-        SkASSERT(tileWidth > 0 && tileHeight > 0);
-        // When stitching tiled turbulence, the frequencies must be adjusted
-        // so that the tile borders will be continuous.
-        if (fBaseFrequency.fX) {
-            SkScalar lowFrequencx =
-                SkScalarFloorToScalar(tileWidth * fBaseFrequency.fX) / tileWidth;
-            SkScalar highFrequencx =
-                SkScalarCeilToScalar(tileWidth * fBaseFrequency.fX) / tileWidth;
-            // BaseFrequency should be non-negative according to the standard.
-            if (SkScalarDiv(fBaseFrequency.fX, lowFrequencx) <
-                SkScalarDiv(highFrequencx, fBaseFrequency.fX)) {
-                fBaseFrequency.fX = lowFrequencx;
-            } else {
-                fBaseFrequency.fX = highFrequencx;
-            }
-        }
-        if (fBaseFrequency.fY) {
-            SkScalar lowFrequency =
-                SkScalarFloorToScalar(tileHeight * fBaseFrequency.fY) / tileHeight;
-            SkScalar highFrequency =
-                SkScalarCeilToScalar(tileHeight * fBaseFrequency.fY) / tileHeight;
-            if (SkScalarDiv(fBaseFrequency.fY, lowFrequency) <
-                SkScalarDiv(highFrequency, fBaseFrequency.fY)) {
-                fBaseFrequency.fY = lowFrequency;
-            } else {
-                fBaseFrequency.fY = highFrequency;
-            }
-        }
-        // Set up TurbulenceInitial stitch values.
-        fStitchDataInit.fWidth  =
-            SkScalarRoundToInt(tileWidth * fBaseFrequency.fX);
-        fStitchDataInit.fWrapX  = kPerlinNoise + fStitchDataInit.fWidth;
-        fStitchDataInit.fHeight =
-            SkScalarRoundToInt(tileHeight * fBaseFrequency.fY);
-        fStitchDataInit.fWrapY  = kPerlinNoise + fStitchDataInit.fHeight;
+    if (fTileSize.isEmpty()) {

[scroggo, 2014/03/04 22:26:34]

stitch() is now part of init.

+        return;
     }
 
-    SkBitmap* getPermutationsBitmap()
-    {
-        if (!fPermutationsBitmap) {
-            fPermutationsBitmap = SkNEW(SkBitmap);
-            fPermutationsBitmap->allocPixels(SkImageInfo::MakeA8(kBlockSize, 1));
-            uint8_t* bitmapPixels = fPermutationsBitmap->getAddr8(0, 0);
-            memcpy(bitmapPixels, fLatticeSelector, sizeof(uint8_t) * kBlockSize);
+    SkScalar tileWidth  = SkIntToScalar(fTileSize.width());
+    SkScalar tileHeight = SkIntToScalar(fTileSize.height());
+    SkASSERT(tileWidth > 0 && tileHeight > 0);
+    // When stitching tiled turbulence, the frequencies must be adjusted
+    // so that the tile borders will be continuous.
+    if (fBaseFrequency.fX) {
+        SkScalar lowFrequencx =
+                SkScalarFloorToScalar(tileWidth * fBaseFrequency.fX) / tileWidth;
+        SkScalar highFrequencx =
+                SkScalarCeilToScalar(tileWidth * fBaseFrequency.fX) / tileWidth;
+        // BaseFrequency should be non-negative according to the standard.
+        if (SkScalarDiv(fBaseFrequency.fX, lowFrequencx) <
+                SkScalarDiv(highFrequencx, fBaseFrequency.fX)) {
+            fBaseFrequency.fX = lowFrequencx;
+        } else {
+            fBaseFrequency.fX = highFrequencx;
         }
-        return fPermutationsBitmap;
     }
+    if (fBaseFrequency.fY) {
+        SkScalar lowFrequency =
+                SkScalarFloorToScalar(tileHeight * fBaseFrequency.fY) / tileHeight;
+        SkScalar highFrequency =
+                SkScalarCeilToScalar(tileHeight * fBaseFrequency.fY) / tileHeight;
+        if (SkScalarDiv(fBaseFrequency.fY, lowFrequency) <
+                SkScalarDiv(highFrequency, fBaseFrequency.fY)) {
+            fBaseFrequency.fY = lowFrequency;
+        } else {
+            fBaseFrequency.fY = highFrequency;
+        }
+    }
+    // Set up TurbulenceInitial stitch values.
+    fStitchDataInit.fWidth  =
+            SkScalarRoundToInt(tileWidth * fBaseFrequency.fX);
+    fStitchDataInit.fWrapX  = kPerlinNoise + fStitchDataInit.fWidth;
+    fStitchDataInit.fHeight =
+            SkScalarRoundToInt(tileHeight * fBaseFrequency.fY);
+    fStitchDataInit.fWrapY  = kPerlinNoise + fStitchDataInit.fHeight;
+}
 
-    SkBitmap* getNoiseBitmap()
-    {
-        if (!fNoiseBitmap) {
-            fNoiseBitmap = SkNEW(SkBitmap);
-            fNoiseBitmap->allocPixels(SkImageInfo::MakeN32Premul(kBlockSize, 4));
-            uint32_t* bitmapPixels = fNoiseBitmap->getAddr32(0, 0);
-            memcpy(bitmapPixels, fNoise[0][0], sizeof(uint16_t) * kBlockSize * 4 * 2);
-        }
-        return fNoiseBitmap;
+const SkBitmap& SkPerlinNoiseShader::getPermutationsBitmap() const {
+    if (kUnknown_SkColorType == fPermutationsBitmap.colorType()) {
+        // initialize the cache.
+        fPermutationsBitmap.allocPixels(SkImageInfo::MakeA8(kBlockSize, 1));
+        uint8_t* bitmapPixels = fPermutationsBitmap.getAddr8(0, 0);
+        memcpy(bitmapPixels, fLatticeSelector, sizeof(uint8_t) * kBlockSize);
     }
-};
+    return fPermutationsBitmap;
+}
+
+const SkBitmap& SkPerlinNoiseShader::getNoiseBitmap() const {
+    if (kUnknown_SkColorType == fNoiseBitmap.colorType()) {
+        // initialize the cache.
+        fNoiseBitmap.allocPixels(SkImageInfo::MakeN32Premul(kBlockSize, 4));
+        uint32_t* bitmapPixels = fNoiseBitmap.getAddr32(0, 0);
+        memcpy(bitmapPixels, fNoise[0][0], sizeof(uint16_t) * kBlockSize * 4 * 2);
+    }
+    return fNoiseBitmap;
+}
 
 SkShader* SkPerlinNoiseShader::CreateFractalNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
                                                   int numOctaves, SkScalar seed,
                                                   const SkISize* tileSize) {
     return SkNEW_ARGS(SkPerlinNoiseShader, (kFractalNoise_Type, baseFrequencyX, baseFrequencyY,
                                             numOctaves, seed, tileSize));
 }
 
 SkShader* SkPerlinNoiseShader::CreateTubulence(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
                                               int numOctaves, SkScalar seed,
                                               const SkISize* tileSize) {
     return SkNEW_ARGS(SkPerlinNoiseShader, (kTurbulence_Type, baseFrequencyX, baseFrequencyY,
                                             numOctaves, seed, tileSize));
 }
 
 SkPerlinNoiseShader::SkPerlinNoiseShader(SkPerlinNoiseShader::Type type,
                                          SkScalar baseFrequencyX,
                                          SkScalar baseFrequencyY,
                                          int numOctaves,
                                          SkScalar seed,
                                          const SkISize* tileSize)
   : fType(type)
-  , fBaseFrequencyX(baseFrequencyX)
-  , fBaseFrequencyY(baseFrequencyY)
+  , fBaseFrequency(SkPoint::Make(baseFrequencyX, baseFrequencyY))
   , fNumOctaves(numOctaves > 255 ? 255 : numOctaves/*[0,255] octaves allowed*/)
-  , fSeed(seed)
-  , fStitchTiles((tileSize != NULL) && !tileSize->isEmpty())
-  , fPaintingData(NULL)
+  // According to the SVG spec, we must truncate (not round) the seed value.
+  , fSeed(SkScalarTruncToInt(seed))
+  , fTileSize(NULL == tileSize ? SkISize::Make(0, 0) : *tileSize)
+  , fStitchTiles(!fTileSize.isEmpty())
 {
     SkASSERT(numOctaves >= 0 && numOctaves < 256);
-    setTileSize(fStitchTiles ? *tileSize : SkISize::Make(0,0));
     fMatrix.reset();
+    this->init();
 }
 
-SkPerlinNoiseShader::SkPerlinNoiseShader(SkReadBuffer& buffer) :
-        INHERITED(buffer), fPaintingData(NULL) {
+SkPerlinNoiseShader::SkPerlinNoiseShader(SkReadBuffer& buffer)
+    : INHERITED(buffer)
+{
     fType           = (SkPerlinNoiseShader::Type) buffer.readInt();
-    fBaseFrequencyX = buffer.readScalar();
-    fBaseFrequencyY = buffer.readScalar();
+    buffer.readPoint(&fBaseFrequency);
     fNumOctaves     = buffer.readInt();
-    fSeed           = buffer.readScalar();
+    fSeed           = buffer.readInt();

[Stephen White, 2014/03/05 14:32:58]

Hmmm. Isn't this going to require an SkPicture version bump?  In this new
backward-compatibility serialization world, I think we'll have to support the
old format too (check w/Brian).

I also find it strange that we have a value that's both serialized and mutable
(changed on every call to random()). This doesn't seem right to me, but perhaps
I'm misunderstanding.

Maybe Alexis can tell me that my suggestion of getting rid of PaintingData was a
bad one. :) Another option might be to backtrack a little, keep the mutable data
in PaintingData, and leave the original parameters in the shader (everything
that's const-able).

[sugoi, 2014/03/05 16:50:33]

Hmmm... In this const shader world, is there no way to cleanly compute and store
some values that will be needed later on during processing? As we discussed
earlier this week, currently, we could compute these values every time we render
since the shader is recreated every time we render it (although that may not be
the case forever).

For now, my opinion is that we should simplify this code as much as possible for
the current case and worry about other considerations when we get there. I don't
want to delay this effort while not being entirely sure of what will be needed
later on.

[scroggo, 2014/03/05 18:24:05]

What do you mean by "later on during processing?" In the const shader world, the
only way to store data for the future is in SkShader::setContext. setContext is
called once before each draw, and this is where data gets cached that will be
used for that draw. Currently, that data lives on the shader, but in the const
shader world, it will be eliminated after the draw
(https://codereview.chromium.org/160103002/ shows an early, rough look at what
that looks like).
I think I didn't quite follow this part of the discussion, which seemed to be
largely about Blink and image filters. Right now we do compute all the values at
shader creation time (with or without my changes - without my changes there were
private functions that theoretically could be called to recompute all the
values, but these functions were never called). If you create this shader at
render time (do you mean before each draw?), this CL should not impact that use.
If, on the other hand, you want to be able to reuse the same shader with
different inputs at different times, I'm not sure how to provide that
functionality without sacrificing immutable shaders (which we think would be
useful for faster record times and cheaper multithreaded drawing). I think
that's where Stephen's suggestion comes in, where some other class creates a new
shader each time we need new values. In that case, I still think this CL is the
right approach, and we can figure out how to make that work in a future CL.
That sounds good to me. Are there specific ways you think this code should be
simplified?

[scroggo, 2014/03/05 18:24:05]

Yes, this would require a picture version bump. In my mind, it makes more sense
to store an int than a scalar, since we always truncate it (it seems odd that
the input is a scalar - is this part of a webkit restriction?). On the other
hand, I think the cost of storing a scalar is low, so I'm fine with leaving it a
scalar and leaving the picture version unchanged.
No, you are correct. I overlooked that. I was thinking we never again need the
original value of SkPerlinNoiseShader::fSeed which is *almost* true. The one
time we do need it is for flattening (although truly we only need the truncated
version). 

random() is only called in init (which in turn is only called by the
constructor), and come to think of it, there's no good reason to modify the
original seed value. I've  updated the code to just modify a local variable.
Alexis, what do you think? Now that I've fixed fSeed, the only things that are
modified outside of init (and therefore should be mutable) will be the bitmaps.
I think removing the PaintingData is a bit simpler.

     fStitchTiles    = buffer.readBool();
     fTileSize.fWidth  = buffer.readInt();
     fTileSize.fHeight = buffer.readInt();
-    setTileSize(fTileSize);
     fMatrix.reset();
+    this->init();
     buffer.validate(perlin_noise_type_is_valid(fType) &&
-                    (fNumOctaves >= 0) && (fNumOctaves <= 255));
-}
-
-SkPerlinNoiseShader::~SkPerlinNoiseShader() {
-    // Safety, should have been done in endContext()
-    SkDELETE(fPaintingData);
+                    (fNumOctaves >= 0) && (fNumOctaves <= 255) &&
+                    (fStitchTiles != fTileSize.isEmpty()));
 }
 
 void SkPerlinNoiseShader::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeInt((int) fType);
-    buffer.writeScalar(fBaseFrequencyX);
-    buffer.writeScalar(fBaseFrequencyY);
+    buffer.writePoint(fBaseFrequency);
     buffer.writeInt(fNumOctaves);
-    buffer.writeScalar(fSeed);
+    buffer.writeInt(fSeed);
     buffer.writeBool(fStitchTiles);
     buffer.writeInt(fTileSize.fWidth);
     buffer.writeInt(fTileSize.fHeight);
 }
 
-void SkPerlinNoiseShader::initPaint(PaintingData& paintingData)
-{
-    paintingData.init(fSeed);
-
-    // Set frequencies to original values
-    paintingData.fBaseFrequency.set(fBaseFrequencyX, fBaseFrequencyY);
-    // Adjust frequecies based on size if stitching is enabled
-    if (fStitchTiles) {
-        paintingData.stitch();
-    }
-}
-
-void SkPerlinNoiseShader::setTileSize(const SkISize& tileSize) {
-    fTileSize = tileSize;
-
-    if (NULL == fPaintingData) {
-        fPaintingData = SkNEW_ARGS(PaintingData, (fTileSize));
-        initPaint(*fPaintingData);
-    } else {
-        // Set Size
-        fPaintingData->fTileSize = fTileSize;
-        // Set frequencies to original values
-        fPaintingData->fBaseFrequency.set(fBaseFrequencyX, fBaseFrequencyY);
-        // Adjust frequecies based on size if stitching is enabled
-        if (fStitchTiles) {
-            fPaintingData->stitch();
-        }
-    }
-}
-
-SkScalar SkPerlinNoiseShader::noise2D(int channel, const PaintingData& paintingData,
-                                     const StitchData& stitchData, const SkPoint& noiseVector)
-{
+SkScalar SkPerlinNoiseShader::noise2D(int channel, const StitchData& stitchData,
+                                      const SkPoint& noiseVector) const {
     struct Noise {
         int noisePositionIntegerValue;
         SkScalar noisePositionFractionValue;
         Noise(SkScalar component)
         {
             SkScalar position = component + kPerlinNoise;
             noisePositionIntegerValue = SkScalarFloorToInt(position);
             noisePositionFractionValue = position - SkIntToScalar(noisePositionIntegerValue);
         }
     };
     Noise noiseX(noiseVector.x());
     Noise noiseY(noiseVector.y());
     SkScalar u, v;
     // If stitching, adjust lattice points accordingly.
     if (fStitchTiles) {
         noiseX.noisePositionIntegerValue =
             checkNoise(noiseX.noisePositionIntegerValue, stitchData.fWrapX, stitchData.fWidth);
         noiseY.noisePositionIntegerValue =
             checkNoise(noiseY.noisePositionIntegerValue, stitchData.fWrapY, stitchData.fHeight);
     }
     noiseX.noisePositionIntegerValue &= kBlockMask;
     noiseY.noisePositionIntegerValue &= kBlockMask;
-    int latticeIndex =
-        paintingData.fLatticeSelector[noiseX.noisePositionIntegerValue] +
-        noiseY.noisePositionIntegerValue;
-    int nextLatticeIndex =
-        paintingData.fLatticeSelector[(noiseX.noisePositionIntegerValue + 1) & kBlockMask] +
-        noiseY.noisePositionIntegerValue;
+    int latticeIndex = fLatticeSelector[noiseX.noisePositionIntegerValue] +
+            noiseY.noisePositionIntegerValue;
+    int nextLatticeIndex = fLatticeSelector[(noiseX.noisePositionIntegerValue + 1) & kBlockMask] +
+            noiseY.noisePositionIntegerValue;
     SkScalar sx = smoothCurve(noiseX.noisePositionFractionValue);
     SkScalar sy = smoothCurve(noiseY.noisePositionFractionValue);
     // This is taken 1:1 from SVG spec: http://www.w3.org/TR/SVG11/filters.html#feTurbulenceElement
     SkPoint fractionValue = SkPoint::Make(noiseX.noisePositionFractionValue,
                                           noiseY.noisePositionFractionValue); // Offset (0,0)
-    u = paintingData.fGradient[channel][latticeIndex & kBlockMask].dot(fractionValue);
+    u = fGradient[channel][latticeIndex & kBlockMask].dot(fractionValue);
     fractionValue.fX -= SK_Scalar1; // Offset (-1,0)
-    v = paintingData.fGradient[channel][nextLatticeIndex & kBlockMask].dot(fractionValue);
+    v = fGradient[channel][nextLatticeIndex & kBlockMask].dot(fractionValue);
     SkScalar a = SkScalarInterp(u, v, sx);
     fractionValue.fY -= SK_Scalar1; // Offset (-1,-1)
-    v = paintingData.fGradient[channel][(nextLatticeIndex + 1) & kBlockMask].dot(fractionValue);
+    v = fGradient[channel][(nextLatticeIndex + 1) & kBlockMask].dot(fractionValue);
     fractionValue.fX = noiseX.noisePositionFractionValue; // Offset (0,-1)
-    u = paintingData.fGradient[channel][(latticeIndex + 1) & kBlockMask].dot(fractionValue);
+    u = fGradient[channel][(latticeIndex + 1) & kBlockMask].dot(fractionValue);
     SkScalar b = SkScalarInterp(u, v, sx);
     return SkScalarInterp(a, b, sy);
 }
 
-SkScalar SkPerlinNoiseShader::calculateTurbulenceValueForPoint(
-    int channel, const PaintingData& paintingData, StitchData& stitchData, const SkPoint& point)
-{
+SkScalar SkPerlinNoiseShader::calculateTurbulenceValueForPoint(int channel, StitchData& stitchData,
+                                                               const SkPoint& point) const {
     if (fStitchTiles) {
         // Set up TurbulenceInitial stitch values.
-        stitchData = paintingData.fStitchDataInit;
+        stitchData = fStitchDataInit;
     }
     SkScalar turbulenceFunctionResult = 0;
-    SkPoint noiseVector(SkPoint::Make(SkScalarMul(point.x(), paintingData.fBaseFrequency.fX),
-                                      SkScalarMul(point.y(), paintingData.fBaseFrequency.fY)));
+    SkPoint noiseVector(SkPoint::Make(SkScalarMul(point.x(), fBaseFrequency.fX),
+                                      SkScalarMul(point.y(), fBaseFrequency.fY)));
     SkScalar ratio = SK_Scalar1;
     for (int octave = 0; octave < fNumOctaves; ++octave) {
-        SkScalar noise = noise2D(channel, paintingData, stitchData, noiseVector);
+        SkScalar noise = noise2D(channel, stitchData, noiseVector);
         turbulenceFunctionResult += SkScalarDiv(
             (fType == kFractalNoise_Type) ? noise : SkScalarAbs(noise), ratio);
         noiseVector.fX *= 2;
         noiseVector.fY *= 2;
         ratio *= 2;
         if (fStitchTiles) {
             // Update stitch values
             stitchData.fWidth  *= 2;
             stitchData.fWrapX   = stitchData.fWidth + kPerlinNoise;
             stitchData.fHeight *= 2;
@@ skipping 10 matching lines @@
 
     if (channel == 3) { // Scale alpha by paint value
         turbulenceFunctionResult = SkScalarMul(turbulenceFunctionResult,
             SkScalarDiv(SkIntToScalar(getPaintAlpha()), SkIntToScalar(255)));
     }
 
     // Clamp result
     return SkScalarPin(turbulenceFunctionResult, 0, SK_Scalar1);
 }
 
-SkPMColor SkPerlinNoiseShader::shade(const SkPoint& point, StitchData& stitchData) {
+SkPMColor SkPerlinNoiseShader::shade(const SkPoint& point, StitchData& stitchData) const {
     SkMatrix matrix = fMatrix;
     matrix.postConcat(getLocalMatrix());
     SkMatrix invMatrix;
     if (!matrix.invert(&invMatrix)) {
         invMatrix.reset();
     } else {
         invMatrix.postConcat(invMatrix); // Square the matrix
     }
     // This (1,1) translation is due to WebKit's 1 based coordinates for the noise
     // (as opposed to 0 based, usually). The same adjustment is in the setData() function.
     matrix.postTranslate(SK_Scalar1, SK_Scalar1);
     SkPoint newPoint;
     matrix.mapPoints(&newPoint, &point, 1);
     invMatrix.mapPoints(&newPoint, &newPoint, 1);
     newPoint.fX = SkScalarRoundToScalar(newPoint.fX);
     newPoint.fY = SkScalarRoundToScalar(newPoint.fY);
 
     U8CPU rgba[4];
     for (int channel = 3; channel >= 0; --channel) {
         rgba[channel] = SkScalarFloorToInt(255 *
-            calculateTurbulenceValueForPoint(channel, *fPaintingData, stitchData, newPoint));
+            calculateTurbulenceValueForPoint(channel, stitchData, newPoint));
     }
     return SkPreMultiplyARGB(rgba[3], rgba[0], rgba[1], rgba[2]);
 }
 
 bool SkPerlinNoiseShader::setContext(const SkBitmap& device, const SkPaint& paint,
                                      const SkMatrix& matrix) {
     fMatrix = matrix;
     return INHERITED::setContext(device, paint, matrix);
 }
 
@@ skipping 831 matching lines @@
         return cf->asNewEffect(context);
     }
 
     // Either we don't stitch tiles, either we have a valid tile size
     SkASSERT(!fStitchTiles || !fTileSize.isEmpty());
 
 #ifdef SK_USE_SIMPLEX_NOISE
     // Simplex noise is currently disabled but can be enabled by defining SK_USE_SIMPLEX_NOISE
     sk_ignore_unused_variable(context);
     GrEffectRef* effect =
-        GrSimplexNoiseEffect::Create(fType, fPaintingData->fBaseFrequency,
+        GrSimplexNoiseEffect::Create(fType, fBaseFrequency,
                                      fNumOctaves, fStitchTiles, fSeed,
                                      this->getLocalMatrix(), paint.getAlpha());
 #else
     GrTexture* permutationsTexture = GrLockAndRefCachedBitmapTexture(
-        context, *fPaintingData->getPermutationsBitmap(), NULL);
+        context, this->getPermutationsBitmap(), NULL);
     GrTexture* noiseTexture = GrLockAndRefCachedBitmapTexture(
-        context, *fPaintingData->getNoiseBitmap(), NULL);
+        context, this->getNoiseBitmap(), NULL);
 
     GrEffectRef* effect = (NULL != permutationsTexture) && (NULL != noiseTexture) ?
-        GrPerlinNoiseEffect::Create(fType, fPaintingData->fBaseFrequency,
+        GrPerlinNoiseEffect::Create(fType, fBaseFrequency,
                                     fNumOctaves, fStitchTiles,
-                                    fPaintingData->fStitchDataInit,
+                                    fStitchDataInit,
                                     permutationsTexture, noiseTexture,
                                     this->getLocalMatrix(), paint.getAlpha()) :
         NULL;
 
     // Unlock immediately, this is not great, but we don't have a way of
     // knowing when else to unlock it currently. TODO: Remove this when
     // unref becomes the unlock replacement for all types of textures.
     if (NULL != permutationsTexture) {
         GrUnlockAndUnrefCachedBitmapTexture(permutationsTexture);
     }
@@ skipping 24 matching lines @@
             str->append("\"fractal noise\"");
             break;
         case kTurbulence_Type:
             str->append("\"turbulence\"");
             break;
         default:
             str->append("\"unknown\"");
             break;
     }
     str->append(" base frequency: (");
-    str->appendScalar(fBaseFrequencyX);
+    str->appendScalar(fBaseFrequency.fX);
     str->append(", ");
-    str->appendScalar(fBaseFrequencyY);
+    str->appendScalar(fBaseFrequency.fY);
     str->append(") number of octaves: ");
     str->appendS32(fNumOctaves);
     str->append(" seed: ");
-    str->appendScalar(fSeed);
+    str->appendS32(fSeed);
     str->append(" stitch tiles: ");
     str->append(fStitchTiles ? "true " : "false ");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif