Save a bitmap copy when advancing to dependent GIF and WebP animation frames

third_party/WebKit/Source/platform/image-decoders/ImageFrame.cpp

 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) 2008, 2009 Google, Inc.
  *
  * 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 78 matching lines @@
 bool ImageFrame::copyBitmapData(const ImageFrame& other)
 {
     if (this == &other)
         return true;
 
     m_hasAlpha = other.m_hasAlpha;
     m_bitmap.reset();
     return other.m_bitmap.copyTo(&m_bitmap, other.m_bitmap.colorType());
 }
 
+bool ImageFrame::takeBitmapDataIfWritable(ImageFrame* other)
+{
+    DCHECK(other);
+    if (this == other)
+        return false;
+    if (other->m_bitmap.isImmutable())

[Peter Kasting, 2016/08/26 19:04:04]

Nit: Just combine these conditionals

[aleksandar.stojiljkovic, 2016/08/26 21:53:51]

Done.

+        return false;
+    m_hasAlpha = other->m_hasAlpha;
+    m_bitmap.reset();
+    m_bitmap.swap(other->m_bitmap);
+    other->m_status = FrameEmpty;
+    return true;
+}
+
 bool ImageFrame::setSizeAndColorProfile(int newWidth, int newHeight, const ICCProfile& newIccProfile)
 {
     // setSizeAndColorProfile() should only be called once, it leaks memory otherwise.
     ASSERT(!width() && !height());
 
     sk_sp<SkColorSpace> colorSpace;
     if (RuntimeEnabledFeatures::colorCorrectRenderingEnabled() && !newIccProfile.isEmpty())
         colorSpace = SkColorSpace::NewICC(newIccProfile.data(), newIccProfile.size());
 
     m_bitmap.setInfo(SkImageInfo::MakeN32(newWidth, newHeight,
         m_premultiplyAlpha ? kPremul_SkAlphaType : kUnpremul_SkAlphaType, colorSpace));
     if (!m_bitmap.tryAllocPixels(m_allocator, 0))
         return false;
 
     zeroFillPixelData();
     return true;
 }
 
 bool ImageFrame::hasAlpha() const
 {
     return m_hasAlpha;
 }
 
+const SkBitmap& ImageFrame::bitmap(bool setImmutableIfDone)

[aleksandar.stojiljkovic, 2016/08/26 18:53:41]

pkasting@
The fix for the failing tests is simpler than anticipated:
- ImageFrameGenerator is the only customer of ImageFrame::bitmap() in cases
referred from the bugs listed here. ImageFrameGenerator doesn't increase ref
count (it just calls getPixels) and it is not interested if bitmap is mutable or
not... When decoder and ImageFrame are used by ImageFrameGenerator, there is no
need to get the bitmap immutable flag set (to call setImmutable). 

The other clients of ImageFrame::bitmap() are kept the same - setImmutable is
deferred and set when client makes a request to access bitmap via
ImageFrame::bitmap(bool setImmutableIfDone = true).

+{
+    if (m_status == FrameComplete && setImmutableIfDone && !m_bitmap.isImmutable()) {
+        // We don't set the status to immutable until there is a request to
+        // access the bitmap.  This is because mutable bitmap can be reused as
+        // the next frame by calling takeBitmapDataIfWritable.
+        m_bitmap.setImmutable();
+    }
+    return m_bitmap;
+}
+
 void ImageFrame::setHasAlpha(bool alpha)
 {
     m_hasAlpha = alpha;
 
     m_bitmap.setAlphaType(computeAlphaType());
 }
 
 void ImageFrame::setStatus(Status status)
 {
     m_status = status;
     if (m_status == FrameComplete) {
         m_bitmap.setAlphaType(computeAlphaType());
         // Send pending pixels changed notifications now, because we can't do this after
         // the bitmap has been marked immutable.
         notifyBitmapIfPixelsChanged();
-        m_bitmap.setImmutable(); // Tell the bitmap it's done.
     }
 }
 
 void ImageFrame::zeroFillFrameRect(const IntRect& rect)
 {
     if (rect.isEmpty())
         return;
 
     m_bitmap.eraseArea(rect, SkColorSetARGB(0, 0, 0, 0));
     setHasAlpha(true);
 }
 
 SkAlphaType ImageFrame::computeAlphaType() const
 {
     // If the frame is not fully loaded, there will be transparent pixels,
     // so we can't tell skia we're opaque, even for image types that logically
     // always are (e.g. jpeg).
     if (!m_hasAlpha && m_status == FrameComplete)
         return kOpaque_SkAlphaType;
 
     return m_premultiplyAlpha ? kPremul_SkAlphaType : kUnpremul_SkAlphaType;
 }
 
 } // namespace blink