Revert "use unique_ptr for stream api"

This reverts commit 49f1f34438d3431f6d7e32847accd2ba96948a73.

Reason for revert: broke win-chrome

../../third_party/skia/src/ports/SkFontMgr_win_dw.cpp(89): error C2228: left of '.release' must have class/struct/union
../../third_party/skia/src/ports/SkFontMgr_win_dw.cpp(89): note: type is 'SkStreamAsset *'
../../third_party/skia/src/ports/SkFontMgr_win_dw.cpp(89): note: did you intend to use '->' instead?


Original change's description:
> use unique_ptr for stream api
> 
> Bug: skia:6888
> Change-Id: I3459b4913982a7cae1c0061697c82cc65ad9a2d8
> Reviewed-on: https://skia-review.googlesource.com/26740
> Reviewed-by: Mike Klein <mtklein@chromium.org>
> Commit-Queue: Mike Reed <reed@google.com>

TBR=mtklein@chromium.org,mtklein@google.com,bungeman@google.com,reed@google.com

Change-Id: Ic1e4af557317abd06b7f6b7f5056645df7e469f0
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:6888
Reviewed-on: https://skia-review.googlesource.com/47440
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Mike Reed <reed@google.com>

3 files changed, 15 insertions, 25 deletions

diff --git a/tests/CodecTest.cpp b/tests/CodecTest.cpp
index f2551d2d95..baa231497f 100644
--- a/tests/CodecTest.cpp
+++ b/tests/CodecTest.cpp
@@ -442,10 +442,10 @@ static void check(skiatest::Reporter* r,
 
 #ifndef SK_PNG_DISABLE_TESTS
         // Test using SkFrontBufferedStream, as Android does
-        auto bufferedStream = SkFrontBufferedStream::Make(
-                      SkMemoryStream::Make(std::move(fullData)), SkCodec::MinBufferedBytesNeeded());
+        SkStream* bufferedStream = SkFrontBufferedStream::Create(
+                new SkMemoryStream(std::move(fullData)), SkCodec::MinBufferedBytesNeeded());
         REPORTER_ASSERT(r, bufferedStream);
-        codec = SkCodec::MakeFromStream(std::move(bufferedStream));
+        codec = SkCodec::MakeFromStream(std::unique_ptr<SkStream>(bufferedStream));
         REPORTER_ASSERT(r, codec);
         if (codec) {
             test_info(r, codec.get(), info, SkCodec::kSuccess, &codecDigest);
diff --git a/tests/FrontBufferedStreamTest.cpp b/tests/FrontBufferedStreamTest.cpp
index 5452730ea4..aa2dc89a11 100644
--- a/tests/FrontBufferedStreamTest.cpp
+++ b/tests/FrontBufferedStreamTest.cpp
@@ -54,10 +54,9 @@ static void test_incremental_buffering(skiatest::Reporter* reporter, size_t buff
     // NOTE: For this and other tests in this file, we cheat and continue to refer to the
     // wrapped stream, but that's okay because we know the wrapping stream has not been
     // deleted yet (and we only call const methods in it).
-    SkMemoryStream* memStream = SkMemoryStream::MakeDirect(gAbcs, strlen(gAbcs)).release();
+    SkMemoryStream* memStream = new SkMemoryStream(gAbcs, strlen(gAbcs), false);
 
-    auto bufferedStream = SkFrontBufferedStream::Make(std::unique_ptr<SkStream>(memStream),
-                                                      bufferSize);
+    std::unique_ptr<SkStream> bufferedStream(SkFrontBufferedStream::Create(memStream, bufferSize));
     test_hasLength(reporter, *bufferedStream, *memStream);
 
     // First, test reading less than the max buffer size.
@@ -83,9 +82,8 @@ static void test_incremental_buffering(skiatest::Reporter* reporter, size_t buff
 }
 
 static void test_perfectly_sized_buffer(skiatest::Reporter* reporter, size_t bufferSize) {
-    SkMemoryStream* memStream = SkMemoryStream::MakeDirect(gAbcs, strlen(gAbcs)).release();
-    auto bufferedStream = SkFrontBufferedStream::Make(std::unique_ptr<SkStream>(memStream),
-                                                      bufferSize);
+    SkMemoryStream* memStream = new SkMemoryStream(gAbcs, strlen(gAbcs), false);
+    std::unique_ptr<SkStream> bufferedStream(SkFrontBufferedStream::Create(memStream, bufferSize));
     test_hasLength(reporter, *bufferedStream, *memStream);
 
     // Read exactly the amount that fits in the buffer.
@@ -103,9 +101,8 @@ static void test_perfectly_sized_buffer(skiatest::Reporter* reporter, size_t buf
 }
 
 static void test_skipping(skiatest::Reporter* reporter, size_t bufferSize) {
-    SkMemoryStream* memStream = SkMemoryStream::MakeDirect(gAbcs, strlen(gAbcs)).release();
-    auto bufferedStream = SkFrontBufferedStream::Make(std::unique_ptr<SkStream>(memStream),
-                                                      bufferSize);
+    SkMemoryStream* memStream = new SkMemoryStream(gAbcs, strlen(gAbcs), false);
+    std::unique_ptr<SkStream> bufferedStream(SkFrontBufferedStream::Create(memStream, bufferSize));
     test_hasLength(reporter, *bufferedStream, *memStream);
 
     // Skip half the buffer.
@@ -159,8 +156,7 @@ static void test_read_beyond_buffer(skiatest::Reporter* reporter, size_t bufferS
             new AndroidLikeMemoryStream((void*)gAbcs, bufferSize, false);
 
     // Create a buffer that matches the length of the stream.
-    auto bufferedStream = SkFrontBufferedStream::Make(std::unique_ptr<SkStream>(memStream),
-                                                      bufferSize);
+    std::unique_ptr<SkStream> bufferedStream(SkFrontBufferedStream::Create(memStream, bufferSize));
     test_hasLength(reporter, *bufferedStream.get(), *memStream);
 
     // Attempt to read one more than the bufferSize
@@ -207,8 +203,7 @@ static void test_length_combos(skiatest::Reporter* reporter, size_t bufferSize)
         for (int hasPos = 0; hasPos <= 1; hasPos++) {
             LengthOptionalStream* stream =
                     new LengthOptionalStream(SkToBool(hasLen), SkToBool(hasPos));
-            auto buffered = SkFrontBufferedStream::Make(std::unique_ptr<SkStream>(stream),
-                                                        bufferSize);
+            std::unique_ptr<SkStream> buffered(SkFrontBufferedStream::Create(stream, bufferSize));
             test_hasLength(reporter, *buffered.get(), *stream);
         }
     }
@@ -222,8 +217,7 @@ static void test_initial_offset(skiatest::Reporter* reporter, size_t bufferSize)
     // the stream it wraps.
     const size_t arbitraryOffset = 17;
     memStream->skip(arbitraryOffset);
-    auto bufferedStream = SkFrontBufferedStream::Make(std::unique_ptr<SkStream>(memStream),
-                                                      bufferSize);
+    std::unique_ptr<SkStream> bufferedStream(SkFrontBufferedStream::Create(memStream, bufferSize));
 
     // Since SkMemoryStream has a length, bufferedStream must also.
     REPORTER_ASSERT(reporter, bufferedStream->hasLength());
@@ -287,7 +281,7 @@ private:
 
 DEF_TEST(ShortFrontBufferedStream, reporter) {
     FailingStream* failingStream = new FailingStream;
-    auto stream = SkFrontBufferedStream::Make(std::unique_ptr<SkStream>(failingStream), 64);
+    std::unique_ptr<SkStreamRewindable> stream(SkFrontBufferedStream::Create(failingStream, 64));
 
     // This will fail to create a codec.  However, what we really want to test is that we
     // won't read past the end of the stream.
diff --git a/tests/StreamTest.cpp b/tests/StreamTest.cpp
index 2e8078e337..8b5b2ae05a 100644
--- a/tests/StreamTest.cpp
+++ b/tests/StreamTest.cpp
@@ -227,9 +227,9 @@ static void test_fully_peekable_stream(skiatest::Reporter* r, SkStream* stream,
 static void test_peeking_front_buffered_stream(skiatest::Reporter* r,
                                                const SkStream& original,
                                                size_t bufferSize) {
-    std::unique_ptr<SkStream> dupe(original.duplicate());
+    SkStream* dupe = original.duplicate();
     REPORTER_ASSERT(r, dupe != nullptr);
-    auto bufferedStream = SkFrontBufferedStream::Make(std::move(dupe), bufferSize);
+    std::unique_ptr<SkStream> bufferedStream(SkFrontBufferedStream::Create(dupe, bufferSize));
     REPORTER_ASSERT(r, bufferedStream != nullptr);
 
     size_t peeked = 0;
@@ -249,11 +249,7 @@ static void test_peeking_front_buffered_stream(skiatest::Reporter* r,
     }
 
     // Test that attempting to peek beyond the length of the buffer does not prevent rewinding.
-#ifdef SK_SUPPORT_LEGACY_STREAM_API
     bufferedStream.reset(SkFrontBufferedStream::Create(original.duplicate(), bufferSize));
-#else
-    bufferedStream = SkFrontBufferedStream::Make(original.duplicate(), bufferSize);
-#endif
     REPORTER_ASSERT(r, bufferedStream != nullptr);
 
     const size_t bytesToPeek = bufferSize + 1;