***Disables swizzles to 565.

We may want to enable swizzles to 565
for images that are encoded in a format
similar to 565, however, we do not want
to take images that decode naturally to
kN32 and then convert them to 565.

***Enable swizzles to kIndex_8.  For images
encoded in a color table format, we suggest
that they be decoded to kIndex_8.  When we
decode, we only allow conversion to kIndex_8
if it matches the suggested color type (except
wbmp which seems good as is).

***Modify dm to test images that decode to
kIndex_8.

BUG=skia:3257
BUG=skia:3440

Review URL: https://codereview.chromium.org/1055743003

1 files changed, 112 insertions, 0 deletions

diff --git a/tests/SwizzlerTest.cpp b/tests/SwizzlerTest.cpp
new file mode 100644
index 0000000000..1355f3be8c
--- /dev/null
+++ b/tests/SwizzlerTest.cpp
@@ -0,0 +1,112 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkSwizzler.h"
+#include "Test.h"
+
+// These are the values that we will look for to indicate that the fill was successful
+static const uint8_t kFillIndex = 0x1;
+static const uint32_t kFillColor = 0x22334455;
+
+static void check_fill(skiatest::Reporter* r,
+                       const SkImageInfo& imageInfo,
+                       uint32_t startRow,
+                       size_t rowBytes,
+                       uint32_t offset,
+                       uint32_t colorOrIndex,
+                       SkPMColor* colorTable) {
+
+    // Calculate the total size of the image in bytes.  Use the smallest possible size.
+    // The offset value tells us to adjust the pointer from the memory we allocate in order
+    // to test on different memory alignments.  If offset is nonzero, we need to increase the
+    // size of the memory we allocate in order to make sure that we have enough.  We are
+    // still allocating the smallest possible size.
+    const size_t totalBytes = imageInfo.getSafeSize(rowBytes) + offset;
+
+    // Create fake image data where every byte has a value of 0
+    SkAutoTDelete<uint8_t> storage((uint8_t*) sk_malloc_throw(totalBytes));
+    memset(storage.get(), 0, totalBytes);
+    // Adjust the pointer in order to test on different memory alignments
+    uint8_t* imageData = storage.get() + offset;
+
+    // Fill image with the fill value starting at the indicated row
+    SkSwizzler::Fill(imageData, imageInfo, rowBytes, startRow, colorOrIndex, colorTable);
+
+    // Ensure that the pixels are filled properly
+    // The bots should catch any memory corruption
+    uint8_t* indexPtr = imageData + startRow * rowBytes;
+    uint32_t* colorPtr = (uint32_t*) indexPtr;
+    for (int32_t y = startRow; y < imageInfo.height(); y++) {
+        for (int32_t x = 0; x < imageInfo.width(); x++) {
+            if (kIndex_8_SkColorType == imageInfo.colorType()) {
+                REPORTER_ASSERT(r, kFillIndex == indexPtr[x]);
+            } else {
+                REPORTER_ASSERT(r, kFillColor == colorPtr[x]);
+            }
+        }
+        indexPtr += rowBytes;
+        colorPtr = (uint32_t*) indexPtr;
+    }
+}
+
+// Test Fill() with different combinations of dimensions, alignment, and padding
+DEF_TEST(SwizzlerFill, r) {
+    // Set up a color table
+    SkPMColor colorTable[kFillIndex + 1];
+    colorTable[kFillIndex] = kFillColor;
+    // Apart from the fill index, we will leave the other colors in the color table uninitialized.
+    // If we incorrectly try to fill with this uninitialized memory, the bots will catch it.
+
+    // Test on an invalid width and representative widths
+    const uint32_t widths[] = { 0, 10, 50 };
+
+    // In order to call Fill(), there must be at least one row to fill
+    // Test on the smallest possible height and representative heights
+    const uint32_t heights[] = { 1, 5, 10 };
+
+    // Test on interesting possibilities for row padding
+    const uint32_t paddings[] = { 0, 1, 2, 3, 4 };
+
+    // Iterate over test dimensions
+    for (uint32_t width : widths) {
+        for (uint32_t height : heights) {
+
+            // Create image info objects
+            const SkImageInfo colorInfo = SkImageInfo::MakeN32(width, height,
+                kUnknown_SkAlphaType);
+            const SkImageInfo indexInfo = colorInfo.makeColorType(kIndex_8_SkColorType);
+
+            for (uint32_t padding : paddings) {
+
+                // Calculate row bytes
+                size_t colorRowBytes = SkColorTypeBytesPerPixel(kN32_SkColorType) * width +
+                        padding;
+                size_t indexRowBytes = width + padding;
+
+                // If there is padding, we can invent an offset to change the memory alignment
+                for (uint32_t offset = 0; offset <= padding; offset++) {
+
+                    // Test all possible start rows
+                    for (uint32_t startRow = 0; startRow < height; startRow++) {
+
+                        // Fill with an index that we use to look up a color
+                        check_fill(r, colorInfo, startRow, colorRowBytes, offset, kFillIndex,
+                               colorTable);
+
+                        // Fill with a color
+                        check_fill(r, colorInfo, startRow, colorRowBytes, offset, kFillColor,
+                                NULL);
+
+                        // Fill with an index
+                        check_fill(r, indexInfo, startRow, indexRowBytes, offset, kFillIndex,
+                                NULL);
+                    }
+                }
+            }
+        }
+    }
+}