Revert of Fixes for SkRWBuffer

tests/DataRefTest.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 "SkData.h"
 #include "SkDataTable.h"
 #include "SkOSFile.h"
@@ skipping 227 matching lines @@
 
 const char gABC[] = "abcdefghijklmnopqrstuvwxyz";
 
 static void check_abcs(skiatest::Reporter* reporter, const char buffer[], size_t size) {
     REPORTER_ASSERT(reporter, size % 26 == 0);
     for (size_t offset = 0; offset < size; offset += 26) {
         REPORTER_ASSERT(reporter, !memcmp(&buffer[offset], gABC, 26));
     }
 }
 
-// stream should contain an integral number of copies of gABC.
+// stream should contains an integral number of copies of gABC.
 static void check_alphabet_stream(skiatest::Reporter* reporter, SkStream* stream) {
     REPORTER_ASSERT(reporter, stream->hasLength());
     size_t size = stream->getLength();
     REPORTER_ASSERT(reporter, size % 26 == 0);
 
     SkAutoTMalloc<char> storage(size);
     char* array = storage.get();
     size_t bytesRead = stream->read(array, size);
     REPORTER_ASSERT(reporter, bytesRead == size);
     check_abcs(reporter, array, size);
@@ skipping 18 matching lines @@
     size_t offset = 0;
     do {
         SkASSERT(offset + iter.size() <= size);
         memcpy(storage.get() + offset, iter.data(), iter.size());
         offset += iter.size();
     } while (iter.next());
     REPORTER_ASSERT(reporter, offset == size);
     check_abcs(reporter, storage.get(), size);
 }
 
-#include "SkTaskGroup.h"
-
 DEF_TEST(RWBuffer, reporter) {
     // Knowing that the default capacity is 4096, choose N large enough so we force it to use
     // multiple buffers internally.
     const int N = 1000;
     SkROBuffer* readers[N];
     SkStream* streams[N];
 
     {
-        SkTaskGroup tasks;
         SkRWBuffer buffer;
         for (int i = 0; i < N; ++i) {
             buffer.append(gABC, 26);
             readers[i] = buffer.newRBufferSnapshot();
             streams[i] = buffer.newStreamSnapshot();
-            REPORTER_ASSERT(reporter, readers[i]->size() == buffer.size());
-            REPORTER_ASSERT(reporter, streams[i]->getLength() == buffer.size());
-
-            tasks.add([reporter, i, &readers, &streams] {
-                REPORTER_ASSERT(reporter, (i + 1) * 26U == readers[i]->size());
-                REPORTER_ASSERT(reporter, streams[i]->getLength() == readers[i]->size());
-                check_alphabet_buffer(reporter, readers[i]);
-                check_alphabet_stream(reporter, streams[i]);
-                REPORTER_ASSERT(reporter, streams[i]->rewind());
-            });
         }
         REPORTER_ASSERT(reporter, N*26 == buffer.size());
-        tasks.wait();
     }
 
-    // Test again, to verify that the snapshots work even after the SkRWBuffer is gone.
     for (int i = 0; i < N; ++i) {
         REPORTER_ASSERT(reporter, (i + 1) * 26U == readers[i]->size());
-        REPORTER_ASSERT(reporter, streams[i]->getLength() == readers[i]->size());
         check_alphabet_buffer(reporter, readers[i]);
         check_alphabet_stream(reporter, streams[i]);
         readers[i]->unref();
         delete streams[i];
     }
 }
 
 // Tests that it is safe to call SkROBuffer::Iter::size() when exhausted.
 DEF_TEST(RWBuffer_size, r) {
     SkRWBuffer buffer;
     buffer.append(gABC, 26);
 
     SkAutoTUnref<SkROBuffer> roBuffer(buffer.newRBufferSnapshot());
     SkROBuffer::Iter iter(roBuffer);
     REPORTER_ASSERT(r, iter.data());
     REPORTER_ASSERT(r, iter.size() == 26);
 
     // There is only one block in this buffer.
     REPORTER_ASSERT(r, !iter.next());
     REPORTER_ASSERT(r, 0 == iter.size());
 }
 
-// Tests that operations (including the destructor) are safe on an SkRWBuffer
-// without any data appended.
+// Tests that it is safe to destruct an SkRWBuffer without appending
+// anything to it.
 DEF_TEST(RWBuffer_noAppend, r) {
     SkRWBuffer buffer;
     REPORTER_ASSERT(r, 0 == buffer.size());
-
-    sk_sp<SkROBuffer> roBuffer = sk_sp<SkROBuffer>(buffer.newRBufferSnapshot());
-    REPORTER_ASSERT(r, roBuffer);
-    if (roBuffer) {
-        REPORTER_ASSERT(r, roBuffer->size() == 0);
-        SkROBuffer::Iter iter(roBuffer.get());
-        REPORTER_ASSERT(r, iter.size() == 0);
-        REPORTER_ASSERT(r, !iter.data());
-        REPORTER_ASSERT(r, !iter.next());
-    }
-
-    SkAutoTDelete<SkStream> stream(buffer.newStreamSnapshot());
-    REPORTER_ASSERT(r, stream);
-    if (stream) {
-        REPORTER_ASSERT(r, stream->hasLength());
-        REPORTER_ASSERT(r, stream->getLength() == 0);
-        REPORTER_ASSERT(r, stream->skip(10) == 0);
-    }
 }