Checking structure sizes before reading them from memory to avoid overflowing the buffer's stream.

tests/SerializationTest.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 "SkOrderedWriteBuffer.h"
 #include "SkValidatingReadBuffer.h"
 #include "Test.h"
 
 static void Tests(skiatest::Reporter* reporter) {
+    // Test matrix serialization

[reed1, 2013/11/04 14:26:54]

Looks like a lot of similar code. Can any of this be
consolidate/templated/shared?

[sugoi1, 2013/11/04 15:26:14]

Done.

+    {
+        SkMatrix matrix = SkMatrix::I();
+        SkOrderedWriteBuffer writer(1024);
+        writer.setFlags(SkOrderedWriteBuffer::kValidation_Flag);
+        writer.writeMatrix(matrix);
+        uint32_t bytesWritten = writer.bytesWritten();
+        // This should write the length (in 4 bytes) and the array
+        REPORTER_ASSERT(reporter, (9 * sizeof(SkScalar)) == bytesWritten);
+
+        unsigned char dataWritten[1024];
+        writer.writeToMemory(dataWritten);
+
+        // Make sure this fails when it should
+        SkValidatingReadBuffer buffer(dataWritten, bytesWritten - 1);
+        const unsigned char* peekBefore = static_cast<const unsigned char*>(buffer.skip(0));
+        buffer.readMatrix(&matrix);
+        const unsigned char* peekAfter = static_cast<const unsigned char*>(buffer.skip(0));
+        // This should have failed, since the buffer is too small to read a matrix from it
+        REPORTER_ASSERT(reporter, peekBefore == peekAfter);
+
+        // Make sure this succeeds when it should
+        SkValidatingReadBuffer buffer2(dataWritten, bytesWritten);
+        peekBefore = static_cast<const unsigned char*>(buffer2.skip(0));
+        buffer2.readMatrix(&matrix);
+        peekAfter = static_cast<const unsigned char*>(buffer2.skip(0));
+        // This should have succeeded, since there are enough bytes to read this
+        REPORTER_ASSERT(reporter, (peekAfter - peekBefore) == bytesWritten);
+
+        // Test memory read/write functions directly
+        size_t bytesWrittenToMemory = matrix.writeToMemory(dataWritten);
+        REPORTER_ASSERT(reporter, SkAlign4(bytesWrittenToMemory) == bytesWrittenToMemory);
+        size_t bytesReadFromMemory = matrix.readFromMemory(dataWritten, bytesWrittenToMemory);
+        REPORTER_ASSERT(reporter, SkAlign4(bytesReadFromMemory) == bytesReadFromMemory);
+     }
+
+    // Test path serialization
+    {
+        SkPath path;
+        SkOrderedWriteBuffer writer(1024);
+        writer.setFlags(SkOrderedWriteBuffer::kValidation_Flag);
+        writer.writePath(path);
+        uint32_t bytesWritten = writer.bytesWritten();
+
+        unsigned char dataWritten[1024];
+        writer.writeToMemory(dataWritten);
+
+        // Make sure this fails when it should
+        SkValidatingReadBuffer buffer(dataWritten, bytesWritten - 1);
+        const unsigned char* peekBefore = static_cast<const unsigned char*>(buffer.skip(0));
+        buffer.readPath(&path);
+        const unsigned char* peekAfter = static_cast<const unsigned char*>(buffer.skip(0));
+        // This should have failed, since the buffer is too small to read a matrix from it
+        REPORTER_ASSERT(reporter, peekBefore == peekAfter);
+
+        // Make sure this succeeds when it should
+        SkValidatingReadBuffer buffer2(dataWritten, bytesWritten);
+        peekBefore = static_cast<const unsigned char*>(buffer2.skip(0));
+        buffer2.readPath(&path);
+        peekAfter = static_cast<const unsigned char*>(buffer2.skip(0));
+        // This should have succeeded, since there are enough bytes to read this
+        REPORTER_ASSERT(reporter, (peekAfter - peekBefore) == bytesWritten);
+
+        // Test memory read/write functions directly
+        size_t bytesWrittenToMemory = path.writeToMemory(dataWritten);
+        REPORTER_ASSERT(reporter, SkAlign4(bytesWrittenToMemory) == bytesWrittenToMemory);
+        size_t bytesReadFromMemory = path.readFromMemory(dataWritten, bytesWrittenToMemory);
+        REPORTER_ASSERT(reporter, SkAlign4(bytesReadFromMemory) == bytesReadFromMemory);
+    }
+
+    // Test region serialization
+    {
+        SkRegion region;
+        SkOrderedWriteBuffer writer(1024);
+        writer.setFlags(SkOrderedWriteBuffer::kValidation_Flag);
+        writer.writeRegion(region);
+        uint32_t bytesWritten = writer.bytesWritten();
+
+        unsigned char dataWritten[1024];
+        writer.writeToMemory(dataWritten);
+
+        // Make sure this fails when it should
+        SkValidatingReadBuffer buffer(dataWritten, bytesWritten - 1);
+        const unsigned char* peekBefore = static_cast<const unsigned char*>(buffer.skip(0));
+        buffer.readRegion(&region);
+        const unsigned char* peekAfter = static_cast<const unsigned char*>(buffer.skip(0));
+        // This should have failed, since the buffer is too small to read a matrix from it
+        REPORTER_ASSERT(reporter, peekBefore == peekAfter);
+
+        // Make sure this succeeds when it should
+        SkValidatingReadBuffer buffer2(dataWritten, bytesWritten);
+        peekBefore = static_cast<const unsigned char*>(buffer2.skip(0));
+        buffer2.readRegion(&region);
+        peekAfter = static_cast<const unsigned char*>(buffer2.skip(0));
+        // This should have succeeded, since there are enough bytes to read this
+        REPORTER_ASSERT(reporter, (peekAfter - peekBefore) == bytesWritten);
+
+        // Test memory read/write functions directly
+        size_t bytesWrittenToMemory = region.writeToMemory(dataWritten);
+        REPORTER_ASSERT(reporter, SkAlign4(bytesWrittenToMemory) == bytesWrittenToMemory);
+        size_t bytesReadFromMemory = region.readFromMemory(dataWritten, bytesWrittenToMemory);
+        REPORTER_ASSERT(reporter, SkAlign4(bytesReadFromMemory) == bytesReadFromMemory);
+    }
+
+    // Test rrect serialization
+    {
+        SkRRect rrect;
+        unsigned char dataWritten[1024];
+
+        // Test memory read/write functions directly
+        size_t bytesWrittenToMemory = rrect.writeToMemory(dataWritten);
+        REPORTER_ASSERT(reporter, SkAlign4(bytesWrittenToMemory) == bytesWrittenToMemory);
+        size_t bytesReadFromMemory = rrect.readFromMemory(dataWritten, bytesWrittenToMemory);
+        REPORTER_ASSERT(reporter, SkAlign4(bytesReadFromMemory) == bytesReadFromMemory);
+    }
+
+    // Test readByteArray
     {
         static const uint32_t arraySize = 512;
         unsigned char data[arraySize] = {0};
         SkOrderedWriteBuffer writer(1024);
         writer.setFlags(SkOrderedWriteBuffer::kValidation_Flag);
         writer.writeByteArray(data, arraySize);
         uint32_t bytesWritten = writer.bytesWritten();
         // This should write the length (in 4 bytes) and the array
         REPORTER_ASSERT(reporter, (4 + arraySize) == bytesWritten);
 
         unsigned char dataWritten[1024];
         writer.writeToMemory(dataWritten);
 
         // Make sure this fails when it should
         SkValidatingReadBuffer buffer(dataWritten, bytesWritten);
         unsigned char dataRead[arraySize];
         bool success = buffer.readByteArray(dataRead, 256);
         // This should have failed, since 256 < sizeInBytes
         REPORTER_ASSERT(reporter, !success);
 
         // Make sure this succeeds when it should
         SkValidatingReadBuffer buffer2(dataWritten, bytesWritten);
         success = buffer2.readByteArray(dataRead, arraySize);
         // This should have succeeded, since there are enough bytes to read this
         REPORTER_ASSERT(reporter, success);
     }
 
+    // Test readColorArray
     {
         static const uint32_t arraySize = 64;
         SkColor data[arraySize];
         SkOrderedWriteBuffer writer(1024);
         writer.setFlags(SkOrderedWriteBuffer::kValidation_Flag);
         writer.writeColorArray(data, arraySize);
         uint32_t bytesWritten = writer.bytesWritten();
         // This should write the length (in 4 bytes) and the array
         REPORTER_ASSERT(reporter, (4 + arraySize * sizeof(SkColor)) == bytesWritten);
 
         unsigned char dataWritten[1024];
         writer.writeToMemory(dataWritten);
 
         // Make sure this fails when it should
         SkValidatingReadBuffer buffer(dataWritten, bytesWritten);
         SkColor dataRead[arraySize];
         bool success = buffer.readColorArray(dataRead, 32);
         // This should have failed, since 256 < sizeInBytes
         REPORTER_ASSERT(reporter, !success);
 
         // Make sure this succeeds when it should
         SkValidatingReadBuffer buffer2(dataWritten, bytesWritten);
         success = buffer2.readColorArray(dataRead, arraySize);
         // This should have succeeded, since there are enough bytes to read this
         REPORTER_ASSERT(reporter, success);
     }
 
+    // Test readIntArray
     {
         static const uint32_t arraySize = 64;
         int32_t data[arraySize];
         SkOrderedWriteBuffer writer(1024);
         writer.setFlags(SkOrderedWriteBuffer::kValidation_Flag);
         writer.writeIntArray(data, arraySize);
         uint32_t bytesWritten = writer.bytesWritten();
         // This should write the length (in 4 bytes) and the array
         REPORTER_ASSERT(reporter, (4 + arraySize * sizeof(int32_t)) == bytesWritten);
 
         unsigned char dataWritten[1024];
         writer.writeToMemory(dataWritten);
 
         // Make sure this fails when it should
         SkValidatingReadBuffer buffer(dataWritten, bytesWritten);
         int32_t dataRead[arraySize];
         bool success = buffer.readIntArray(dataRead, 32);
         // This should have failed, since 256 < sizeInBytes
         REPORTER_ASSERT(reporter, !success);
 
         // Make sure this succeeds when it should
         SkValidatingReadBuffer buffer2(dataWritten, bytesWritten);
         success = buffer2.readIntArray(dataRead, arraySize);
         // This should have succeeded, since there are enough bytes to read this
         REPORTER_ASSERT(reporter, success);
     }
 
+    // Test readPointArray
     {
         static const uint32_t arraySize = 64;
         SkPoint data[arraySize];
         SkOrderedWriteBuffer writer(1024);
         writer.setFlags(SkOrderedWriteBuffer::kValidation_Flag);
         writer.writePointArray(data, arraySize);
         uint32_t bytesWritten = writer.bytesWritten();
         // This should write the length (in 4 bytes) and the array
         REPORTER_ASSERT(reporter, (4 + arraySize * sizeof(SkPoint)) == bytesWritten);
 
         unsigned char dataWritten[1024];
         writer.writeToMemory(dataWritten);
 
         // Make sure this fails when it should
         SkValidatingReadBuffer buffer(dataWritten, bytesWritten);
         SkPoint dataRead[arraySize];
         bool success = buffer.readPointArray(dataRead, 32);
         // This should have failed, since 256 < sizeInBytes
         REPORTER_ASSERT(reporter, !success);
 
         // Make sure this succeeds when it should
         SkValidatingReadBuffer buffer2(dataWritten, bytesWritten);
         success = buffer2.readPointArray(dataRead, arraySize);
         // This should have succeeded, since there are enough bytes to read this
         REPORTER_ASSERT(reporter, success);
     }
 
+    // Test readScalarArray
     {
         static const uint32_t arraySize = 64;
         SkScalar data[arraySize];
         SkOrderedWriteBuffer writer(1024);
         writer.setFlags(SkOrderedWriteBuffer::kValidation_Flag);
         writer.writeScalarArray(data, arraySize);
         uint32_t bytesWritten = writer.bytesWritten();
         // This should write the length (in 4 bytes) and the array
         REPORTER_ASSERT(reporter, (4 + arraySize * sizeof(SkScalar)) == bytesWritten);
 
@@ skipping 10 matching lines @@
         // Make sure this succeeds when it should
         SkValidatingReadBuffer buffer2(dataWritten, bytesWritten);
         success = buffer2.readScalarArray(dataRead, arraySize);
         // This should have succeeded, since there are enough bytes to read this
         REPORTER_ASSERT(reporter, success);
     }
 }
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS("Serialization", SerializationClass, Tests)