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 197 matching lines @@
 
   // Tell libpng to send us rows for interlaced pngs.
   if (interlace_type == PNG_INTERLACE_ADAM7)
     png_set_interlace_handling(png);
 
   // Update our info now (so we can get color channel info).
   png_read_update_info(png, info);
 
   int channels = png_get_channels(png, info);
   DCHECK(channels == 3 || channels == 4);
   has_alpha_channel_ = (channels == 4);

[scroggo_chromium, 2017/05/31 14:27:50]

if channels == 3, we know that the image is opaque.

[cblume, 2017/05/31 21:05:29]

Just checking -- you aren't pointing this out as something you want me to
change, right?

Right now it looks like the constructor and this line are the only lines that
set has_alpha_channel_.
So this is now the critical line that determines if we report alpha or not.

The now-removed current_buffer_saw_alpha_ used to also influence whether we
reported alpha or not.

[scroggo_chromium, 2017/06/01 12:14:07]

I don't want you to change it, but I thought we might take advantage of it. Now
that you've removed current_buffer_saw_alpha_, we never report that the image is
opaque. But we could:

  if (!has_alpha_channel_) {
    buffer.SetHasAlpha(false);
  }

(It's a little more complex than that - you'll need to consider any frames that
it blends with. Same for GIF, although SkGifCodec already considers this.)

This assumes that there's an advantage to marking the image as opaque, which
isn't clear from your timing data.

 }
 
 void PNGImageDecoder::RowAvailable(unsigned char* row_buffer,
                                    unsigned row_index,
                                    int) {
   if (current_frame_ >= frame_buffer_cache_.size())
     return;
 
   ImageFrame& buffer = frame_buffer_cache_[current_frame_];
   if (buffer.GetStatus() == ImageFrame::kFrameEmpty) {
     png_structp png = reader_->PngPtr();
     if (!InitFrameBuffer(current_frame_)) {
       longjmp(JMPBUF(png), 1);
       return;
     }
 
     DCHECK_EQ(ImageFrame::kFramePartial, buffer.GetStatus());
 
     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