Move gif image decoder to SkCodec

third_party/WebKit/Source/platform/image-decoders/SegmentStream.cpp

Index: third_party/WebKit/Source/platform/image-decoders/SegmentStream.cpp
diff --git a/third_party/WebKit/Source/platform/image-decoders/SegmentStream.cpp b/third_party/WebKit/Source/platform/image-decoders/SegmentStream.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1d1c347c17f66188af4b8a50461a849b4201a163
--- /dev/null
+++ b/third_party/WebKit/Source/platform/image-decoders/SegmentStream.cpp
@@ -0,0 +1,104 @@
+// Copyright (c) 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "platform/image-decoders/SegmentStream.h"
+#include <utility>
+
+namespace blink {
+
+SegmentStream::SegmentStream() = default;
+
+SegmentStream::SegmentStream(SegmentStream&& rhs)
+    : reader_(std::move(rhs.reader_)),
+      position_(rhs.position_),
+      has_read_all_contents_(rhs.has_read_all_contents_),
+      is_cleared_(rhs.is_cleared_) {}
+
+SegmentStream& SegmentStream::operator=(SegmentStream&& rhs) {
+  reader_ = std::move(rhs.reader_);
+  position_ = rhs.position_;
+  has_read_all_contents_ = rhs.has_read_all_contents_;
+  is_cleared_ = rhs.is_cleared_;
+
+  return *this;
+}
+
+void SegmentStream::SetReader(WTF::PassRefPtr<SegmentReader> reader) {
+  reader_ = std::move(reader);
+  SetPositionState(position_);
+}
+
+size_t SegmentStream::read(void* buffer, size_t size) {
+  if (is_cleared_)
+    return 0;
+
+  size = std::min(size, reader_->size() - position_);
+
+  size_t bytes_advanced = 0;
+  if (!buffer) {  // skipping, not reading
+    bytes_advanced = size;
+  } else {
+    bytes_advanced = peek(buffer, size);
+  }
+
+  SetPositionState(position_ + bytes_advanced);
+
+  return bytes_advanced;
+}
+
+size_t SegmentStream::peek(void* buffer, size_t size) const {
+  if (is_cleared_)
+    return 0;
+
+  size = std::min(size, reader_->size() - position_);
+
+  size_t total_bytes_peeked = 0;
+  char* buffer_as_char_ptr = reinterpret_cast<char*>(buffer);
+  while (size) {
+    const char* segment = nullptr;
+    size_t bytes_peeked =
+        reader_->GetSomeData(segment, position_ + total_bytes_peeked);
+    if (!bytes_peeked)
+      break;
+    if (bytes_peeked > size)
+      bytes_peeked = size;
+
+    memcpy(buffer_as_char_ptr, segment, bytes_peeked);
+    buffer_as_char_ptr += bytes_peeked;
+    size -= bytes_peeked;
+    total_bytes_peeked += bytes_peeked;
+  }
+
+  return total_bytes_peeked;
+}
+
+bool SegmentStream::rewind() {
+  SetPositionState(0);
+  return true;
+}
+
+bool SegmentStream::seek(size_t position) {
+  SetPositionState(position);
+  return true;
+}
+
+bool SegmentStream::move(long offset) {
+  DCHECK_GT(offset, 0);

[scroggo_chromium, 2017/08/08 19:39:25]

In [1], vmpstr@ suggested that you "DCHECK absolute_position > 0", where
absolute_position = position_ + offset. This is a slightly different DCHECK. In
practice, this statement is also always true, and I don't foresee it changing.
If it does, I suppose this DCHECK_GT will catch us.

[1]
https://codereview.chromium.org/2565323003/diff/2480001/third_party/WebKit/So...

[cblume, 2017/08/09 17:29:29]

position_ is a size_t and can never be negative.
The only way absolute_position could have been <= 0 is if offset was <= 0.
So although this line is different, it should be effectively the same. It
asserts on the same condition.

Note, position_ and offset could both be 0. This is valid although odd. My old
code handled this. DCHECK absolute_position > 0 does not.

The reason I went with this instead of DCHECK absolute_position > 0 is because
of another comment in [1] you linked on line 59:
https://codereview.chromium.org/2565323003/diff/2480001/third_party/WebKit/So...
That comment requests getting rid of a named variable which is only there to
give a name to the equation.
It is very similar to absolute_position was here. I was trying to adopt the
spirit of the comment.

[scroggo_chromium, 2017/08/09 17:50:48]

sgtm

+  SetPositionState(position_ + offset);
+  return true;
+}
+
+void SegmentStream::SetPositionState(size_t new_position) {
+  position_ = new_position;
+  if (reader_) {
+    const size_t reader_size = reader_->size();
+    has_read_all_contents_ = position_ >= reader_size;
+    is_cleared_ = position_ > reader_size;
+  } else {
+    has_read_all_contents_ = true;
+    is_cleared_ = true;
+  }
+}
+
+}  // namespace blink