Refactor ImageDecoder factories

third_party/WebKit/Source/platform/graphics/DeferredImageDecoder.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
@@ skipping 39 matching lines @@
         , m_uniqueID(DecodingImageGenerator::kNeedNewImageUniqueID)
     {}
 
     ImageOrientation m_orientation;
     float m_duration;
     bool m_isComplete;
     size_t m_frameBytes;
     uint32_t m_uniqueID;
 };
 
-std::unique_ptr<DeferredImageDecoder> DeferredImageDecoder::create(ImageDecoder::SniffResult sniffResult, ImageDecoder::AlphaOption alphaOption, ImageDecoder::GammaAndColorProfileOption colorOptions)
+std::unique_ptr<DeferredImageDecoder> DeferredImageDecoder::create(PassRefPtr<SharedBuffer> passData,
+    bool dataComplete, ImageDecoder::AlphaOption alphaOption, ImageDecoder::GammaAndColorProfileOption colorOptions)
 {
-    std::unique_ptr<ImageDecoder> actualDecoder = ImageDecoder::create(sniffResult, alphaOption, colorOptions);
+    RefPtr<SharedBuffer> data = passData;
+
+    std::unique_ptr<ImageDecoder> actualDecoder = ImageDecoder::create(data, dataComplete, alphaOption, colorOptions);
 
     if (!actualDecoder)
         return nullptr;
 
-    return wrapUnique(new DeferredImageDecoder(std::move(actualDecoder)));
+    std::unique_ptr<DeferredImageDecoder> decoder = wrapUnique(new DeferredImageDecoder(std::move(actualDecoder)));

[Peter Kasting, 2016/08/19 23:04:58]

Nit: Seems like the wrapUnique() call here doesn't buy us anything (just
construct |decoder| directly)

[f(malita), 2016/08/22 01:51:15]

Done.

+
+    // Since we've just instantiated a fresh decoder, there's no need to reset its data.
+    decoder->setDataInternal(data.release(), dataComplete, false);
+
+    return decoder;
 }
 
 std::unique_ptr<DeferredImageDecoder> DeferredImageDecoder::createForTesting(std::unique_ptr<ImageDecoder> actualDecoder)
 {
     return wrapUnique(new DeferredImageDecoder(std::move(actualDecoder)));
 }
 
 DeferredImageDecoder::DeferredImageDecoder(std::unique_ptr<ImageDecoder> actualDecoder)
     : m_allDataReceived(false)
     , m_actualDecoder(std::move(actualDecoder))
@@ skipping 48 matching lines @@
         return nullptr;
     RefPtr<SkROBuffer> roBuffer = adoptRef(m_rwBuffer->newRBufferSnapshot());
     RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create();
     SkROBuffer::Iter it(roBuffer.get());
     do {
         sharedBuffer->append(static_cast<const char*>(it.data()), it.size());
     } while (it.next());
     return sharedBuffer.release();
 }
 
-void DeferredImageDecoder::setData(SharedBuffer& data, bool allDataReceived)
+void DeferredImageDecoder::setData(PassRefPtr<SharedBuffer> data, bool allDataReceived)
 {
+    setDataInternal(data, allDataReceived, true);
+}
+
+void DeferredImageDecoder::setDataInternal(PassRefPtr<SharedBuffer> passData, bool allDataReceived, bool pushDataToDecoder)
+{
+    RefPtr<SharedBuffer> data = passData;
     if (m_actualDecoder) {
         m_allDataReceived = allDataReceived;
-        m_actualDecoder->setData(&data, allDataReceived);
+        if (pushDataToDecoder)
+            m_actualDecoder->setData(data, allDataReceived);
         prepareLazyDecodedFrames();
     }
 
     if (m_frameGenerator) {
         if (!m_rwBuffer)
-            m_rwBuffer = wrapUnique(new SkRWBuffer(data.size()));
+            m_rwBuffer = wrapUnique(new SkRWBuffer(data->size()));
 
         const char* segment = 0;
-        for (size_t length = data.getSomeData(segment, m_rwBuffer->size());
-            length; length = data.getSomeData(segment, m_rwBuffer->size())) {
+        for (size_t length = data->getSomeData(segment, m_rwBuffer->size());
+            length; length = data->getSomeData(segment, m_rwBuffer->size())) {
             m_rwBuffer->append(segment, length);
         }
     }
 }
 
 bool DeferredImageDecoder::isSizeAvailable()
 {
     // m_actualDecoder is 0 only if image decoding is deferred and that means
     // the image header decoded successfully and the size is available.
     return m_actualDecoder ? m_actualDecoder->isSizeAvailable() : true;
@@ skipping 178 matching lines @@
 }
 
 } // namespace blink
 
 namespace WTF {
 template<> struct VectorTraits<blink::DeferredFrameData> : public SimpleClassVectorTraits<blink::DeferredFrameData> {
     STATIC_ONLY(VectorTraits);
     static const bool canInitializeWithMemset = false; // Not all DeferredFrameData members initialize to 0.
 };
 }