Fix ImageFilter fuzzer issue

src/core/SkReadBuffer.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkReadBuffer_DEFINED
 #define SkReadBuffer_DEFINED
 
@@ skipping 83 matching lines @@
     bool isScalarFloat() const { return SkToBool(fFlags & kScalarIsFloat_Flag); }
     bool isPtr64Bit() const { return SkToBool(fFlags & kPtrIs64Bit_Flag); }
     bool isValidating() const { return SkToBool(fFlags & kValidation_Flag); }
 
     SkReader32* getReader32() { return &fReader; }
 
     size_t size() { return fReader.size(); }
     size_t offset() { return fReader.offset(); }
     bool eof() { return fReader.eof(); }
     virtual const void* skip(size_t size) { return fReader.skip(size); }
+
+    void setOffset(size_t offset) { fReader.setOffset(offset); }

[reed1, 2016/04/20 13:26:37]

who needs this, why?

[robertphillips, 2016/04/20 17:09:40]

SkPicturePlayback::handleOp uses it as an optimization to skip to the restore
operation if everything is clipped out (for clipRect, clipPath, clipRRect and
clipRegion).

I have added a validating override.

+
     void* readFunctionPtr() { return fReader.readPtr(); }
 
     // primitives
     virtual bool readBool();
     virtual SkColor readColor();
     virtual int32_t readInt();
     virtual SkScalar readScalar();
     virtual uint32_t readUInt();
     virtual int32_t read32();
 
     // strings -- the caller is responsible for freeing the string contents
     virtual void readString(SkString* string);
     virtual void* readEncodedString(size_t* length, SkPaint::TextEncoding encoding);
 
     // common data structures
     virtual void readPoint(SkPoint* point);
     SkPoint readPoint() { SkPoint p; this->readPoint(&p); return p; }
     virtual void readMatrix(SkMatrix* matrix);
     virtual void readIRect(SkIRect* rect);
     virtual void readRect(SkRect* rect);
+    virtual void readRRect(SkRRect* rrect);
     virtual void readRegion(SkRegion* region);
 
     virtual void readPath(SkPath* path);
     void readPaint(SkPaint* paint) { paint->unflatten(*this); }
 
     virtual SkFlattenable* readFlattenable(SkFlattenable::Type);
     template <typename T> sk_sp<T> readFlattenable() {
         return sk_sp<T>((T*)this->readFlattenable(T::GetFlattenableType()));
     }
     sk_sp<SkColorFilter> readColorFilter() { return this->readFlattenable<SkColorFilter>(); }
@@ skipping 62 matching lines @@
     /**
      *  Provide a function to decode an SkBitmap from encoded data. Only used if the writer
      *  encoded the SkBitmap. If the proper decoder cannot be used, a red bitmap with the
      *  appropriate size will be used.
      */
     void setBitmapDecoder(SkPicture::InstallPixelRefProc bitmapDecoder) {
         fBitmapDecoder = bitmapDecoder;
     }
 
     // Default impelementations don't check anything.
-    virtual bool validate(bool isValid) { return true; }
+    virtual bool validate(bool isValid) { return isValid; }
     virtual bool isValid() const { return true; }
     virtual bool validateAvailable(size_t size) { return true; }
+    bool validateIndex(int index, int count) {
+        return this->validate(index >= 0 && index < count);
+    }
 
 protected:
     SkReader32 fReader;
 
 private:
     bool readArray(void* value, size_t size, size_t elementSize);
 
     uint32_t fFlags;
     int fVersion;
 
     void* fMemoryPtr;
 
     SkBitmapHeapReader* fBitmapStorage;
     SkTypeface** fTFArray;
     int        fTFCount;
 
     SkFlattenable::Factory* fFactoryArray;
     int                     fFactoryCount;
 
     SkPicture::InstallPixelRefProc fBitmapDecoder;
 
 #ifdef DEBUG_NON_DETERMINISTIC_ASSERT
     // Debugging counter to keep track of how many bitmaps we
     // have decoded.
     int fDecodedBitmapIndex;
 #endif // DEBUG_NON_DETERMINISTIC_ASSERT
 };
 
 #endif // SkReadBuffer_DEFINED