Decrease GrInOrderDrawBuffer::Cmd's reliance on GrInOrderDrawBuffer

tests/MemsetTest.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 "SkChunkAlloc.h"
 #include "SkUtils.h"
 #include "Test.h"
 
+static void check_alloc(skiatest::Reporter* reporter, const SkChunkAlloc& alloc,
+                        size_t capacity, size_t used, int numBlocks) {
+    REPORTER_ASSERT(reporter, alloc.totalCapacity() >= capacity);
+    REPORTER_ASSERT(reporter, alloc.totalUsed() == used);
+    REPORTER_ASSERT(reporter, alloc.blockCount() == numBlocks);
+}
+
+static void* simple_alloc(skiatest::Reporter* reporter, SkChunkAlloc* alloc, size_t size) {
+    void* ptr = alloc->allocThrow(size);
+    check_alloc(reporter, *alloc, size, size, 1);
+    REPORTER_ASSERT(reporter, alloc->contains(ptr));
+    return ptr;
+}
+                        
 static void test_chunkalloc(skiatest::Reporter* reporter) {
-    size_t min = 256;
-    SkChunkAlloc alloc(min);
+    static const size_t kMin = 1024;
+    SkChunkAlloc alloc(kMin);
 
-    REPORTER_ASSERT(reporter, 0 == alloc.totalCapacity());
-    REPORTER_ASSERT(reporter, 0 == alloc.totalUsed());
-    REPORTER_ASSERT(reporter, 0 == alloc.blockCount());
+    //------------------------------------------------------------------------
+    // check empty
+    check_alloc(reporter, alloc, 0, 0, 0);
     REPORTER_ASSERT(reporter, !alloc.contains(NULL));
     REPORTER_ASSERT(reporter, !alloc.contains(reporter));
 
+    // reset on empty allocator
     alloc.reset();
-    REPORTER_ASSERT(reporter, 0 == alloc.totalCapacity());
-    REPORTER_ASSERT(reporter, 0 == alloc.totalUsed());
-    REPORTER_ASSERT(reporter, 0 == alloc.blockCount());
+    check_alloc(reporter, alloc, 0, 0, 0);
 
-    size_t size = min >> 1;
-    void* ptr = alloc.allocThrow(size);
-    REPORTER_ASSERT(reporter, alloc.totalCapacity() >= size);
-    REPORTER_ASSERT(reporter, alloc.totalUsed() == size);
-    REPORTER_ASSERT(reporter, alloc.blockCount() > 0);
+    // rewind on empty allocator
+    alloc.rewind();
+    check_alloc(reporter, alloc, 0, 0, 0);
+
+    //------------------------------------------------------------------------
+    // test reset when something is allocated
+    size_t size = kMin >> 1;
+    void* ptr = simple_alloc(reporter, &alloc, size);
+
+    alloc.reset();
+    check_alloc(reporter, alloc, 0, 0, 0);
+    REPORTER_ASSERT(reporter, !alloc.contains(ptr));
+
+    //------------------------------------------------------------------------
+    // test rewind when something is allocated
+    ptr = simple_alloc(reporter, &alloc, size);
+
+    alloc.rewind();
+    check_alloc(reporter, alloc, size, 0, 1);
+    REPORTER_ASSERT(reporter, !alloc.contains(ptr));
+
+    // use the available block
+    ptr = simple_alloc(reporter, &alloc, size);
+    alloc.reset();
+
+    //------------------------------------------------------------------------
+    // test out pre allocating a block
+    alloc.preAlloc(size);
+    check_alloc(reporter, alloc, size, 0, 1);
+
+    // use the available block
+    ptr = simple_alloc(reporter, &alloc, size);
+    alloc.reset();
+
+    //------------------------------------------------------------------------
+    // test out allocating a second block
+    ptr = simple_alloc(reporter, &alloc, size);
+
+    ptr = alloc.allocThrow(kMin);
+    check_alloc(reporter, alloc, 2*kMin, size+kMin, 2);
     REPORTER_ASSERT(reporter, alloc.contains(ptr));
 
-    alloc.reset();
+    //------------------------------------------------------------------------
+    // test out unalloc
+    size_t freed = alloc.unalloc(ptr);
+    REPORTER_ASSERT(reporter, freed == kMin);
+    check_alloc(reporter, alloc, 2*kMin, size, 2);
     REPORTER_ASSERT(reporter, !alloc.contains(ptr));
-    REPORTER_ASSERT(reporter, 0 == alloc.totalCapacity());
-    REPORTER_ASSERT(reporter, 0 == alloc.totalUsed());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void set_zero(void* dst, size_t bytes) {
     char* ptr = (char*)dst;
     for (size_t i = 0; i < bytes; ++i) {
         ptr[i] = 0;
     }
 }
@@ skipping 66 matching lines @@
  *  Test sk_memset16 and sk_memset32.
  *  For performance considerations, implementations may take different paths
  *  depending on the alignment of the dst, and/or the size of the count.
  */
 DEF_TEST(Memset, reporter) {
     test_16(reporter);
     test_32(reporter);
 
     test_chunkalloc(reporter);
 }