Upstream version 7.36.149.0

[platform/framework/web/crosswalk.git] / src / third_party / skia / src / core / SkValidatingReadBuffer.cpp

diff --git a/src/third_party/skia/src/core/SkValidatingReadBuffer.cpp b/src/third_party/skia/src/core/SkValidatingReadBuffer.cpp
index 9f094f9..0112f18 100644 (file)
--- a/src/third_party/skia/src/core/SkValidatingReadBuffer.cpp
+++ b/src/third_party/skia/src/core/SkValidatingReadBuffer.cpp
@@ -14,18 +14,23 @@
 SkValidatingReadBuffer::SkValidatingReadBuffer(const void* data, size_t size) :
     fError(false) {
     this->setMemory(data, size);
-    this->setFlags(SkFlattenableReadBuffer::kValidation_Flag);
+    this->setFlags(SkReadBuffer::kValidation_Flag);
 }
 
 SkValidatingReadBuffer::~SkValidatingReadBuffer() {
 }
 
-void SkValidatingReadBuffer::validate(bool isValid) {
+bool SkValidatingReadBuffer::validate(bool isValid) {
     if (!fError && !isValid) {
         // When an error is found, send the read cursor to the end of the stream
         fReader.skip(fReader.available());
         fError = true;
     }
+    return !fError;
+}
+
+bool SkValidatingReadBuffer::isValid() const {
+    return !fError;
 }
 
 void SkValidatingReadBuffer::setMemory(const void* data, size_t size) {
@@ -86,21 +91,23 @@ int32_t SkValidatingReadBuffer::read32() {
 }
 
 void SkValidatingReadBuffer::readString(SkString* string) {
-    const size_t len = this->readInt();
+    const size_t len = this->readUInt();
     const void* ptr = fReader.peek();
     const char* cptr = (const char*)ptr;
 
     // skip over the string + '\0' and then pad to a multiple of 4
     const size_t alignedSize = SkAlign4(len + 1);
     this->skip(alignedSize);
-    this->validate(cptr[len] == '\0');
+    if (!fError) {
+        this->validate(cptr[len] == '\0');
+    }
     if (!fError) {
         string->set(cptr, len);
     }
 }
 
 void* SkValidatingReadBuffer::readEncodedString(size_t* length, SkPaint::TextEncoding encoding) {
-    const int32_t encodingType = fReader.readInt();
+    const int32_t encodingType = this->readInt();
     this->validate(encodingType == encoding);
     *length = this->readInt();
     const void* ptr = this->skip(SkAlign4(*length));
@@ -113,13 +120,16 @@ void* SkValidatingReadBuffer::readEncodedString(size_t* length, SkPaint::TextEnc
 }
 
 void SkValidatingReadBuffer::readPoint(SkPoint* point) {
-    point->fX = fReader.readScalar();
-    point->fY = fReader.readScalar();
+    point->fX = this->readScalar();
+    point->fY = this->readScalar();
 }
 
 void SkValidatingReadBuffer::readMatrix(SkMatrix* matrix) {
-    const size_t size = matrix->readFromMemory(fReader.peek());
-    this->validate(SkAlign4(size) == size);
+    size_t size = 0;
+    if (!fError) {
+        size = matrix->readFromMemory(fReader.peek(), fReader.available());
+        this->validate((SkAlign4(size) == size) && (0 != size));
+    }
     if (!fError) {
         (void)this->skip(size);
     }
@@ -140,16 +150,22 @@ void SkValidatingReadBuffer::readRect(SkRect* rect) {
 }
 
 void SkValidatingReadBuffer::readRegion(SkRegion* region) {
-    const size_t size = region->readFromMemory(fReader.peek());
-    this->validate(SkAlign4(size) == size);
+    size_t size = 0;
+    if (!fError) {
+        size = region->readFromMemory(fReader.peek(), fReader.available());
+        this->validate((SkAlign4(size) == size) && (0 != size));
+    }
     if (!fError) {
         (void)this->skip(size);
     }
 }
 
 void SkValidatingReadBuffer::readPath(SkPath* path) {
-    const size_t size = path->readFromMemory(fReader.peek());
-    this->validate(SkAlign4(size) == size);
+    size_t size = 0;
+    if (!fError) {
+        size = path->readFromMemory(fReader.peek(), fReader.available());
+        this->validate((SkAlign4(size) == size) && (0 != size));
+    }
     if (!fError) {
         (void)this->skip(size);
     }
@@ -189,16 +205,18 @@ bool SkValidatingReadBuffer::readScalarArray(SkScalar* values, size_t size) {
 }
 
 uint32_t SkValidatingReadBuffer::getArrayCount() {
-    return *(uint32_t*)fReader.peek();
+    const size_t inc = sizeof(uint32_t);
+    fError = fError || !IsPtrAlign4(fReader.peek()) || !fReader.isAvailable(inc);
+    return fError ? 0 : *(uint32_t*)fReader.peek();
 }
 
 void SkValidatingReadBuffer::readBitmap(SkBitmap* bitmap) {
     const int width = this->readInt();
     const int height = this->readInt();
+    const bool useBitmapHeap = this->readBool();
     const size_t length = this->readUInt();
     // A size of zero means the SkBitmap was simply flattened.
-    this->validate(length == 0);
-    if (fError) {
+    if (!this->validate(!useBitmapHeap && (0 == length))) {
         return;
     }
     bitmap->unflatten(*this);
@@ -210,6 +228,10 @@ SkTypeface* SkValidatingReadBuffer::readTypeface() {
     return NULL;
 }
 
+bool SkValidatingReadBuffer::validateAvailable(size_t size) {
+    return this->validate((size <= SK_MaxU32) && fReader.isAvailable(static_cast<uint32_t>(size)));
+}
+
 SkFlattenable* SkValidatingReadBuffer::readFlattenable(SkFlattenable::Type type) {
     SkString name;
     this->readString(&name);
@@ -234,10 +256,10 @@ SkFlattenable* SkValidatingReadBuffer::readFlattenable(SkFlattenable::Type type)
     SkFlattenable* obj = NULL;
     uint32_t sizeRecorded = this->readUInt();
     if (factory) {
-        uint32_t offset = fReader.offset();
+        size_t offset = fReader.offset();
         obj = (*factory)(*this);
         // check that we read the amount we expected
-        uint32_t sizeRead = fReader.offset() - offset;
+        size_t sizeRead = fReader.offset() - offset;
         this->validate(sizeRecorded == sizeRead);
         if (fError) {
             // we could try to fix up the offset...