Convert SkWriter32 to use an SkTDArray for its internal storage.

tests/Writer32Test.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Test.h"
 #include "TestClassDef.h"
 #include "SkRandom.h"
 #include "SkReader32.h"
 #include "SkWriter32.h"
 
 static void check_contents(skiatest::Reporter* reporter, const SkWriter32& writer,
                            const void* expected, size_t size) {
     SkAutoSMalloc<256> storage(size);
     REPORTER_ASSERT(reporter, writer.bytesWritten() == size);
     writer.flatten(storage.get());
     REPORTER_ASSERT(reporter, !memcmp(storage.get(), expected, size));
 }
 
 
 static void test_reserve(skiatest::Reporter* reporter) {
     // There used to be a bug where we'd assert your first reservation had to
     // fit in external storage if you used it.  This would crash in debug mode.
     uint8_t storage[4];
-    SkWriter32 writer(0, storage, sizeof(storage));
+    SkWriter32 writer(storage, sizeof(storage));
     writer.reserve(40);
 }
 
 static void test_string_null(skiatest::Reporter* reporter) {
     uint8_t storage[8];
-    SkWriter32 writer(0, storage, sizeof(storage));
+    SkWriter32 writer(storage, sizeof(storage));
 
     // Can we write NULL?
     writer.writeString(NULL);
     const int32_t expected[] = { 0x0, 0x0 };
     check_contents(reporter, writer, expected, sizeof(expected));
 }
 
 static void test_rewind(skiatest::Reporter* reporter) {
-    SkSWriter32<32> writer(32);
+    SkSWriter32<32> writer;
     int32_t array[3] = { 1, 2, 4 };
 
     REPORTER_ASSERT(reporter, 0 == writer.bytesWritten());
     for (size_t i = 0; i < SK_ARRAY_COUNT(array); ++i) {
         writer.writeInt(array[i]);
     }
     check_contents(reporter, writer, array, sizeof(array));
 
     writer.rewindToOffset(2*sizeof(int32_t));
     REPORTER_ASSERT(reporter, sizeof(array) - 4 == writer.bytesWritten());
     writer.writeInt(3);
     REPORTER_ASSERT(reporter, sizeof(array) == writer.bytesWritten());
     array[2] = 3;
     check_contents(reporter, writer, array, sizeof(array));
 
     // test rewinding past allocated chunks. This used to crash because we
     // didn't truncate our link-list after freeing trailing blocks
     {
-        SkWriter32 writer(64);
+        SkWriter32 writer;
         for (int i = 0; i < 100; ++i) {
             writer.writeInt(i);
         }
         REPORTER_ASSERT(reporter, 100*4 == writer.bytesWritten());
         for (int j = 100*4; j >= 0; j -= 16) {
             writer.rewindToOffset(j);
         }
         REPORTER_ASSERT(reporter, writer.bytesWritten() < 16);
     }
 }
 
 static void test_ptr(skiatest::Reporter* reporter) {
-    SkSWriter32<32> writer(32);
+    SkSWriter32<32> writer;
 
     void* p0 = reporter;
     void* p1 = &writer;
 
     // try writing ptrs where at least one of them may be at a non-multiple of
     // 8 boundary, to confirm this works on 64bit machines.
 
     writer.writePtr(p0);
     writer.write8(0x33);
     writer.writePtr(p1);
@@ skipping 94 matching lines @@
         REPORTER_ASSERT(reporter, memcmp(readPtr, originalData.get(), len) == 0);
         // Ensure that the rest is padded with zeroes.
         const char* stop = readPtr + SkAlign4(len);
         readPtr += len;
         while (readPtr < stop) {
             REPORTER_ASSERT(reporter, *readPtr++ == 0);
         }
     }
 }
 
-DEF_TEST(Writer32, reporter) {
-    // dynamic allocator
-    {
-        SkWriter32 writer(256 * 4);
-        test1(reporter, &writer);
+DEF_TEST(Writer32_dynamic, reporter) {
+    SkWriter32 writer;
+    test1(reporter, &writer);
 
-        writer.reset();
-        test2(reporter, &writer);
+    writer.reset();
+    test2(reporter, &writer);
 
-        writer.reset();
-        testWritePad(reporter, &writer);
-    }
+    writer.reset();
+    testWritePad(reporter, &writer);
+}
 
-    // storage-block
-    {
-        SkWriter32 writer(0);
-        uint32_t storage[256];
-        writer.reset(storage, sizeof(storage));
-        // These three writes are small enough to fit in storage.
-        test1(reporter, &writer);
-        REPORTER_ASSERT(reporter, writer.wroteOnlyToStorage());
+DEF_TEST(Writer32_contiguous, reporter) {
+    uint32_t storage[256];
+    SkWriter32 writer;
+    writer.reset(storage, sizeof(storage));
+    // This write is small enough to fit in storage, so it's contiguous.
+    test1(reporter, &writer);
+    REPORTER_ASSERT(reporter, writer.contiguousArray() != NULL);
 
-        writer.reset(storage, sizeof(storage));
-        test2(reporter, &writer);
-        REPORTER_ASSERT(reporter, writer.wroteOnlyToStorage());
+    // This write is too big for the 32 byte storage block we provide.
+    writer.reset(storage, 32);
+    test2(reporter, &writer);
+    // Some data is in storage, some in writer's internal storage.
+    REPORTER_ASSERT(reporter, writer.contiguousArray() == NULL);
 
-        writer.reset(storage, sizeof(storage));
-        testWritePad(reporter, &writer);
-        REPORTER_ASSERT(reporter, writer.wroteOnlyToStorage());
+    writer.reset();
+    test2(reporter, &writer);
+    // There is no external storage.  All the data is in internal storage,
+    // so we can always read it contiguously.
+    REPORTER_ASSERT(reporter, writer.contiguousArray() != NULL);
+}
 
-        // Try overflowing the storage-block.
-        uint32_t smallStorage[8];
-        writer.reset(smallStorage, sizeof(smallStorage));
-        test2(reporter, &writer);
-        REPORTER_ASSERT(reporter, !writer.wroteOnlyToStorage());
-    }
+DEF_TEST(Writer32_small, reporter) {
+    SkSWriter32<8 * sizeof(intptr_t)> writer;
+    test1(reporter, &writer);
+    writer.reset(); // should just rewind our storage
+    test2(reporter, &writer);
 
-    // small storage
-    {
-        SkSWriter32<8 * sizeof(intptr_t)> writer(100);
-        test1(reporter, &writer);
-        writer.reset(); // should just rewind our storage
-        test2(reporter, &writer);
+    writer.reset();
+    testWritePad(reporter, &writer);
+}
 
-        writer.reset();
-        testWritePad(reporter, &writer);
-    }
+DEF_TEST(Writer32_large, reporter) {
+    SkSWriter32<1024 * sizeof(intptr_t)> writer;
+    test1(reporter, &writer);
+    writer.reset(); // should just rewind our storage
+    test2(reporter, &writer);
 
-    // large storage
-    {
-        SkSWriter32<1024 * sizeof(intptr_t)> writer(100);
-        test1(reporter, &writer);
-        writer.reset(); // should just rewind our storage
-        test2(reporter, &writer);
+    writer.reset();
+    testWritePad(reporter, &writer);
+}
 
-        writer.reset();
-        testWritePad(reporter, &writer);
-    }
-
+DEF_TEST(Writer32_misc, reporter) {
     test_reserve(reporter);
     test_string_null(reporter);
     test_ptr(reporter);
     test_rewind(reporter);
 }