Eliminate copies of encoded image data

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

+// 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 "platform/SharedBuffer.h"
+#include "third_party/skia/include/core/SkData.h"
+#include "wtf/Assertions.h"
+#include "wtf/Noncopyable.h"
+#include "wtf/PassRefPtr.h"
+#include "wtf/RefPtr.h"
+
+namespace blink {
+
+// SharedBufferSegmentReader ---------------------------------------------------
+
+// Interface for ImageDecoder to read a SharedBuffer.
+class SharedBufferSegmentReader final : public SegmentReader {
+    WTF_MAKE_NONCOPYABLE(SharedBufferSegmentReader);
+public:
+    SharedBufferSegmentReader(PassRefPtr<SharedBuffer>);
+    size_t size() const override;
+    size_t getSomeData(const char*& data, size_t position) const override;
+    PassRefPtr<SkData> getAsSkData() const override;
+private:
+    RefPtr<SharedBuffer> m_sharedBuffer;
+};
+
+SharedBufferSegmentReader::SharedBufferSegmentReader(PassRefPtr<SharedBuffer> buffer)
+    : m_sharedBuffer(buffer) {}
+
+size_t SharedBufferSegmentReader::size() const
+{
+    return m_sharedBuffer->size();
+}
+
+size_t SharedBufferSegmentReader::getSomeData(const char*& data, size_t position) const
+{
+    return m_sharedBuffer->getSomeData(data, position);
+}
+
+PassRefPtr<SkData> SharedBufferSegmentReader::getAsSkData() const
+{
+    return m_sharedBuffer->getAsSkData();
+}
+
+// DataSegmentReader -----------------------------------------------------------
+
+// Interface for ImageDecoder to read an SkData.
+class DataSegmentReader final : public SegmentReader {
+    WTF_MAKE_NONCOPYABLE(DataSegmentReader);
+public:
+    DataSegmentReader(PassRefPtr<SkData>);
+    size_t size() const override;
+    size_t getSomeData(const char*& data, size_t position) const override;
+    PassRefPtr<SkData> getAsSkData() const override;
+private:
+    RefPtr<SkData> m_data;
+};
+
+DataSegmentReader::DataSegmentReader(PassRefPtr<SkData> data)
+    : m_data(data) {}
+
+size_t DataSegmentReader::size() const
+{
+    return m_data->size();
+}
+
+size_t DataSegmentReader::getSomeData(const char*& data, size_t position) const
+{
+    if (position >= m_data->size())
+        return 0;
+
+    data = reinterpret_cast<const char*>(m_data->bytes() + position);
+    return m_data->size() - position;
+}
+
+PassRefPtr<SkData> DataSegmentReader::getAsSkData() const
+{
+    return m_data.get();
+}
+
+// ROBufferSegmentReader -------------------------------------------------------
+
+class ROBufferSegmentReader final : public SegmentReader {
+    WTF_MAKE_NONCOPYABLE(ROBufferSegmentReader);
+public:
+    ROBufferSegmentReader(PassRefPtr<SkROBuffer>);
+
+    size_t size() const override;
+    size_t getSomeData(const char*& data, size_t position) const override;
+    PassRefPtr<SkData> getAsSkData() const override;
+
+private:
+    RefPtr<SkROBuffer> m_roBuffer;
+};
+
+ROBufferSegmentReader::ROBufferSegmentReader(PassRefPtr<SkROBuffer> buffer)
+    : m_roBuffer(buffer)
+    {}
+
+size_t ROBufferSegmentReader::size() const
+{
+    return m_roBuffer ? m_roBuffer->size() : 0;
+}
+
+size_t ROBufferSegmentReader::getSomeData(const char*& data, size_t position) const
+{
+    if (!m_roBuffer)
+        return 0;
+
+    SkROBuffer::Iter iter(m_roBuffer.get());

[scroggo_chromium, 2016/04/05 20:43:04]

Along with the switch to ThreadSafeRefCounted, this makes the
ROBufferSegmentReader thread-safe. I now use a local Iter instead of keeping a
mutable one in the class. In theory this could slow down decodes, since we have
to iterate from the beginning in each call to getSomeData, but I did not see a
significant  difference. If it did cause a slowdown, we could try another way to
make this safe (without having to start the iterator from the beginning), e.g.
locking a mutex.

+    for (size_t sizeOfBlock = iter.size(), positionOfBlock = 0; sizeOfBlock != 0; positionOfBlock += sizeOfBlock, sizeOfBlock = iter.size()) {

[scroggo_chromium, 2016/04/05 20:43:04]

When I converted to a for loop, I left out updating sizeOfBlock. This often
worked out okay, but I eventually noticed artifacts from reading the wrong data.
This patch set updates sizeOfBlock correctly.

[Peter Kasting, 2016/04/05 22:26:57]

Good catch.  Any way to set up a test that would verify this (by having blocks
of different sizes)?

[scroggo_chromium, 2016/04/06 19:20:23]

Done.

+        ASSERT(positionOfBlock <= position);
+
+        if (positionOfBlock + sizeOfBlock > position) {
+            // |position| is in this block.
+            const size_t positionInBlock = position - positionOfBlock;
+            data = static_cast<const char*>(iter.data()) + positionInBlock;
+            return sizeOfBlock - positionInBlock;
+        }
+
+        // Move to next block.
+        if (!iter.next()) {
+            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()));
+    }
+
+    RefPtr<SkData> data = adoptRef(SkData::NewUninitialized(m_roBuffer->size()));
+    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 data.release();
+}
+
+// SegmentReader ---------------------------------------------------------------
+
+PassRefPtr<SegmentReader> SegmentReader::createFromSharedBuffer(PassRefPtr<SharedBuffer> buffer)
+{
+    return adoptRef(new SharedBufferSegmentReader(buffer));
+}
+
+PassRefPtr<SegmentReader> SegmentReader::createFromSkData(PassRefPtr<SkData> data)
+{
+    return adoptRef(new DataSegmentReader(data));
+}
+
+PassRefPtr<SegmentReader> SegmentReader::createFromSkROBuffer(PassRefPtr<SkROBuffer> buffer)
+{
+    return adoptRef(new ROBufferSegmentReader(buffer));
+}
+
+} // namespace blink
+