Ganesh: images upload to GPU performance fix (skip copying encoded data)

third_party/WebKit/Source/platform/graphics/ImageFrameGenerator.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #include "platform/graphics/ImageFrameGenerator.h"
 
+#include "SkData.h"
 #include "platform/SharedBuffer.h"
 #include "platform/TraceEvent.h"
 #include "platform/graphics/ImageDecodingStore.h"
 #include "platform/image-decoders/ImageDecoder.h"
 
 namespace blink {
 
 static bool compatibleInfo(const SkImageInfo& src, const SkImageInfo& dst)
 {
     if (src == dst)
@@ skipping 54 matching lines @@
     componentSizes[0].set(size.width(), size.height());
     size = decoder->decodedYUVSize(1, sizeType);
     componentSizes[1].set(size.width(), size.height());
     size = decoder->decodedYUVSize(2, sizeType);
     componentSizes[2].set(size.width(), size.height());
     return true;
 }
 
 ImageFrameGenerator::ImageFrameGenerator(const SkISize& fullSize, PassRefPtr<SharedBuffer> data, bool allDataReceived, bool isMultiFrame)
     : m_fullSize(fullSize)
+    , m_data(adoptRef(new ThreadSafeDataTransport()))
     , m_isMultiFrame(isMultiFrame)
     , m_decodeFailedAndEmpty(false)
     , m_decodeCount(0)
     , m_frameCount(0)
 {
     setData(data.get(), allDataReceived);
 }
 
 ImageFrameGenerator::~ImageFrameGenerator()
 {
     ImageDecodingStore::instance().removeCacheIndexedByGenerator(this);
 }
 
 void ImageFrameGenerator::setData(PassRefPtr<SharedBuffer> data, bool allDataReceived)
 {
-    m_data.setData(data.get(), allDataReceived);
+    m_data->setData(data.get(), allDataReceived);
 }
 
-void ImageFrameGenerator::copyData(RefPtr<SharedBuffer>* data, bool* allDataReceived)
+static void sharedSkDataReleaseCallback(const void* address, void* context)
 {
+    ThreadSafeDataTransport* dataTransport = static_cast<ThreadSafeDataTransport*>(context);
+#if ENABLE(ASSERT)
+    ASSERT(dataTransport);
     SharedBuffer* buffer = 0;
-    m_data.data(&buffer, allDataReceived);
-    if (buffer)
-        *data = buffer->copy();
+    bool allDataReceived = false;
+    dataTransport->data(&buffer, &allDataReceived);
+    ASSERT(allDataReceived && buffer && buffer->data() == address);
+#endif
+    // Deref m_data now.
+    dataTransport->deref();
+}
+
+SkData* ImageFrameGenerator::refEncodedData() const
+{
+    // Every SkData instance and SharedBuffer need to keep buffer->data() refcounted.
+    // Both SkData and m_data.m_readBuffer are having separate ref counting implementations.
+    //
+    // SkData's SkData::NewWithProc is designed with similar use case in mind,
+    // unmapping wrapped shmem data once all SkData instances are disposed.
+    // in this case, sharedBufSkDataReleaseProc would just need to deref (since m_data->m_readBuffer
+    // might still hold a reference) and that is happening in sharedBufSkDataReleaseProc.
+    //
+    // Preventing m_data disposal if ImageFrameGenerator is thread safe - SkData could get disposed
+    // in any thread, and SkData would still need to hold the ref to SharedBuffer if ImageFrameGenerator
+    // is deleted. This is why full m_data (ThreadSafeRefCounted) is passed to client - to hold the
+    // reference to SharedBuffer (accompanying returned SkData). By contract in Skia's SkData,
+    // client needs to call SkData unref that would end up in sharedBufSkDataReleaseProc
+    // releasing the ref to ThreadSafeDataTransport (in thread safe way) and underlying SharedBuffer.
+    //
+    // A note about allDataReceived:
+    // SkData is returned only for full image (encoded) data downloaded. This is important since
+    // DeferredImageDecoder::setData is called only once with allDataReceived and after that
+    // m_data->m_readBuffer.data() is not changed. See also RELEASE_ASSERT used in
+    // ThreadSafeDataTransport::data().
+    SharedBuffer* buffer = 0;
+    bool allDataReceived = false;
+    m_data->data(&buffer, &allDataReceived);
+    if (!allDataReceived)
+        return nullptr;
+
+    // While SkData is holding reference to underlying data, prevent disposing m_data and its content.
+    m_data->ref();
+    return SkData::NewWithProc(buffer->data(), buffer->size(), sharedSkDataReleaseCallback, m_data.get());
 }
 
 bool ImageFrameGenerator::decodeAndScale(const SkImageInfo& info, size_t index, void* pixels, size_t rowBytes)
 {
     // This method is called to populate a discardable memory owned by Skia.
 
     // Prevents concurrent decode or scale operations on the same image data.
     MutexLocker lock(m_decodeMutex);
 
     // This implementation does not support scaling so check the requested size.
@@ skipping 39 matching lines @@
 
     TRACE_EVENT2("blink", "ImageFrameGenerator::decodeToYUV", "generator", this, "decodeCount", static_cast<int>(m_decodeCount));
 
     if (!planes || !planes[0] || !planes[1] || !planes[2]
         || !rowBytes || !rowBytes[0] || !rowBytes[1] || !rowBytes[2]) {
         return false;
     }
 
     SharedBuffer* data = 0;
     bool allDataReceived = false;
-    m_data.data(&data, &allDataReceived);
+    m_data->data(&data, &allDataReceived);
 
     // FIXME: YUV decoding does not currently support progressive decoding.
     ASSERT(allDataReceived);
 
     OwnPtr<ImageDecoder> decoder = ImageDecoder::create(*data, ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileApplied);
     if (!decoder)
         return false;
 
     decoder->setData(data, allDataReceived);
 
@@ skipping 85 matching lines @@
 }
 
 bool ImageFrameGenerator::decode(size_t index, ImageDecoder** decoder, SkBitmap* bitmap)
 {
     TRACE_EVENT2("blink", "ImageFrameGenerator::decode", "width", m_fullSize.width(), "height", m_fullSize.height());
 
     ASSERT(decoder);
     SharedBuffer* data = 0;
     bool allDataReceived = false;
     bool newDecoder = false;
-    m_data.data(&data, &allDataReceived);
+    m_data->data(&data, &allDataReceived);
 
     // Try to create an ImageDecoder if we are not given one.
     if (!*decoder) {
         newDecoder = true;
         if (m_imageDecoderFactory)
             *decoder = m_imageDecoderFactory->create().leakPtr();
 
         if (!*decoder)
             *decoder = ImageDecoder::create(*data, ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileApplied).leakPtr();
 
@@ skipping 47 matching lines @@
 }
 
 bool ImageFrameGenerator::getYUVComponentSizes(SkISize componentSizes[3])
 {
     ASSERT(componentSizes);
 
     TRACE_EVENT2("webkit", "ImageFrameGenerator::getYUVComponentSizes", "width", m_fullSize.width(), "height", m_fullSize.height());
 
     SharedBuffer* data = 0;
     bool allDataReceived = false;
-    m_data.data(&data, &allDataReceived);
+    m_data->data(&data, &allDataReceived);
 
     // FIXME: YUV decoding does not currently support progressive decoding.
     if (!allDataReceived)
         return false;
 
     OwnPtr<ImageDecoder> decoder = ImageDecoder::create(*data, ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileApplied);
     if (!decoder)
         return false;
 
     // JPEG images support YUV decoding: other decoders do not. So don't pump data into decoders
     // that always return false to updateYUVComponentSizes() requests.
     if (decoder->filenameExtension() != "jpg")
         return false;
 
     // Setting a dummy ImagePlanes object signals to the decoder that we want to do YUV decoding.
     decoder->setData(data, allDataReceived);
     OwnPtr<ImagePlanes> dummyImagePlanes = adoptPtr(new ImagePlanes);
     decoder->setImagePlanes(dummyImagePlanes.release());
 
     return updateYUVComponentSizes(decoder.get(), componentSizes, ImageDecoder::SizeForMemoryAllocation);
 }
 
 } // namespace blink