GIF: Avoid copying/storing data when possible
If the input SkStream has a length and position, do not copy and store
LZW blocks or ColorMaps. Instead, mark the position and size, and read
from the stream when necessary.
This will save memory in Chromium's use case, which has already
buffered all of its data.
In the case where we *do* need to copy, store it on the SkStreamBuffer.
This allows SkGifImageReader to have simpler code.
Add tests.
Change-Id: Ic65fa766328ae2e5974b2084bc2099e19aced731
Reviewed-on: https://skia-review.googlesource.com/6157
Reviewed-by: Matt Sarett <msarett@google.com>
Commit-Queue: Leon Scroggins <scroggo@google.com>
diff --git a/tests/FakeStreams.h b/tests/FakeStreams.h
new file mode 100644
index 0000000..6b510b8
--- /dev/null
+++ b/tests/FakeStreams.h
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2016 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 "SkStream.h"
+
+#ifndef FakeStreams_DEFINED
+#define FakeStreams_DEFINED
+
+// Stream that is not an asset stream (!hasPosition() or !hasLength())
+class NotAssetMemStream : public SkStream {
+public:
+ NotAssetMemStream(sk_sp<SkData> data) : fStream(std::move(data)) {}
+
+ bool hasPosition() const override {
+ return false;
+ }
+
+ bool hasLength() const override {
+ return false;
+ }
+
+ size_t peek(void* buf, size_t bytes) const override {
+ return fStream.peek(buf, bytes);
+ }
+ size_t read(void* buf, size_t bytes) override {
+ return fStream.read(buf, bytes);
+ }
+ bool rewind() override {
+ return fStream.rewind();
+ }
+ bool isAtEnd() const override {
+ return fStream.isAtEnd();
+ }
+private:
+ SkMemoryStream fStream;
+};
+
+/*
+ * Represents a stream without all of its data.
+ */
+class HaltingStream : public SkStream {
+public:
+ HaltingStream(sk_sp<SkData> data, size_t initialLimit)
+ : fTotalSize(data->size())
+ , fLimit(initialLimit)
+ , fStream(std::move(data))
+ {}
+
+ void addNewData(size_t extra) {
+ fLimit = SkTMin(fTotalSize, fLimit + extra);
+ }
+
+ size_t read(void* buffer, size_t size) override {
+ if (fStream.getPosition() + size > fLimit) {
+ size = fLimit - fStream.getPosition();
+ }
+
+ return fStream.read(buffer, size);
+ }
+
+ bool isAtEnd() const override {
+ return fStream.isAtEnd();
+ }
+
+ bool hasLength() const override { return true; }
+ size_t getLength() const override { return fLimit; }
+
+ bool hasPosition() const override { return true; }
+ size_t getPosition() const override { return fStream.getPosition(); }
+ bool rewind() override { return fStream.rewind(); }
+ bool move(long offset) override { return fStream.move(offset); }
+ bool seek(size_t position) override { return fStream.seek(position); }
+
+ bool isAllDataReceived() const { return fLimit == fTotalSize; }
+
+private:
+ const size_t fTotalSize;
+ size_t fLimit;
+ SkMemoryStream fStream;
+};
+#endif // FakeStreams_DEFINED