Write transparent pixels more often (SkGifCodec)

src/codec/SkGifCodec.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  *
@@ skipping 275 matching lines @@
     if (firstAttempt) {
         // rowsDecoded reports how many rows have been initialized, so a layer above
         // can fill the rest. In some cases, we fill the background before decoding
         // (or it is already filled for us), so we report rowsDecoded to be the full
         // height.
         bool filledBackground = false;
         if (frameContext->getRequiredFrame() == kNone) {
             // We may need to clear to transparent for one of the following reasons:
             // - The frameRect does not cover the full bounds. haveDecodedRow will
             //   only draw inside the frameRect, so we need to clear the rest.
-            // - There is a valid transparent pixel value. (FIXME: I'm assuming
-            //   writeTransparentPixels will be false in this case, based on
-            //   Chromium's assumption that it would already be zeroed. If we
-            //   change that behavior, could we skip Filling here?)
             // - The frame is interlaced. There is no obvious way to fill
             //   afterwards for an incomplete image. (FIXME: Does the first pass
             //   cover all rows? If so, we do not have to fill here.)
             // - There is no color table for this frame. In that case will not
             //   draw anything, so we need to fill.
             if (frameContext->frameRect() != this->getInfo().bounds()
-                    || frameContext->transparentPixel() < SK_MAX_COLORS
                     || frameContext->interlaced() || !fCurrColorTableIsReal) {
                 // fill ignores the width (replaces it with the actual, scaled width).
                 // But we need to scale in Y.
                 const int scaledHeight = get_scaled_dimension(dstInfo.height(),
                                                               fSwizzler->sampleY());
                 auto fillInfo = dstInfo.makeWH(0, scaledHeight);
                 fSwizzler->fill(fillInfo, fDst, fDstRowBytes, this->getFillValue(dstInfo),
                                 opts.fZeroInitialized);
                 filledBackground = true;
             }
@@ skipping 165 matching lines @@
     if (!fCurrColorTableIsReal) {
         // No color table, so nothing to draw this frame.
         // FIXME: We can abort even earlier - no need to decode this frame.
         return true;
     }
 
     // The swizzler takes care of offsetting into the dst width-wise.
     void* dstLine = SkTAddOffset<void>(fDst, dstRow * fDstRowBytes);
 
     // We may or may not need to write transparent pixels to the buffer.
-    // If we're compositing against a previous image, it's wrong, and if
-    // we're writing atop a cleared, fully transparent buffer, it's
-    // unnecessary; but if we're decoding an interlaced gif and
-    // displaying it "Haeberli"-style, we must write these for passes
-    // beyond the first, or the initial passes will "show through" the
-    // later ones.
+    // If we're compositing against a previous image, it's wrong, but if
+    // we're decoding an interlaced gif and displaying it "Haeberli"-style,
+    // we must write these for passes beyond the first, or the initial passes
+    // will "show through" the later ones.
     const auto dstInfo = this->dstInfo();
     if (writeTransparentPixels || dstInfo.colorType() == kRGB_565_SkColorType) {
         fSwizzler->swizzle(dstLine, rowBegin);
     } else {
         // We cannot swizzle directly into the dst, since that will write the transparent pixels.
         // Instead, swizzle into a temporary buffer, and copy that into the dst.
         {
             void* const memsetDst = fTmpBuffer.get();
             // Although onGetFillValue returns a uint64_t, we only use the low eight bits. The
             // return value is either an 8 bit index (for index8) or SK_ColorTRANSPARENT, which is
@@ skipping 54 matching lines @@
         void* copiedLine = SkTAddOffset<void>(dstLine, fSwizzler->swizzleOffsetBytes());
         void* dst = copiedLine;
         for (unsigned i = 1; i < repeatCount; i++) {
             dst = SkTAddOffset<void>(dst, fDstRowBytes);
             memcpy(dst, copiedLine, bytesToCopy);
         }
     }
 
     return true;
 }