Eliminate copies of encoded image data

third_party/WebKit/Source/platform/image-decoders/ImageDecoder.h

 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) Research In Motion Limited 2009-2010. 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
@@ skipping 11 matching lines @@
  * 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.
  */
 
 #ifndef ImageDecoder_h
 #define ImageDecoder_h
 
 #include "SkColorPriv.h"
 #include "platform/PlatformExport.h"
-#include "platform/SharedBuffer.h"
 #include "platform/graphics/ImageOrientation.h"
 #include "platform/image-decoders/ImageAnimation.h"
 #include "platform/image-decoders/ImageFrame.h"
+#include "platform/image-decoders/SegmentReader.h"
 #include "public/platform/Platform.h"
 #include "wtf/Assertions.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Threading.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 
 #if USE(QCMSLIB)
 #include "qcms.h"
@@ skipping 46 matching lines @@
         , m_sizeAvailable(false)
         , m_isAllDataReceived(false)
         , m_failed(false) { }
 
     virtual ~ImageDecoder() { }
 
     // Returns a caller-owned decoder of the appropriate type.  Returns 0 if
     // we can't sniff a supported type from the provided data (possibly
     // because there isn't enough data yet).
     // Sets m_maxDecodedBytes to Platform::maxImageDecodedBytes().
-    static PassOwnPtr<ImageDecoder> create(const SharedBuffer& data, AlphaOption, GammaAndColorProfileOption);
+    static PassOwnPtr<ImageDecoder> create(const SegmentReader& data, AlphaOption, GammaAndColorProfileOption);
 
     virtual String filenameExtension() const = 0;
 
     bool isAllDataReceived() const { return m_isAllDataReceived; }
 
-    void setData(SharedBuffer* data, bool allDataReceived)
+    void setData(SegmentReader* data, bool allDataReceived)

[Peter Kasting, 2016/03/23 02:42:59]

This takes ownership from the caller.  It should either be passed via PassRefPtr
or by value with the caller doing std::move(), whichever way common WebKit style
is these days.  (Chromium style would be the latter.)

[f(malita), 2016/03/23 16:41:58]

+1

Not new to this CL, but setData should take a PassRefPtr<SegmentReader>.

[scroggo_chromium, 2016/03/24 13:59:45]

Since my CL did not introduce this pattern, do you mind if I leave that until a
follow-on?

[f(malita), 2016/03/24 16:48:37]

Yeah, we should do that separately.

     {
         if (m_failed)
             return;
         m_data = data;
         m_isAllDataReceived = allDataReceived;
         onSetData(data);
     }
 
-    virtual void onSetData(SharedBuffer* data) { }
+    virtual void onSetData(SegmentReader* data) { }
 
     bool isSizeAvailable()
     {
         if (m_failed)
             return false;
         if (!m_sizeAvailable)
             decodeSize();
         return isDecodedSizeAvailable();
     }
 
@@ skipping 199 matching lines @@
     // returns that number.
     virtual size_t decodeFrameCount() { return 1; }
 
     // Performs any additional setup of the requested frame after it has been
     // initially created, e.g. setting a duration or disposal method.
     virtual void initializeNewFrame(size_t) { }
 
     // Decodes the requested frame.
     virtual void decode(size_t) = 0;
 
-    RefPtr<SharedBuffer> m_data; // The encoded data.
+    RefPtr<SegmentReader> m_data; // The encoded data.
     Vector<ImageFrame, 1> m_frameBufferCache;
     bool m_premultiplyAlpha;
     bool m_ignoreGammaAndColorProfile;
     ImageOrientation m_orientation;
 
     // The maximum amount of memory a decoded image should require. Ideally,
     // image decoders should downsample large images to fit under this limit
     // (and then return the downsampled size from decodedSize()). Ignoring
     // this limit can cause excessive memory use or even crashes on low-
     // memory devices.
@@ skipping 11 matching lines @@
 
     IntSize m_size;
     bool m_sizeAvailable;
     bool m_isAllDataReceived;
     bool m_failed;
 };
 
 } // namespace blink
 
 #endif