Pass the destination pointer to next

src/codec/SkCodec_libgif.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.
  */
 
 #include "SkCodec_libgif.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 410 matching lines @@
 
                     // Modify the destination info
                     const SkImageInfo subsetDstInfo =
                             dstInfo.makeWH(innerWidth, innerHeight);
 
                     // Fill the destination with the fill color
                     // FIXME: This may not be the behavior that we want for
                     //        animated gifs where we draw on top of the
                     //        previous frame.
                     if (!skipBackground) {
-                        SkSwizzler::Fill(dst, dstInfo, dstRowBytes, height, fillIndex, colorTable);
+                        SkSwizzler::Fill(dst, dstInfo, dstRowBytes, height,
+                                fillIndex, colorTable);
                     }
 
                     // Modify the dst pointer
                     const int32_t dstBytesPerPixel =
                             SkColorTypeBytesPerPixel(dstColorType);
-                    void* subsetDst = SkTAddOffset<void*>(dst,
+                    dst = SkTAddOffset<void*>(dst,
                             dstRowBytes * imageTop +
                             dstBytesPerPixel * imageLeft);
 
                     // Create the subset swizzler
                     swizzler.reset(SkSwizzler::CreateSwizzler(
                             SkSwizzler::kIndex, colorTable, subsetDstInfo,
-                            subsetDst, dstRowBytes, zeroInit));
+                            zeroInit));
                 } else {
                     // Create the fully dimensional swizzler
                     swizzler.reset(SkSwizzler::CreateSwizzler(
-                            SkSwizzler::kIndex, colorTable, dstInfo, dst,
-                            dstRowBytes, zeroInit));
+                            SkSwizzler::kIndex, colorTable, dstInfo, zeroInit));
                 }
 
                 // Stores output from dgiflib and input to the swizzler
                 SkAutoTDeleteArray<uint8_t>
                         buffer(SkNEW_ARRAY(uint8_t, innerWidth));
 
                 // Check the interlace flag and iterate over rows of the input
                 if (fGif->Image.Interlace) {
                     // In interlace mode, the rows of input are rearranged in
                     // the output image.  We use an iterator to take care of
                     // the rearranging.
                     SkGifInterlaceIter iter(innerHeight);
                     for (int32_t y = 0; y < innerHeight; y++) {
                         if (GIF_ERROR == DGifGetLine(fGif, buffer.get(),
                                 innerWidth)) {
                             // Recover from error by filling remainder of image
                             if (!skipBackground) {
                                 memset(buffer.get(), fillIndex, innerWidth);
                                 for (; y < innerHeight; y++) {
-                                    swizzler->next(buffer.get(), iter.nextY());
+                                    void* dstRow = SkTAddOffset<void>(dst,
+                                            dstRowBytes * iter.nextY());
+                                    swizzler->swizzle(dstRow, buffer.get());
                                 }
                             }
                             return gif_error(SkStringPrintf(
                                     "Could not decode line %d of %d.\n",
                                     y, height - 1).c_str(), kIncompleteInput);
                         }
-                        swizzler->next(buffer.get(), iter.nextY());
+                        void* dstRow = SkTAddOffset<void>(
+                                dst, dstRowBytes * iter.nextY());
+                        swizzler->swizzle(dstRow, buffer.get());
                     }
                 } else {
                     // Standard mode
+                    void* dstRow = dst;
                     for (int32_t y = 0; y < innerHeight; y++) {
                         if (GIF_ERROR == DGifGetLine(fGif, buffer.get(),
                                 innerWidth)) {
                             if (!skipBackground) {
-                                SkSwizzler::Fill(swizzler->getDstRow(), dstInfo, dstRowBytes,
+                                SkSwizzler::Fill(dstRow, dstInfo, dstRowBytes,
                                         innerHeight - y, fillIndex, colorTable);
                             }
                             return gif_error(SkStringPrintf(
                                     "Could not decode line %d of %d.\n",
                                     y, height - 1).c_str(), kIncompleteInput);
                         }
-                        swizzler->next(buffer.get());
+                        swizzler->swizzle(dstRow, buffer.get());
+                        dstRow = SkTAddOffset<void>(dstRow, dstRowBytes);
                     }
                 }
 
                 // FIXME: Gif files may have multiple images stored in a single
                 //        file.  This is most commonly used to enable
                 //        animations.  Since we are leaving animated gifs as a
                 //        TODO, we will return kSuccess after decoding the
                 //        first image in the file.  This is the same behavior
                 //        as SkImageDecoder_libgif.
                 //
@@ skipping 63 matching lines @@
                 // giflib returns an error code if the record type is not known.
                 // We should catch this error immediately.
                 SkASSERT(false);
                 break;
         }
     } while (TERMINATE_RECORD_TYPE != recordType);
 
     return gif_error("Could not find any images to decode in gif file.\n",
             kInvalidInput);
 }