Adding more validation

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 33 matching lines @@
     return noiseValue;
 }
 
 inline SkScalar smoothCurve(SkScalar t) {
     static const SkScalar SK_Scalar3 = SkFloatToScalar(3.0f);
 
     // returns t * t * (3 - 2 * t)
     return SkScalarMul(SkScalarSquare(t), SK_Scalar3 - 2 * t);
 }
 
+bool perlin_noise_type_is_valid(SkPerlinNoiseShader::Type type) {
+    switch (type) {

[Stephen White, 2013/11/25 16:11:21]

Nit: this could be:

return type == SkPerlinNoiseShader::kFractalNoise_Type 
    || type == SkPerlinNoiseShader::kTurbulence_Type;

[sugoi, 2013/11/25 16:20:33]

Done.

+    case SkPerlinNoiseShader::kFractalNoise_Type:
+    case SkPerlinNoiseShader::kTurbulence_Type:
+        return true;
+    default:
+        break;
+    }
+    return false;
+}
+
 } // end namespace
 
 struct SkPerlinNoiseShader::StitchData {
     StitchData()
       : fWidth(0)
       , fWrapX(0)
       , fHeight(0)
       , fWrapY(0)
     {}
 
@@ skipping 208 matching lines @@
 
 SkPerlinNoiseShader::SkPerlinNoiseShader(SkPerlinNoiseShader::Type type,
                                          SkScalar baseFrequencyX,
                                          SkScalar baseFrequencyY,
                                          int numOctaves,
                                          SkScalar seed,
                                          const SkISize* tileSize)
   : fType(type)
   , fBaseFrequencyX(baseFrequencyX)
   , fBaseFrequencyY(baseFrequencyY)
-  , fNumOctaves(numOctaves & 0xFF /*[0,255] octaves allowed*/)
+  , fNumOctaves(numOctaves > 255 ? 255 : numOctaves/*[0,255] octaves allowed*/)
   , fSeed(seed)
   , fStitchTiles((tileSize != NULL) && !tileSize->isEmpty())
   , fPaintingData(NULL)
 {
     SkASSERT(numOctaves >= 0 && numOctaves < 256);
     setTileSize(fStitchTiles ? *tileSize : SkISize::Make(0,0));
     fMatrix.reset();
 }
 
 SkPerlinNoiseShader::SkPerlinNoiseShader(SkFlattenableReadBuffer& buffer) :
         INHERITED(buffer), fPaintingData(NULL) {
     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();
+    buffer.validate(perlin_noise_type_is_valid(fType) &&
+                    (fNumOctaves >= 0) && (fNumOctaves <= 255));
 }
 
 SkPerlinNoiseShader::~SkPerlinNoiseShader() {
     // Safety, should have been done in endContext()
     SkDELETE(fPaintingData);
 }
 
 void SkPerlinNoiseShader::flatten(SkFlattenableWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeInt((int) fType);
@@ skipping 1064 matching lines @@
     str->append(" seed: ");
     str->appendScalar(fSeed);
     str->append(" stitch tiles: ");
     str->append(fStitchTiles ? "true " : "false ");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif