move checkLE functionality directly onto readbuffer

Bug: skia:
Change-Id: I549717f04e2e4cafc41ccbe13009805f47943d5d
Reviewed-on: https://skia-review.googlesource.com/99703
Reviewed-by: Mike Klein <mtklein@chromium.org>
Commit-Queue: Mike Reed <reed@google.com>

12 files changed, 27 insertions, 99 deletions

diff --git a/src/core/SkBlurImageFilter.cpp b/src/core/SkBlurImageFilter.cpp
index 556508ee27..286bc2214a 100644
--- a/src/core/SkBlurImageFilter.cpp
+++ b/src/core/SkBlurImageFilter.cpp
@@ -15,7 +15,6 @@
 #include "SkColorData.h"
 #include "SkColorSpaceXformer.h"
 #include "SkImageFilterPriv.h"
-#include "SkSafeRange.h"
 #include "SkTFitsIn.h"
 #include "SkGpuBlurUtils.h"
 #include "SkNx.h"
@@ -107,8 +106,6 @@ SkBlurImageFilterImpl::SkBlurImageFilterImpl(SkScalar sigmaX,
         : INHERITED(&input, 1, cropRect), fSigma{sigmaX, sigmaY}, fTileMode(tileMode) {}
 
 sk_sp<SkFlattenable> SkBlurImageFilterImpl::CreateProc(SkReadBuffer& buffer) {
-    SkSafeRange safe;
-
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkScalar sigmaX = buffer.readScalar();
     SkScalar sigmaY = buffer.readScalar();
@@ -116,16 +113,11 @@ sk_sp<SkFlattenable> SkBlurImageFilterImpl::CreateProc(SkReadBuffer& buffer) {
     if (buffer.isVersionLT(SkReadBuffer::kTileModeInBlurImageFilter_Version)) {
         tileMode = SkBlurImageFilter::kClampToBlack_TileMode;
     } else {
-        tileMode = safe.checkLE<SkBlurImageFilter::TileMode>(buffer.readInt(),
-                                                             SkBlurImageFilter::kLast_TileMode);
+        tileMode = buffer.read32LE(SkBlurImageFilter::kLast_TileMode);
     }
 
     static_assert(SkBlurImageFilter::kLast_TileMode == 2, "CreateProc");
 
-    if (!buffer.validate(safe)) {
-        return nullptr;
-    }
-
     return SkBlurImageFilter::Make(
           sigmaX, sigmaY, common.getInput(0), &common.cropRect(), tileMode);
 }
diff --git a/src/core/SkMaskFilter.cpp b/src/core/SkMaskFilter.cpp
index ae7d2e291a..59baa4fbff 100644
--- a/src/core/SkMaskFilter.cpp
+++ b/src/core/SkMaskFilter.cpp
@@ -16,7 +16,6 @@
 #include "SkRRect.h"
 #include "SkRasterClip.h"
 #include "SkReadBuffer.h"
-#include "SkSafeRange.h"
 #include "SkWriteBuffer.h"
 
 #if SK_SUPPORT_GPU
@@ -587,11 +586,10 @@ void SkCombineMF::flatten(SkWriteBuffer & buffer) const {
 }
 
 sk_sp<SkFlattenable> SkCombineMF::CreateProc(SkReadBuffer& buffer) {
-    SkSafeRange safe;
     auto dst = buffer.readMaskFilter();
     auto src = buffer.readMaskFilter();
-    SkCoverageMode mode = safe.checkLE(buffer.read32(), SkCoverageMode::kLast);
-    if (!buffer.validate(dst && src && safe)) {
+    SkCoverageMode mode = buffer.read32LE(SkCoverageMode::kLast);
+    if (!buffer.validate(dst && src)) {
         return nullptr;
     }
     return SkMaskFilter::MakeCombine(std::move(dst), std::move(src), mode);
diff --git a/src/core/SkMatrixImageFilter.cpp b/src/core/SkMatrixImageFilter.cpp
index 1a5ca7ccf9..023bd85a5b 100644
--- a/src/core/SkMatrixImageFilter.cpp
+++ b/src/core/SkMatrixImageFilter.cpp
@@ -11,7 +11,6 @@
 #include "SkColorSpaceXformer.h"
 #include "SkImageFilterPriv.h"
 #include "SkReadBuffer.h"
-#include "SkSafeRange.h"
 #include "SkSpecialImage.h"
 #include "SkSpecialSurface.h"
 #include "SkWriteBuffer.h"
@@ -34,20 +33,11 @@ sk_sp<SkImageFilter> SkMatrixImageFilter::Make(const SkMatrix& transform,
 }
 
 sk_sp<SkFlattenable> SkMatrixImageFilter::CreateProc(SkReadBuffer& buffer) {
-    SkSafeRange safe;
-
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkMatrix matrix;
     buffer.readMatrix(&matrix);
 
-    SkFilterQuality quality = safe.checkLE<SkFilterQuality>(buffer.readInt(),
-                                                            kLast_SkFilterQuality);
-
-    if (!buffer.validate(safe)) {
-        return nullptr;
-    }
-
-    return Make(matrix, quality, common.getInput(0));
+    return Make(matrix, buffer.read32LE(kLast_SkFilterQuality), common.getInput(0));
 }
 
 void SkMatrixImageFilter::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/core/SkPicturePlayback.cpp b/src/core/SkPicturePlayback.cpp
index 6155392e44..69542bbd4a 100644
--- a/src/core/SkPicturePlayback.cpp
+++ b/src/core/SkPicturePlayback.cpp
@@ -16,7 +16,6 @@
 #include "SkReadBuffer.h"
 #include "SkRSXform.h"
 #include "SkSafeMath.h"
-#include "SkSafeRange.h"
 #include "SkTextBlob.h"
 #include "SkTDArray.h"
 #include "SkTypes.h"
@@ -671,12 +670,9 @@ void SkPicturePlayback::handleOp(SkReadBuffer* reader,
             }
         } break;
         case DRAW_VERTICES_OBJECT: {
-            SkSafeRange safe;
             const SkPaint* paint = fPictureData->getPaint(reader);
             const SkVertices* vertices = fPictureData->getVertices(reader);
-            SkBlendMode bmode = safe.checkLE<SkBlendMode>(reader->readInt(),
-                                                          SkBlendMode::kLastMode);
-            reader->validate(safe);
+            SkBlendMode bmode = reader->read32LE(SkBlendMode::kLastMode);
             BREAK_ON_READ_ERROR(reader);
 
             if (paint && vertices) {
diff --git a/src/core/SkReadBuffer.h b/src/core/SkReadBuffer.h
index 4e0453a7aa..c3d6d4eb30 100644
--- a/src/core/SkReadBuffer.h
+++ b/src/core/SkReadBuffer.h
@@ -116,6 +116,14 @@ public:
     uint32_t readUInt();
     int32_t read32();
 
+    template <typename T> T read32LE(T max) {
+        uint32_t value = this->readUInt();
+        if (!this->validate(value <= static_cast<uint32_t>(max))) {
+            value = 0;
+        }
+        return static_cast<T>(value);
+    }
+
     // peek
     uint8_t peekByte();
 
diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index 866e724190..7992d97d78 100644
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -10,7 +10,6 @@
 #include "SkGpuBlurUtils.h"
 #include "SkMaskFilterBase.h"
 #include "SkReadBuffer.h"
-#include "SkSafeRange.h"
 #include "SkWriteBuffer.h"
 #include "SkMaskFilter.h"
 #include "SkRRect.h"
@@ -734,20 +733,13 @@ void SkBlurMaskFilterImpl::computeFastBounds(const SkRect& src,
 }
 
 sk_sp<SkFlattenable> SkBlurMaskFilterImpl::CreateProc(SkReadBuffer& buffer) {
-    SkSafeRange safe;
-
     const SkScalar sigma = buffer.readScalar();
-
-    SkBlurStyle style = safe.checkLE(buffer.readUInt(), kLastEnum_SkBlurStyle);
-    unsigned flags = safe.checkLE(buffer.readUInt(), SkBlurMaskFilter::kAll_BlurFlag);
+    SkBlurStyle style = buffer.read32LE(kLastEnum_SkBlurStyle);
+    unsigned flags = buffer.read32LE(SkBlurMaskFilter::kAll_BlurFlag);
 
     SkRect occluder;
     buffer.readRect(&occluder);
 
-    if (!buffer.validate(safe)) {
-        return nullptr;
-    }
-
     return SkBlurMaskFilter::Make((SkBlurStyle)style, sigma, occluder, flags);
 }
 
diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp
index 3fabb4d689..1b055b69a3 100644
--- a/src/effects/SkDisplacementMapEffect.cpp
+++ b/src/effects/SkDisplacementMapEffect.cpp
@@ -11,7 +11,6 @@
 #include "SkColorSpaceXformer.h"
 #include "SkImageFilterPriv.h"
 #include "SkReadBuffer.h"
-#include "SkSafeRange.h"
 #include "SkSpecialImage.h"
 #include "SkWriteBuffer.h"
 #include "SkUnPreMultiply.h"
@@ -147,24 +146,13 @@ SkDisplacementMapEffect::~SkDisplacementMapEffect() {
 }
 
 sk_sp<SkFlattenable> SkDisplacementMapEffect::CreateProc(SkReadBuffer& buffer) {
-    SkSafeRange safe;
-
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
 
-    ChannelSelectorType xsel = safe.checkLE<ChannelSelectorType>(buffer.readInt(),
-                                                                 kLast_ChannelSelectorType);
-    ChannelSelectorType ysel = safe.checkLE<ChannelSelectorType>(buffer.readInt(),
-                                                                 kLast_ChannelSelectorType);
-
+    ChannelSelectorType xsel = buffer.read32LE(kLast_ChannelSelectorType);
+    ChannelSelectorType ysel = buffer.read32LE(kLast_ChannelSelectorType);
     SkScalar scale = buffer.readScalar();
 
-    if (!buffer.validate(safe)) {
-        return nullptr;
-    }
-
-    return Make(xsel, ysel, scale,
-                common.getInput(0), common.getInput(1),
-                &common.cropRect());
+    return Make(xsel, ysel, scale, common.getInput(0), common.getInput(1), &common.cropRect());
 }
 
 void SkDisplacementMapEffect::flatten(SkWriteBuffer& buffer) const {
diff --git a/src/effects/SkDropShadowImageFilter.cpp b/src/effects/SkDropShadowImageFilter.cpp
index bd0fb75353..01c99efc9f 100644
--- a/src/effects/SkDropShadowImageFilter.cpp
+++ b/src/effects/SkDropShadowImageFilter.cpp
@@ -12,7 +12,6 @@
 #include "SkColorSpaceXformer.h"
 #include "SkImageFilterPriv.h"
 #include "SkReadBuffer.h"
-#include "SkSafeRange.h"
 #include "SkSpecialImage.h"
 #include "SkSpecialSurface.h"
 #include "SkWriteBuffer.h"
@@ -42,8 +41,6 @@ SkDropShadowImageFilter::SkDropShadowImageFilter(SkScalar dx, SkScalar dy,
 }
 
 sk_sp<SkFlattenable> SkDropShadowImageFilter::CreateProc(SkReadBuffer& buffer) {
-    SkSafeRange safe;
-
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkScalar dx = buffer.readScalar();
     SkScalar dy = buffer.readScalar();
@@ -51,11 +48,7 @@ sk_sp<SkFlattenable> SkDropShadowImageFilter::CreateProc(SkReadBuffer& buffer) {
     SkScalar sigmaY = buffer.readScalar();
     SkColor color = buffer.readColor();
 
-    ShadowMode shadowMode = safe.checkLE<ShadowMode>(buffer.readInt(), kLast_ShadowMode);
-
-    if (!buffer.validate(safe)) {
-        return nullptr;
-    }
+    ShadowMode shadowMode = buffer.read32LE(kLast_ShadowMode);
 
     return Make(dx, dy, sigmaX, sigmaY, color, shadowMode, common.getInput(0), &common.cropRect());
 }
diff --git a/src/effects/SkHighContrastFilter.cpp b/src/effects/SkHighContrastFilter.cpp
index 69cbcd7a9c..d6299f90c4 100644
--- a/src/effects/SkHighContrastFilter.cpp
+++ b/src/effects/SkHighContrastFilter.cpp
@@ -9,7 +9,6 @@
 #include "SkPM4f.h"
 #include "SkArenaAlloc.h"
 #include "SkRasterPipeline.h"
-#include "SkSafeRange.h"
 #include "SkReadBuffer.h"
 #include "SkString.h"
 #include "SkWriteBuffer.h"
@@ -142,24 +141,19 @@ void SkHighContrast_Filter::flatten(SkWriteBuffer& buffer) const {
 }
 
 sk_sp<SkFlattenable> SkHighContrast_Filter::CreateProc(SkReadBuffer& buffer) {
-    SkSafeRange safe;
-
     SkHighContrastConfig config;
     config.fGrayscale = buffer.readBool();
-    config.fInvertStyle = safe.checkLE<InvertStyle>(buffer.readInt(), InvertStyle::kLast);
+    config.fInvertStyle = buffer.read32LE(InvertStyle::kLast);
     config.fContrast = buffer.readScalar();
 
-    if (!buffer.validate(safe)) {
-        return nullptr;
-    }
-
     return SkHighContrastFilter::Make(config);
 }
 
 sk_sp<SkColorFilter> SkHighContrastFilter::Make(
     const SkHighContrastConfig& config) {
-    if (!config.isValid())
+    if (!config.isValid()) {
         return nullptr;
+    }
     return sk_make_sp<SkHighContrast_Filter>(config);
 }
 
diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index f861a5b9ac..98b0a13245 100644
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -12,7 +12,6 @@
 #include "SkImageFilterPriv.h"
 #include "SkPoint3.h"
 #include "SkReadBuffer.h"
-#include "SkSafeRange.h"
 #include "SkSpecialImage.h"
 #include "SkTypes.h"
 #include "SkWriteBuffer.h"
@@ -1128,15 +1127,7 @@ void SkImageFilterLight::flattenLight(SkWriteBuffer& buffer) const {
 }
 
 /*static*/ SkImageFilterLight* SkImageFilterLight::UnflattenLight(SkReadBuffer& buffer) {
-    // Read type first.
-    SkSafeRange safe;
-
-    SkImageFilterLight::LightType type = safe.checkLE<SkImageFilterLight::LightType>(
-                                            buffer.readInt(), SkImageFilterLight::kLast_LightType);
-
-    if (!buffer.validate(safe)) {
-        return nullptr;
-    }
+    SkImageFilterLight::LightType type = buffer.read32LE(SkImageFilterLight::kLast_LightType);
 
     switch (type) {
         // Each of these constructors must first call SkLight's, so we'll read the baseclass
diff --git a/src/effects/SkMatrixConvolutionImageFilter.cpp b/src/effects/SkMatrixConvolutionImageFilter.cpp
index 12ecfd87c2..1e58786b4d 100644
--- a/src/effects/SkMatrixConvolutionImageFilter.cpp
+++ b/src/effects/SkMatrixConvolutionImageFilter.cpp
@@ -11,7 +11,6 @@
 #include "SkColorSpaceXformer.h"
 #include "SkImageFilterPriv.h"
 #include "SkReadBuffer.h"
-#include "SkSafeRange.h"
 #include "SkSpecialImage.h"
 #include "SkWriteBuffer.h"
 #include "SkRect.h"
@@ -80,8 +79,6 @@ sk_sp<SkImageFilter> SkMatrixConvolutionImageFilter::Make(const SkISize& kernelS
 }
 
 sk_sp<SkFlattenable> SkMatrixConvolutionImageFilter::CreateProc(SkReadBuffer& buffer) {
-    SkSafeRange safe;
-
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
 
     SkISize kernelSize;
@@ -103,13 +100,9 @@ sk_sp<SkFlattenable> SkMatrixConvolutionImageFilter::CreateProc(SkReadBuffer& bu
     kernelOffset.fX = buffer.readInt();
     kernelOffset.fY = buffer.readInt();
 
-    TileMode tileMode = safe.checkLE<TileMode>(buffer.readInt(), kLast_TileMode);
+    TileMode tileMode = buffer.read32LE(kLast_TileMode);
     bool convolveAlpha = buffer.readBool();
 
-    if (!buffer.validate(safe)) {
-        return nullptr;
-    }
-
     return Make(kernelSize, kernel.get(), gain, bias, kernelOffset, tileMode,
                 convolveAlpha, common.getInput(0), &common.cropRect());
 }
diff --git a/src/shaders/SkPerlinNoiseShader.cpp b/src/shaders/SkPerlinNoiseShader.cpp
index 0a15f1ce44..48c9c30447 100644
--- a/src/shaders/SkPerlinNoiseShader.cpp
+++ b/src/shaders/SkPerlinNoiseShader.cpp
@@ -12,7 +12,6 @@
 #include "SkColorFilter.h"
 #include "SkMakeUnique.h"
 #include "SkReadBuffer.h"
-#include "SkSafeRange.h"
 #include "SkWriteBuffer.h"
 #include "SkShader.h"
 #include "SkUnPreMultiply.h"
@@ -416,24 +415,18 @@ SkPerlinNoiseShaderImpl::SkPerlinNoiseShaderImpl(SkPerlinNoiseShaderImpl::Type t
 }
 
 sk_sp<SkFlattenable> SkPerlinNoiseShaderImpl::CreateProc(SkReadBuffer& buffer) {
-    SkSafeRange safe;
-
-    Type type = safe.checkLE<Type>(buffer.readInt(), kLast_Type);
+    Type type = buffer.read32LE(kLast_Type);
 
     SkScalar freqX = buffer.readScalar();
     SkScalar freqY = buffer.readScalar();
 
-    int octaves = safe.checkLE<int>(buffer.readInt(), kMaxOctaves);
+    int octaves = buffer.read32LE<int>(kMaxOctaves);
 
     SkScalar seed = buffer.readScalar();
     SkISize tileSize;
     tileSize.fWidth = buffer.readInt();
     tileSize.fHeight = buffer.readInt();
 
-    if (!buffer.validate(safe)) {
-        return nullptr;
-    }
-
     switch (type) {
         case kFractalNoise_Type:
             return SkPerlinNoiseShader::MakeFractalNoise(freqX, freqY, octaves, seed, &tileSize);
@@ -442,7 +435,7 @@ sk_sp<SkFlattenable> SkPerlinNoiseShaderImpl::CreateProc(SkReadBuffer& buffer) {
         case kImprovedNoise_Type:
             return SkPerlinNoiseShader::MakeImprovedNoise(freqX, freqY, octaves, seed);
         default:
-            // Really shouldn't get here b.c. of earlier checkLE on type
+            // Really shouldn't get here b.c. of earlier check on type
             buffer.validate(false);
             return nullptr;
     }