Eliminate copies of encoded image data

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

Index: third_party/WebKit/Source/platform/image-decoders/ROBufferSegmentReader.cpp
diff --git a/third_party/WebKit/Source/platform/image-decoders/ROBufferSegmentReader.cpp b/third_party/WebKit/Source/platform/image-decoders/ROBufferSegmentReader.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..48e60920e52c5f682a70919bd030ee86e257469b
--- /dev/null
+++ b/third_party/WebKit/Source/platform/image-decoders/ROBufferSegmentReader.cpp
@@ -0,0 +1,108 @@
+// Copyright 2016 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/SegmentReader.h"
+
+#include "third_party/skia/src/core/SkRWBuffer.h"
+#include "wtf/Assertions.h"
+#include "wtf/Noncopyable.h"
+#include "wtf/PassRefPtr.h"
+#include "wtf/RefPtr.h"
+
+namespace blink {
+
+class ROBufferSegmentReader final : public SegmentReader {
+    WTF_MAKE_NONCOPYABLE(ROBufferSegmentReader);
+public:
+    ROBufferSegmentReader(PassRefPtr<SkROBuffer>);
+
+    size_t getSomeData(const char*& data, size_t position) const override;
+    size_t size() const override { return m_roBuffer ? m_roBuffer->size() : 0; }
+    PassRefPtr<SkData> getAsSkData() const override;
+
+private:
+    RefPtr<SkROBuffer> m_roBuffer;
+    // Position of the first char in the current block of m_iter.
+    mutable size_t m_positionOfBlock;
+    mutable SkROBuffer::Iter m_iter;
+};
+
+PassRefPtr<SegmentReader> SegmentReader::createFromSkROBuffer(PassRefPtr<SkROBuffer> buffer)
+{
+    return adoptRef(new ROBufferSegmentReader(buffer));
+}
+
+ROBufferSegmentReader::ROBufferSegmentReader(PassRefPtr<SkROBuffer> buffer)
+    : m_roBuffer(buffer)
+    , m_positionOfBlock(0)
+    , m_iter(m_roBuffer.get())
+    {}
+
+size_t ROBufferSegmentReader::getSomeData(const char*& data, size_t position) const
+{
+    if (!m_roBuffer)
+        return 0;
+
+    if (position < m_positionOfBlock) {
+        // SkROBuffer::Iter only iterates forwards. Start from the
+        // beginning.
+        m_iter.reset(m_roBuffer.get());
+        m_positionOfBlock = 0;
+    }
+
+    for (size_t sizeOfBlock = m_iter.size(); sizeOfBlock != 0; m_positionOfBlock += sizeOfBlock) {
+        ASSERT(m_positionOfBlock <= position);
+
+        if (m_positionOfBlock + sizeOfBlock > position) {
+            // |position| is in this block.
+            const size_t positionInBlock = position - m_positionOfBlock;
+            data = static_cast<const char*>(m_iter.data()) + positionInBlock;
+            return sizeOfBlock - positionInBlock;
+        }
+
+        // Move to next block.
+        if (!m_iter.next()) {
+            // Reset to the beginning, so future calls can succeed.
+            m_iter.reset(m_roBuffer.get());
+            m_positionOfBlock = 0;
+            return 0;
+        }
+
+    }
+
+    return 0;
+}
+
+static void unrefROBuffer(const void* ptr, void* context)
+{
+    static_cast<SkROBuffer*>(context)->unref();
+}
+
+PassRefPtr<SkData> ROBufferSegmentReader::getAsSkData() const
+{
+    if (!m_roBuffer)
+        return nullptr;
+
+    // Check to see if the data is already contiguous.
+    SkROBuffer::Iter iter(m_roBuffer.get());
+    const bool multipleBlocks = iter.next();
+    iter.reset(m_roBuffer.get());
+
+    if (!multipleBlocks) {
+        // Contiguous data. No need to copy.
+        m_roBuffer->ref();
+        return adoptRef(SkData::NewWithProc(iter.data(), iter.size(), &unrefROBuffer, m_roBuffer.get()));
+    }
+
+    SkData* data = SkData::NewUninitialized(m_roBuffer->size());

[scroggo, 2016/03/25 15:49:53]

Updating this to a RefPtr...

+    char* dst = static_cast<char*>(data->writable_data());
+    do {
+        size_t size = iter.size();
+        memcpy(dst, iter.data(), size);
+        dst += size;
+    } while (iter.next());
+    return adoptRef(data);
+}
+
+} // namespace blink