Remove opaque alpha channel special case

third_party/WebKit/Source/platform/image-decoders/png/PNGImageDecoder.cpp

 /*
  * Copyright (C) 2006 Apple Computer, Inc.
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  * Portions are Copyright (C) 2001 mozilla.org
  *
  * Other contributors:
  *   Stuart Parmenter <stuart@mozilla.com>
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 33 matching lines @@
                                  const ColorBehavior& colorBehavior,
                                  size_t maxDecodedBytes,
                                  size_t offset)
     : ImageDecoder(alphaOption, colorBehavior, maxDecodedBytes),
       m_offset(offset),
       m_currentFrame(0),
       // It would be logical to default to cAnimationNone, but BitmapImage uses
       // that as a signal to never check again, meaning the actual count will
       // never be respected.
       m_repetitionCount(cAnimationLoopOnce),
-      m_hasAlphaChannel(false),
-      m_currentBufferSawAlpha(false) {}
+      m_hasAlphaChannel(false) {}
 
 PNGImageDecoder::~PNGImageDecoder() {}
 
 bool PNGImageDecoder::setFailed() {
   m_reader.reset();
   return ImageDecoder::setFailed();
 }
 
 size_t PNGImageDecoder::decodeFrameCount() {
   parse(ParseQuery::MetaData);
@@ skipping 227 matching lines @@
 
     if (PNG_INTERLACE_ADAM7 ==
         png_get_interlace_type(png, m_reader->infoPtr())) {
       unsigned colorChannels = m_hasAlphaChannel ? 4 : 3;
       m_reader->createInterlaceBuffer(colorChannels * size().area());
       if (!m_reader->interlaceBuffer()) {
         longjmp(JMPBUF(png), 1);
         return;
       }
     }
-
-    m_currentBufferSawAlpha = false;
   }
 
   const IntRect& frameRect = buffer.originalFrameRect();
   DCHECK(IntRect(IntPoint(), size()).contains(frameRect));
 
   /* libpng comments (here to explain what follows).
    *
    * this function is called for every row in the image. If the
    * image is interlacing, and you turned on the interlace handler,
    * this function will be called for every row in every pass.
@@ skipping 67 matching lines @@
     // where R, G, and/or B are greater than A.  The legacy drawing
     // pipeline does not know how to handle this.
     if (SkColorSpaceXform* xform = colorTransform()) {
       SkColorSpaceXform::ColorFormat colorFormat =
           SkColorSpaceXform::kRGBA_8888_ColorFormat;
       xform->apply(colorFormat, dstRow, colorFormat, srcPtr, size().width(),
                    kUnpremul_SkAlphaType);
       srcPtr = png_bytep(dstRow);
     }
 
-    unsigned alphaMask = 255;
     if (m_frameBufferCache[m_currentFrame].getAlphaBlendSource() ==
         ImageFrame::BlendAtopBgcolor) {
       if (buffer.premultiplyAlpha()) {
         for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
              dstPixel++, srcPtr += 4) {
           buffer.setRGBAPremultiply(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2],
                                     srcPtr[3]);
-          alphaMask &= srcPtr[3];
         }
       } else {
         for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
              dstPixel++, srcPtr += 4) {
           buffer.setRGBARaw(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2],
                             srcPtr[3]);
-          alphaMask &= srcPtr[3];
         }
       }
     } else {
       // Now, the blend method is ImageFrame::BlendAtopPreviousFrame. Since the
       // frame data of the previous frame is copied at initFrameBuffer, we can
       // blend the pixel of this frame, stored in |srcPtr|, over the previous
       // pixel stored in |dstPixel|.
       if (buffer.premultiplyAlpha()) {
         for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
              dstPixel++, srcPtr += 4) {
           buffer.blendRGBAPremultiplied(dstPixel, srcPtr[0], srcPtr[1],
                                         srcPtr[2], srcPtr[3]);
-          alphaMask &= srcPtr[3];
         }
       } else {
         for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
              dstPixel++, srcPtr += 4) {
           buffer.blendRGBARaw(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2],
                               srcPtr[3]);
-          alphaMask &= srcPtr[3];
         }
       }
     }
-
-    if (alphaMask != 255)
-      m_currentBufferSawAlpha = true;
-
   } else {
     for (auto *dstPixel = dstRow; dstPixel < dstRow + width;
          srcPtr += 3, ++dstPixel) {
       buffer.setRGBARaw(dstPixel, srcPtr[0], srcPtr[1], srcPtr[2], 255);
     }
 
     // We'll apply the color space xform to opaque pixels after they have been
     // written to the ImageFrame, purely because SkColorSpaceXform supports
     // RGBA (and not RGB).
     if (SkColorSpaceXform* xform = colorTransform()) {
@@ skipping 11 matching lines @@
 
   if (m_reader->interlaceBuffer())
     m_reader->clearInterlaceBuffer();
 
   ImageFrame& buffer = m_frameBufferCache[m_currentFrame];
   if (buffer.getStatus() == ImageFrame::FrameEmpty) {
     longjmp(JMPBUF(m_reader->pngPtr()), 1);
     return;
   }
 
-  if (!m_currentBufferSawAlpha)
-    correctAlphaWhenFrameBufferSawNoAlpha(m_currentFrame);
-
   buffer.setStatus(ImageFrame::FrameComplete);
 }
 
 bool PNGImageDecoder::frameIsCompleteAtIndex(size_t index) const {
   if (!isDecodedSizeAvailable())
     return false;
 
   DCHECK(!failed() && m_reader);
 
   // For non-animated images, return whether the status of the frame is
   // ImageFrame::FrameComplete with ImageDecoder::frameIsCompleteAtIndex.
   // This matches the behavior of WEBPImageDecoder.
   if (m_reader->parseCompleted() && m_reader->frameCount() == 1)
     return ImageDecoder::frameIsCompleteAtIndex(index);
 
   return m_reader->frameIsReceivedAtIndex(index);
 }
 
 float PNGImageDecoder::frameDurationAtIndex(size_t index) const {
   if (index < m_frameBufferCache.size())
     return m_frameBufferCache[index].duration();
   return 0;
 }
 
 }  // namespace blink