Eliminate copies of encoded image data

third_party/WebKit/Source/platform/image-decoders/jpeg/JPEGImageDecoder.cpp

 /*
  * Copyright (C) 2006 Apple Computer, Inc.
  *
  * Portions are Copyright (C) 2001-6 mozilla.org
  *
  * Other contributors:
  *   Stuart Parmenter <stuart@mozilla.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ skipping 343 matching lines @@
         }
 
         m_nextReadPosition += bytes;
         m_info.src->bytes_in_buffer = bytes;
         const JOCTET* nextByte = reinterpret_cast_ptr<const JOCTET*>(segment);
         m_info.src->next_input_byte = nextByte;
         m_lastSetByte = nextByte;
         return true;
     }
 
-    void setData(SharedBuffer* data)
+    void setData(SegmentReader* data)
     {
         if (m_data.get() == data)
             return;
 
         m_data = data;
 
-        // If a restart is needed, the next call to fillBuffer will read from the new SharedBuffer.
+        // If a restart is needed, the next call to fillBuffer will read from the new SegmentReader.
         if (m_needsRestart)
             return;
 
         // Otherwise, empty the buffer, and leave the position the same, so fillBuffer continues
-        // reading from the same position in the new SharedBuffer.
+        // reading from the same position in the new SegmentReader.
         m_nextReadPosition -= m_info.src->bytes_in_buffer;
         clearBuffer();
     }
 
     bool decode(bool onlySize)
     {
         // We need to do the setjmp here. Otherwise bad things will happen
         if (setjmp(m_err.setjmp_buffer))
             return m_decoder->setFailed();
 
@@ skipping 243 matching lines @@
     }
 
     void clearBuffer()
     {
         // Let libjpeg know that the buffer needs to be refilled.
         m_info.src->bytes_in_buffer = 0;
         m_info.src->next_input_byte = nullptr;
         m_lastSetByte = nullptr;
     }
 
-    RefPtr<SharedBuffer> m_data;
+    RefPtr<SegmentReader> m_data;
     JPEGImageDecoder* m_decoder;
 
     // Input reading: True if we need to back up to m_restartPosition.
     bool m_needsRestart;
     // If libjpeg needed to restart, this is the position to restart from.
     size_t m_restartPosition;
     // This is the position where we will read from, unless there is a restart.
     size_t m_nextReadPosition;
     // This is how we know to update the restart position. It is the last value
     // we set to next_input_byte. libjpeg will update next_input_byte when it
@@ skipping 65 matching lines @@
     if (!ImageDecoder::setSize(width, height))
         return false;
 
     if (!desiredScaleNumerator())
         return setFailed();
 
     setDecodedSize(width, height);
     return true;
 }
 
-void JPEGImageDecoder::onSetData(SharedBuffer* data)
+void JPEGImageDecoder::onSetData(SegmentReader* data)
 {
     if (m_reader)
         m_reader->setData(data);
 }
 
 void JPEGImageDecoder::setDecodedSize(unsigned width, unsigned height)
 {
     m_decodedSize = IntSize(width, height);
 }
 
@@ skipping 251 matching lines @@
     // has failed.
     if (!m_reader->decode(onlySize) && isAllDataReceived())
         setFailed();
 
     // If decoding is done or failed, we don't need the JPEGImageReader anymore.
     if (isComplete(this, onlySize) || failed())
         m_reader.clear();
 }
 
 } // namespace blink