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"
@@ skipping 63 matching lines @@
                fWrapY == other.fWrapY;
     }
 
     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)
+    PaintingData(const SkISize& tileSize, SkScalar seed,

[Stephen White, 2014/02/18 14:58:56]

Not new to this patch, but I think the PaintingData approach is something we
inherited from the WebKit implementation. Now that it is created at shader
construction time from SkPerlinNoiseShader's member variables, could we simply
remove it and access the member variables directly?

[scroggo, 2014/02/18 16:42:57]

I believe so.

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

Done. This is a much more pervasive change, and reitveld did not handle the
diffs as well as I would have hoped, but I believe I haven't changed any
behavior meaningfully.

+                 SkScalar baseFrequencyX, SkScalar baseFrequencyY)
+      : fTileSize(tileSize)
+      , fBaseFrequency(SkPoint::Make(baseFrequencyX, baseFrequencyY))
       , fPermutationsBitmap(NULL)
       , fNoiseBitmap(NULL)
-    {}
+    {
+        this->init(seed);
+        if (!fTileSize.isEmpty()) {
+            this->stitch();
+        }
+    }
 
     ~PaintingData()
     {
         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;
     }
 
+    // Only called once. Could be part of the constructor.
     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;
         }
@@ skipping 57 matching lines @@
             }
         }
 
         // Invalidate bitmaps
         SkDELETE(fPermutationsBitmap);
         fPermutationsBitmap = NULL;
         SkDELETE(fNoiseBitmap);
         fNoiseBitmap = NULL;
     }
 
+    // Only called once. Could be part of the constructor.
     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 =
@@ skipping 20 matching lines @@
         }
         // 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;
     }
 
+public:
+
     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);
         }
         return fPermutationsBitmap;
     }
@@ skipping 28 matching lines @@
                                          SkScalar baseFrequencyX,
                                          SkScalar baseFrequencyY,
                                          int numOctaves,
                                          SkScalar seed,
                                          const SkISize* tileSize)
   : fType(type)
   , fBaseFrequencyX(baseFrequencyX)
   , fBaseFrequencyY(baseFrequencyY)
   , fNumOctaves(numOctaves > 255 ? 255 : numOctaves/*[0,255] octaves allowed*/)
   , fSeed(seed)
-  , fStitchTiles((tileSize != NULL) && !tileSize->isEmpty())
-  , fPaintingData(NULL)
+  , 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();
+    fPaintingData = SkNEW_ARGS(PaintingData, (fTileSize, fSeed, fBaseFrequencyX, fBaseFrequencyY));
 }
 
-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();
     fNumOctaves     = buffer.readInt();
     fSeed           = buffer.readScalar();
     fStitchTiles    = buffer.readBool();
     fTileSize.fWidth  = buffer.readInt();
     fTileSize.fHeight = buffer.readInt();
-    setTileSize(fTileSize);
     fMatrix.reset();
+    fPaintingData = SkNEW_ARGS(PaintingData, (fTileSize, fSeed, fBaseFrequencyX, fBaseFrequencyY));
     buffer.validate(perlin_noise_type_is_valid(fType) &&
-                    (fNumOctaves >= 0) && (fNumOctaves <= 255));
+                    (fNumOctaves >= 0) && (fNumOctaves <= 255) &&
+                    (fStitchTiles != fTileSize.isEmpty()));
 }
 
 SkPerlinNoiseShader::~SkPerlinNoiseShader() {
     // Safety, should have been done in endContext()
     SkDELETE(fPaintingData);
 }
 
 void SkPerlinNoiseShader::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeInt((int) fType);
     buffer.writeScalar(fBaseFrequencyX);
     buffer.writeScalar(fBaseFrequencyY);
     buffer.writeInt(fNumOctaves);
     buffer.writeScalar(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)
 {
     struct Noise {
         int noisePositionIntegerValue;
         SkScalar noisePositionFractionValue;
         Noise(SkScalar component)
         {
             SkScalar position = component + kPerlinNoise;
             noisePositionIntegerValue = SkScalarFloorToInt(position);
@@ skipping 1015 matching lines @@
     str->append(" seed: ");
     str->appendScalar(fSeed);
     str->append(" stitch tiles: ");
     str->append(fStitchTiles ? "true " : "false ");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif