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& color_behavior,
                                  size_t max_decoded_bytes,
                                  size_t offset)
     : ImageDecoder(alpha_option, color_behavior, max_decoded_bytes),
       offset_(offset),
       current_frame_(0),
       // It would be logical to default to kAnimationNone, but BitmapImage uses
       // that as a signal to never check again, meaning the actual count will
       // never be respected.
       repetition_count_(kAnimationLoopOnce),
-      has_alpha_channel_(false),
-      current_buffer_saw_alpha_(false) {}
+      has_alpha_channel_(false) {}
 
 PNGImageDecoder::~PNGImageDecoder() {}
 
 bool PNGImageDecoder::SetFailed() {
   reader_.reset();
   return ImageDecoder::SetFailed();
 }
 
 size_t PNGImageDecoder::DecodeFrameCount() {
   Parse(ParseQuery::kMetaData);
@@ skipping 225 matching lines @@
 
     if (PNG_INTERLACE_ADAM7 ==
         png_get_interlace_type(png, reader_->InfoPtr())) {
       unsigned color_channels = has_alpha_channel_ ? 4 : 3;
       reader_->CreateInterlaceBuffer(color_channels * Size().Area());
       if (!reader_->InterlaceBuffer()) {
         longjmp(JMPBUF(png), 1);
         return;
       }
     }
-
-    current_buffer_saw_alpha_ = false;
   }
 
   const IntRect& frame_rect = buffer.OriginalFrameRect();
   DCHECK(IntRect(IntPoint(), Size()).Contains(frame_rect));
 
   /* 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 color_format =
           SkColorSpaceXform::kRGBA_8888_ColorFormat;
       xform->apply(color_format, dst_row, color_format, src_ptr, width,
                    kUnpremul_SkAlphaType);
       src_ptr = png_bytep(dst_row);
     }
 
-    unsigned alpha_mask = 255;
     if (frame_buffer_cache_[current_frame_].GetAlphaBlendSource() ==
         ImageFrame::kBlendAtopBgcolor) {
       if (buffer.PremultiplyAlpha()) {
         for (auto *dst_pixel = dst_row; dst_pixel < dst_row + width;
              dst_pixel++, src_ptr += 4) {
           ImageFrame::SetRGBAPremultiply(dst_pixel, src_ptr[0], src_ptr[1],
                                          src_ptr[2], src_ptr[3]);
-          alpha_mask &= src_ptr[3];
         }
       } else {
         for (auto *dst_pixel = dst_row; dst_pixel < dst_row + width;
              dst_pixel++, src_ptr += 4) {
           ImageFrame::SetRGBARaw(dst_pixel, src_ptr[0], src_ptr[1], src_ptr[2],
                                  src_ptr[3]);
-          alpha_mask &= src_ptr[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 |src_ptr|, over the previous
       // pixel stored in |dst_pixel|.
       if (buffer.PremultiplyAlpha()) {
         for (auto *dst_pixel = dst_row; dst_pixel < dst_row + width;
              dst_pixel++, src_ptr += 4) {
           ImageFrame::BlendRGBAPremultiplied(dst_pixel, src_ptr[0], src_ptr[1],
                                              src_ptr[2], src_ptr[3]);
-          alpha_mask &= src_ptr[3];
         }
       } else {
         for (auto *dst_pixel = dst_row; dst_pixel < dst_row + width;
              dst_pixel++, src_ptr += 4) {
           ImageFrame::BlendRGBARaw(dst_pixel, src_ptr[0], src_ptr[1],
                                    src_ptr[2], src_ptr[3]);
-          alpha_mask &= src_ptr[3];
         }
       }
     }
-
-    if (alpha_mask != 255)
-      current_buffer_saw_alpha_ = true;
-
   } else {
     for (auto *dst_pixel = dst_row; dst_pixel < dst_row + width;
          src_ptr += 3, ++dst_pixel) {
       ImageFrame::SetRGBARaw(dst_pixel, src_ptr[0], src_ptr[1], src_ptr[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).
@@ skipping 12 matching lines @@
 
   if (reader_->InterlaceBuffer())
     reader_->ClearInterlaceBuffer();
 
   ImageFrame& buffer = frame_buffer_cache_[current_frame_];
   if (buffer.GetStatus() == ImageFrame::kFrameEmpty) {
     longjmp(JMPBUF(reader_->PngPtr()), 1);
     return;
   }
 
-  if (!current_buffer_saw_alpha_)
-    CorrectAlphaWhenFrameBufferSawNoAlpha(current_frame_);
-
   buffer.SetStatus(ImageFrame::kFrameComplete);
 }
 
 bool PNGImageDecoder::FrameIsCompleteAtIndex(size_t index) const {
   if (!IsDecodedSizeAvailable())
     return false;
 
   DCHECK(!Failed() && 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 (reader_->ParseCompleted() && reader_->FrameCount() == 1)
     return ImageDecoder::FrameIsCompleteAtIndex(index);
 
   return reader_->FrameIsReceivedAtIndex(index);
 }
 
 float PNGImageDecoder::FrameDurationAtIndex(size_t index) const {
   if (index < frame_buffer_cache_.size())
     return frame_buffer_cache_[index].Duration();
   return 0;
 }
 
 }  // namespace blink