High CPU and increased memory usage fix for high-res (GIF, WEBP...) animations.

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
  *    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 "platform/graphics/DeferredImageDecoder.h"
 
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/DecodingImageGenerator.h"
-#include "platform/graphics/FrameData.h"
 #include "platform/graphics/ImageDecodingStore.h"
 #include "platform/graphics/ImageFrameGenerator.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "wtf/PassOwnPtr.h"
 
 namespace blink {
 
+struct DeferredFrameData {

[Peter Kasting, 2016/04/28 23:07:55]

This probably needs comments about why you can't use FrameData (maybe leaving
some fields uninitialized?) and how you selected which fields to preserve.

Furthermore, it seems like FrameData is pretty much only used by BitmapImage
after this change, in which case I'd consider moving it to BitmapImage.cpp.

[aleksandar.stojiljkovic, 2016/04/29 17:17:43]

After second patch these two diverged further -  DeferredFrameData got uniqueID
and FrameData has 2 flag fields that DeferredFrameData doesn't need.
Didn't move FrameData to BitmapFrame.cpp as it is used from BitmapImageTest.cpp
too. 

+    DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
+    WTF_MAKE_NONCOPYABLE(DeferredFrameData);
+public:
+    DeferredFrameData()
+        : m_orientation(DefaultImageOrientation)
+        , m_duration(0)
+        , m_isComplete(false)
+        , m_frameBytes(0)
+    {}
+
+    ImageOrientation m_orientation;
+    float m_duration;
+    bool m_isComplete : 1;
+    size_t m_frameBytes;
+};
+
 bool DeferredImageDecoder::s_enabled = true;
 
 PassOwnPtr<DeferredImageDecoder> DeferredImageDecoder::create(const SharedBuffer& data, ImageDecoder::AlphaOption alphaOption, ImageDecoder::GammaAndColorProfileOption colorOptions)
 {
     OwnPtr<ImageDecoder> actualDecoder = ImageDecoder::create(data, alphaOption, colorOptions);
 
     if (!actualDecoder)
         return nullptr;
 
     return adoptPtr(new DeferredImageDecoder(actualDecoder.release()));
@@ skipping 34 matching lines @@
 }
 
 PassRefPtr<SkImage> DeferredImageDecoder::createFrameAtIndex(size_t index)
 {
     if (m_frameGenerator && m_frameGenerator->decodeFailed())
         return nullptr;
 
     prepareLazyDecodedFrames();
 
     if (index < m_frameData.size()) {
-        FrameData* frameData = &m_frameData[index];
-        // ImageFrameGenerator has the latest known alpha state. There will be a
-        // performance boost if this frame is opaque.
-        ASSERT(m_frameGenerator);
-        frameData->m_hasAlpha = m_frameGenerator->hasAlpha(index);
+        DeferredFrameData* frameData = &m_frameData[index];
         if (m_actualDecoder)
             frameData->m_frameBytes = m_actualDecoder->frameBytesAtIndex(index);
         else
             frameData->m_frameBytes = m_size.area() * sizeof(ImageFrame::PixelData);
-        return createFrameImageAtIndex(index, !frameData->m_hasAlpha);
+        // ImageFrameGenerator has the latest known alpha state. There will be a
+        // performance boost if this frame is opaque.
+        ASSERT(m_frameGenerator);
+        return createFrameImageAtIndex(index, !m_frameGenerator->hasAlpha(index));
     }
 
     if (!m_actualDecoder || m_actualDecoder->failed())
         return nullptr;
 
     ImageFrame* frame = m_actualDecoder->frameBufferAtIndex(index);
     if (!frame || frame->getStatus() == ImageFrame::FrameEmpty)
         return nullptr;
 
     return adoptRef(SkImage::NewFromBitmap(frame->bitmap()));
@@ skipping 132 matching lines @@
     activateLazyDecoding();
 
     const size_t previousSize = m_frameData.size();
     m_frameData.resize(m_actualDecoder->frameCount());
 
     // We have encountered a broken image file. Simply bail.
     if (m_frameData.size() < previousSize)
         return;
 
     for (size_t i = previousSize; i < m_frameData.size(); ++i) {
-        m_frameData[i].m_haveMetadata = true;
         m_frameData[i].m_duration = m_actualDecoder->frameDurationAtIndex(i);
         m_frameData[i].m_orientation = m_actualDecoder->orientation();
         m_frameData[i].m_isComplete = m_actualDecoder->frameIsCompleteAtIndex(i);
     }
 
     // The last lazy decoded frame created from previous call might be
     // incomplete so update its state.
     if (previousSize) {
         const size_t lastFrame = previousSize - 1;
         m_frameData[lastFrame].m_isComplete = m_actualDecoder->frameIsCompleteAtIndex(lastFrame);
@@ skipping 28 matching lines @@
     return image.release();
 }
 
 bool DeferredImageDecoder::hotSpot(IntPoint& hotSpot) const
 {
     // TODO: Implement.
     return m_actualDecoder ? m_actualDecoder->hotSpot(hotSpot) : false;
 }
 
 } // 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.
+};
+}