Add a method to read a stream without advancing it.

tests/StreamTest.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 "Resources.h"
 #include "SkData.h"
+#include "SkFrontBufferedStream.h"
 #include "SkOSFile.h"
 #include "SkRandom.h"
 #include "SkStream.h"
 #include "Test.h"
 
 #ifndef SK_BUILD_FOR_WIN
 #include <unistd.h>
 #include <fcntl.h>
 #endif
 
@@ skipping 164 matching lines @@
     memStream.setData(nullData);
     TestDereferencingData(&memStream);
 
 }
 
 DEF_TEST(Stream, reporter) {
     TestWStream(reporter);
     TestPackedUInt(reporter);
     TestNullData();
 }
+
+/**
+ *  Tests peeking and then reading the same amount. The two should provide the
+ *  same results.
+ *  Returns the amount successfully read minus the amount successfully peeked.
+ */
+static size_t compare_peek_to_read(skiatest::Reporter* reporter,
+                                   SkStream* stream, size_t bytesToPeek) {
+    // The rest of our tests won't be very interesting if bytesToPeek is zero.
+    REPORTER_ASSERT(reporter, bytesToPeek > 0);
+    SkAutoMalloc peekStorage(bytesToPeek);
+    SkAutoMalloc readStorage(bytesToPeek);
+    void* peekPtr = peekStorage.get();
+    void* readPtr = peekStorage.get();
+
+    const size_t bytesPeeked = stream->peek(peekPtr, bytesToPeek);
+    const size_t bytesRead = stream->read(readPtr, bytesToPeek);
+
+    // bytesRead should only be less than attempted if the stream is at the
+    // end.
+    REPORTER_ASSERT(reporter, bytesRead == bytesToPeek || stream->isAtEnd());
+
+    // The only way this can fail with our existing streams is if it is a file
+    // stream and seek() failed.
+    REPORTER_ASSERT(reporter, bytesPeeked != SkStream::kFailed_PeekResult);
+
+    if (0 == bytesPeeked || SkStream::kUnsupported_PeekResult == bytesPeeked) {
+        // The mem compare will not be very interesting here.
+        return bytesRead;
+    }
+
+    // peek and read should behave the same, except peek returned to the
+    // original position, so they read the same data.
+    REPORTER_ASSERT(reporter, !memcmp(peekPtr, readPtr, bytesPeeked));
+
+    // A stream should never be able to peek less than it can read.

[bungeman-skia, 2015/04/01 19:04:40]

Should this be

// A stream should never be able to peek *more* than it can read.

+    REPORTER_ASSERT(reporter, bytesRead >= bytesPeeked);
+    return bytesRead - bytesPeeked;
+}
+
+// Test peeking on a stream for which peeking is always supported.
+static void test_fully_peekable_stream(skiatest::Reporter* r,
+                                       SkStream* stream) {

[bungeman-skia, 2015/04/01 19:04:40]

Seems that this would fit on the previous line?

[scroggo, 2015/04/02 18:04:53]

82 chars. I'm never sure how to treat our soft limit of 80 characters...

+    for (size_t i = 1; !stream->isAtEnd(); i++) {
+        // We can always peek as many bytes as we can read.
+        REPORTER_ASSERT(r, compare_peek_to_read(r, stream, i) == 0);
+    }
+}
+
+static void test_peeking_front_buffered_stream(skiatest::Reporter* r,
+                                               const SkStream& original,
+                                               size_t bufferSize) {
+    SkStream* dupe = original.duplicate();
+    REPORTER_ASSERT(r, dupe != NULL);
+    SkAutoTDelete<SkStream> bufferedStream(SkFrontBufferedStream::Create(dupe, bufferSize));
+    REPORTER_ASSERT(r, bufferedStream != NULL);
+    size_t peeked = 0;
+    for (size_t i = 1; !bufferedStream->isAtEnd(); i++) {
+        const size_t unpeekableBytes = compare_peek_to_read(r, bufferedStream, i);
+        if (unpeekableBytes > 0) {
+            // This could not have returned a number greater than i.
+            REPORTER_ASSERT(r, unpeekableBytes <= i);
+
+            // We have reached the end of the buffer. Verify that it was at least
+            // bufferSize.
+            REPORTER_ASSERT(r, peeked + i - unpeekableBytes >= bufferSize);
+            // No more peeking is supported.
+            break;
+        }
+        peeked += i;
+    }
+}
+
+DEF_TEST(StreamPeek, reporter) {
+    // Test a memory stream.
+    const char gAbcs[] = "abcdefghijklmnopqrstuvwxyz";
+    SkMemoryStream memStream(gAbcs, strlen(gAbcs), false);
+    test_fully_peekable_stream(reporter, &memStream);
+
+    // Test an arbitrary file stream.
+    SkFILEStream fileStream(GetResourcePath("baby_tux.webp").c_str());
+    REPORTER_ASSERT(reporter, fileStream.isValid());
+    test_fully_peekable_stream(reporter, &fileStream);
+
+    // Now test some FrontBufferedStreams
+    for (size_t i = 1; i < memStream.getLength(); i++) {
+        test_peeking_front_buffered_stream(reporter, memStream, i);
+    }
+}