Move gif image decoder to SkCodec

third_party/WebKit/Source/platform/image-decoders/gif/GIFImageDecoder.cpp

 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/image-decoders/gif/GIFImageDecoder.h"
 
 #include <limits>
-#include "platform/image-decoders/gif/GIFImageReader.h"
+#include "platform/image-decoders/SegmentStream.h"
 #include "platform/wtf/NotFound.h"
 #include "platform/wtf/PtrUtil.h"
+#include "third_party/skia/include/core/SkImageInfo.h"
 
 namespace blink {
 
 GIFImageDecoder::GIFImageDecoder(AlphaOption alpha_option,
                                  const ColorBehavior& color_behavior,
                                  size_t max_decoded_bytes)
     : ImageDecoder(alpha_option, color_behavior, max_decoded_bytes),
-      repetition_count_(kAnimationLoopOnce) {}
-
-GIFImageDecoder::~GIFImageDecoder() {}
+      codec_(),
+      segment_stream_(nullptr) {}
+
+GIFImageDecoder::~GIFImageDecoder() = default;
 
 void GIFImageDecoder::OnSetData(SegmentReader* data) {
-  if (reader_)
-    reader_->SetData(data);
+  if (!data) {
+    if (segment_stream_)
+      segment_stream_->SetReader(nullptr);
+    return;
+  }
+
+  std::unique_ptr<SegmentStream> segment_stream;
+  if (!segment_stream_) {
+    segment_stream = base::MakeUnique<SegmentStream>();
+    segment_stream_ = segment_stream.get();
+  }
+
+  segment_stream_->SetReader(PassRefPtr<SegmentReader>(data));
+
+  if (!codec_) {
+    SkCodec::Result codec_creation_result;
+    codec_ = SkCodec::MakeFromStream(std::move(segment_stream),
+                                     &codec_creation_result, nullptr);
+    switch (codec_creation_result) {
+      case SkCodec::kSuccess: {
+        // SkCodec::MakeFromStream will read enough of the image to get the
+        // image size.
+        SkImageInfo image_info = codec_->getInfo();
+        SetSize(image_info.width(), image_info.height());
+        return;
+      }
+      case SkCodec::kIncompleteInput:
+        // |segment_stream_|'s ownership is passed into MakeFromStream.
+        // It is deleted if MakeFromStream fails.
+        // If MakeFromStream fails, we set |segment_stream_| to null so
+        // we aren't pointing to reclaimed memory.
+        segment_stream_ = nullptr;
+        return;
+      default:
+        SetFailed();
+        return;
+    }
+  }
 }
 
 int GIFImageDecoder::RepetitionCount() const {
+  if (!codec_ || segment_stream_->IsCleared())
+    return cached_repetition_count_;
+
+  DCHECK(!Failed());
+
   // This value can arrive at any point in the image data stream.  Most GIFs
   // in the wild declare it near the beginning of the file, so it usually is
   // set by the time we've decoded the size, but (depending on the GIF and the
-  // packets sent back by the webserver) not always.  If the reader hasn't
-  // seen a loop count yet, it will return kCLoopCountNotSeen, in which case we
-  // should default to looping once (the initial value for
-  // |repetition_count_|).
+  // packets sent back by the webserver) not always.
   //
-  // There are some additional wrinkles here. First, ImageSource::Clear()
-  // may destroy the reader, making the result from the reader _less_
-  // authoritative on future calls if the recreated reader hasn't seen the
-  // loop count.  We don't need to special-case this because in this case the
-  // new reader will once again return kCLoopCountNotSeen, and we won't
-  // overwrite the cached correct value.
+  // SkCodec will parse forward in the file if the repetition count has not
+  // been seen yet.
+  int repetition_count = codec_->getRepetitionCount();
+
+  switch (repetition_count) {
+    case 0: {
+      // SkCodec returns 0 for both still images and animated images which
+      // only play once.
+      if (IsAllDataReceived() && codec_->getFrameCount() == 1) {
+        cached_repetition_count_ = kAnimationNone;
+        break;
+      }
+
+      cached_repetition_count_ = kAnimationLoopOnce;
+      break;
+    }
+    case SkCodec::kRepetitionCountInfinite:
+      cached_repetition_count_ = kAnimationLoopInfinite;
+      break;
+    default:
+      cached_repetition_count_ = repetition_count;
+      break;
+  }
+
+  return cached_repetition_count_;
+}
+
+bool GIFImageDecoder::FrameIsReceivedAtIndex(size_t index) const {
+  if (!codec_)
+    return false;
+
+  if (max_received_frame_index_ == kNotFound)
+    return false;
+
+  return index <= max_received_frame_index_;
+}
+
+float GIFImageDecoder::FrameDurationAtIndex(size_t index) const {
+  if (index < frame_buffer_cache_.size())
+    return frame_buffer_cache_[index].Duration();
+  return 0;
+}
+
+bool GIFImageDecoder::SetFailed() {
+  segment_stream_ = nullptr;
+  codec_.reset();
+  return ImageDecoder::SetFailed();
+}
+
+size_t GIFImageDecoder::ClearCacheExceptFrame(size_t index) {
+  // SkCodec attempts to report the earliest possible required frame, but it is
+  // possible that frame has been evicted, while a later frame (which could also
+  // be used as the required frame) is still cached. Try to preserve a frame
+  // that is still cached.
+  if (frame_buffer_cache_.size() <= 1)
+    return 0;
+
+  size_t index2 = kNotFound;
+  if (index < frame_buffer_cache_.size()) {
+    const ImageFrame& frame = frame_buffer_cache_[index];
+    if (!FrameStatusSufficientForSuccessors(index) ||
+        frame.GetDisposalMethod() == ImageFrame::kDisposeOverwritePrevious) {
+      index2 = GetViableReferenceFrameIndex(index);
+    }
+  }
+
+  return ClearCacheExceptTwoFrames(index, index2);
+}
+
+size_t GIFImageDecoder::DecodeFrameCount() {
+  if (!codec_ || segment_stream_->IsCleared())
+    return frame_buffer_cache_.size();
+
+  int frame_count = codec_->getFrameCount();
+  if (frame_count == 1) {
+    max_received_frame_index_ = kNotFound;

[scroggo_chromium, 2017/08/10 23:31:26]

I don't think this is quite right. If we had *exactly* the entire first frame
(or even part of the header for the second frame), this will incorrectly report
that frame 0 is incomplete.

Again, I think it would be simpler to just call getFrameInfo in
FrameIsReceivedAtIndex.

[cblume, 2017/08/11 16:56:23]

You're right.

Well, I'm happy to do what you think is best. After all, I need your approval.
:)
I also agree that it would be more simple to just call getFrameInfo
inFrameIsReceivedAtIndex. That is what I used to have.
I'm trying to figure out if there is anything that I'm not grasping from our
conversaion...I could go back to what we had and lose the caching. I think
that's what we're after and we're on the same page. But just to confirm, that is
what we had and went away from. We're okay losing the caching for more simple
code. It sounds like we're okay going back to the old code, right?

[cblume, 2017/08/11 17:33:56]

Also, are we talking about getting rid of both cached values (repetition count
and max fully-received index)?

[cblume, 2017/08/14 17:10:42]

I just uploaded a PS which calls getFrameInfo inside FrameIsReceivedAtIndex and
without caching.
I'm still unsure if this is what you had meant when you mentioned simplifying
the code. But it certainly is more simple.

I re-read your comments a few times and tried to think of different ways it
could be interpreted.

You mentioned here that we could call getFrameInfo from inside
FrameIsReceivedAtIndex().
Earlier, you mentioned calling it from DecodeFrameCount(). [1] Maybe this was
not what you meant? That could be why I'm unsure what you want.

[1]
https://codereview.chromium.org/2565323003/diff/3080001/third_party/WebKit/So...

[scroggo_chromium, 2017/08/14 18:26:06]

Almost - you called getFrameCount, which was unsafe to call if the SegmentStream
had been cleared. I just mean to call getFrameInfo, which is safe (non-const,
and does no reading of the stream). I've added a comment in patch set 162 that
shows what I mean.
SkCodec has already stored the information, which can be accessed with
getFrameInfo. No need for an extra cache.
No, I think it makes sense to cache repetition count (as does the old code).
You mostly wrote what I meant here, but after I proposed it, I realized calling
getFrameInfo (without getFrameCount) in FrameIsReceivedAtIndex is simpler (and
covers the case you were worried about).

[cblume, 2017/08/14 18:52:04]

Oooohhh okay, I see now. I was confused because I was also calling getFrameInfo.
But that was the safe call. You were suggesting only calling that, rather than
both functions. Okay, fixed.
I see now. It wouldn't make sense to have the whole system only cache one and
not the other. We can cache both in the whole system, but use SkCodec's cache of
frame received. So the Blink image decoder only needs to cache the repetition
count in order for the whole system to cache both.

+    return frame_count;
+  }
+
+  // For gifs, if frame i+1 is known to exist then frame i must be completely
+  // received.
+  max_received_frame_index_ = frame_count - 2;
+
+  SkCodec::FrameInfo frame_info;
+  codec_->getFrameInfo(frame_count - 1, &frame_info);
+  if (frame_info.fFullyReceived)
+    max_received_frame_index_ = frame_count - 1;
+
+  return frame_count;
+}
+
+void GIFImageDecoder::InitializeNewFrame(size_t index) {
+  DCHECK(codec_);
+
+  ImageFrame& frame = frame_buffer_cache_[index];
+  // SkCodec does not inform us if only a portion of the image was updated
+  // in the current frame. Because of this, rather than correctly filling in
+  // the frame rect, we set the frame rect to be the image's full size.
+  // The original frame rect is not used, anyway.
+  IntSize full_image_size = Size();
+  frame.SetOriginalFrameRect(IntRect(IntPoint(), full_image_size));
+
+  SkCodec::FrameInfo frame_info;
+  bool frame_info_received = codec_->getFrameInfo(index, &frame_info);
+  DCHECK(frame_info_received);
+  frame.SetDuration(frame_info.fDuration);
+  size_t required_previous_frame_index;
+  if (frame_info.fRequiredFrame == SkCodec::kNone) {
+    required_previous_frame_index = kNotFound;
+  } else {
+    required_previous_frame_index =
+        static_cast<size_t>(frame_info.fRequiredFrame);
+  }
+  frame.SetRequiredPreviousFrameIndex(required_previous_frame_index);
+
+  ImageFrame::DisposalMethod disposal_method = ImageFrame::kDisposeNotSpecified;
+  switch (frame_info.fDisposalMethod) {
+    case SkCodecAnimation::DisposalMethod::kKeep:
+      disposal_method = ImageFrame::kDisposeKeep;
+      break;
+    case SkCodecAnimation::DisposalMethod::kRestoreBGColor:
+      disposal_method = ImageFrame::kDisposeOverwriteBgcolor;
+      break;
+    case SkCodecAnimation::DisposalMethod::kRestorePrevious:
+      disposal_method = ImageFrame::kDisposeOverwritePrevious;
+      break;
+  }
+  frame.SetDisposalMethod(disposal_method);
+}
+
+void GIFImageDecoder::Decode(size_t index) {
+  if (!codec_ || segment_stream_->IsCleared())
+    return;
+
+  DCHECK(!Failed());
+
+  DCHECK_LT(index, frame_buffer_cache_.size());
+
+  UpdateAggressivePurging(index);
+  SkImageInfo image_info = codec_->getInfo()
+                               .makeColorType(kN32_SkColorType)
+                               .makeColorSpace(ColorSpaceForSkImages());
+
+  SkCodec::Options options;
+  options.fFrameIndex = index;
+  options.fPriorFrame = SkCodec::kNone;
+  options.fZeroInitialized = SkCodec::kNo_ZeroInitialized;
+
+  ImageFrame& frame = frame_buffer_cache_[index];
+  if (frame.GetStatus() == ImageFrame::kFrameEmpty) {
+    size_t required_previous_frame_index = frame.RequiredPreviousFrameIndex();
+    if (required_previous_frame_index == kNotFound) {
+      frame.AllocatePixelData(Size().Width(), Size().Height(),
+                              ColorSpaceForSkImages());
+      frame.ZeroFillPixelData();
+    } else {
+      size_t previous_frame_index = GetViableReferenceFrameIndex(index);
+      if (previous_frame_index == kNotFound) {
+        previous_frame_index = required_previous_frame_index;
+        Decode(previous_frame_index);
+      }
+
+      // We try to reuse |previous_frame| as starting state to avoid copying.
+      // If CanReusePreviousFrameBuffer returns false, we must copy the data
+      // since |previous_frame| is necessary to decode this or later frames.
+      // In that case copy the data instead.
+      ImageFrame& previous_frame = frame_buffer_cache_[previous_frame_index];
+      if ((!CanReusePreviousFrameBuffer(index) ||
+           !frame.TakeBitmapDataIfWritable(&previous_frame)) &&
+          !frame.CopyBitmapData(previous_frame)) {
+        SetFailed();
+        return;
+      }
+      options.fPriorFrame = previous_frame_index;
+    }
+  }
+
+  if (frame.GetStatus() == ImageFrame::kFrameAllocated) {
+    SkCodec::Result start_incremental_decode_result =
+        codec_->startIncrementalDecode(image_info, frame.Bitmap().getPixels(),
+                                       frame.Bitmap().rowBytes(), &options);
+    switch (start_incremental_decode_result) {
+      case SkCodec::kSuccess:
+        break;
+      case SkCodec::kIncompleteInput:
+        return;
+      default:
+        SetFailed();
+        return;
+    }
+    frame.SetStatus(ImageFrame::kFramePartial);
+  }
+
+  SkCodec::Result incremental_decode_result = codec_->incrementalDecode();
+  switch (incremental_decode_result) {
+    case SkCodec::kSuccess: {
+      SkCodec::FrameInfo frame_info;
+      bool frame_info_received = codec_->getFrameInfo(index, &frame_info);
+      DCHECK(frame_info_received);
+      frame.SetHasAlpha(!SkAlphaTypeIsOpaque(frame_info.fAlphaType));
+      frame.SetPixelsChanged(true);
+      frame.SetStatus(ImageFrame::kFrameComplete);
+      PostDecodeProcessing(index);
+      break;
+    }
+    case SkCodec::kIncompleteInput:
+      frame.SetPixelsChanged(true);
+      if (FrameIsReceivedAtIndex(index) || IsAllDataReceived()) {
+        SetFailed();
+      }
+      break;
+    default:
+      SetFailed();
+      break;
+  }
+}
+
+bool GIFImageDecoder::CanReusePreviousFrameBuffer(size_t index) const {
+  DCHECK_LT(index, frame_buffer_cache_.size());
+  return frame_buffer_cache_[index].GetDisposalMethod() !=
+         ImageFrame::kDisposeOverwritePrevious;
+}
+
+size_t GIFImageDecoder::GetViableReferenceFrameIndex(
+    size_t dependent_index) const {
+  DCHECK_LT(dependent_index, frame_buffer_cache_.size());
+
+  size_t required_previous_frame_index =
+      frame_buffer_cache_[dependent_index].RequiredPreviousFrameIndex();
+
+  // Any frame in the range [|required_previous_frame_index|, |dependent_index|)
+  // which has a disposal method other than kRestorePrevious can be provided as
+  // the prior frame to SkCodec.
   //
-  // Second, a GIF might never set a loop count at all, in which case we
-  // should continue to treat it as a "loop once" animation.  We don't need
-  // special code here either, because in this case we'll never change
-  // |repetition_count_| from its default value.
-  //
-  // Third, we use the same GIFImageReader for counting frames and we might
-  // see the loop count and then encounter a decoding error which happens
-  // later in the stream. It is also possible that no frames are in the
-  // stream. In these cases we should just loop once.
-  if (IsAllDataReceived() && ParseCompleted() && reader_->ImagesCount() == 1)
-    repetition_count_ = kAnimationNone;
-  else if (Failed() || (reader_ && (!reader_->ImagesCount())))
-    repetition_count_ = kAnimationLoopOnce;
-  else if (reader_ && reader_->LoopCount() != kCLoopCountNotSeen)
-    repetition_count_ = reader_->LoopCount();
-  return repetition_count_;
-}
-
-bool GIFImageDecoder::FrameIsReceivedAtIndex(size_t index) const {
-  return reader_ && (index < reader_->ImagesCount()) &&
-         reader_->FrameContext(index)->IsComplete();
-}
-
-float GIFImageDecoder::FrameDurationAtIndex(size_t index) const {
-  return (reader_ && (index < reader_->ImagesCount()) &&
-          reader_->FrameContext(index)->IsHeaderDefined())
-             ? reader_->FrameContext(index)->DelayTime()
-             : 0;
-}
-
-bool GIFImageDecoder::SetFailed() {
-  reader_.reset();
-  return ImageDecoder::SetFailed();
-}
-
-bool GIFImageDecoder::HaveDecodedRow(size_t frame_index,
-                                     GIFRow::const_iterator row_begin,
-                                     size_t width,
-                                     size_t row_number,
-                                     unsigned repeat_count,
-                                     bool write_transparent_pixels) {
-  const GIFFrameContext* frame_context = reader_->FrameContext(frame_index);
-  // The pixel data and coordinates supplied to us are relative to the frame's
-  // origin within the entire image size, i.e.
-  // (frameC_context->xOffset, frame_context->yOffset). There is no guarantee
-  // that width == (size().width() - frame_context->xOffset), so
-  // we must ensure we don't run off the end of either the source data or the
-  // row's X-coordinates.
-  const int x_begin = frame_context->XOffset();
-  const int y_begin = frame_context->YOffset() + row_number;
-  const int x_end = std::min(static_cast<int>(frame_context->XOffset() + width),
-                             Size().Width());
-  const int y_end = std::min(
-      static_cast<int>(frame_context->YOffset() + row_number + repeat_count),
-      Size().Height());
-  if (!width || (x_begin < 0) || (y_begin < 0) || (x_end <= x_begin) ||
-      (y_end <= y_begin))
-    return true;
-
-  const GIFColorMap::Table& color_table =
-      frame_context->LocalColorMap().IsDefined()
-          ? frame_context->LocalColorMap().GetTable()
-          : reader_->GlobalColorMap().GetTable();
-
-  if (color_table.IsEmpty())
-    return true;
-
-  GIFColorMap::Table::const_iterator color_table_iter = color_table.begin();
-
-  // Initialize the frame if necessary.
-  ImageFrame& buffer = frame_buffer_cache_[frame_index];
-  if (!InitFrameBuffer(frame_index))
-    return false;
-
-  const size_t transparent_pixel = frame_context->TransparentPixel();
-  GIFRow::const_iterator row_end = row_begin + (x_end - x_begin);
-  ImageFrame::PixelData* current_address = buffer.GetAddr(x_begin, y_begin);
-
-  // 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.
-  //
-  // The loops below are almost identical. One writes a transparent pixel
-  // and one doesn't based on the value of |write_transparent_pixels|.
-  // The condition check is taken out of the loop to enhance performance.
-  // This optimization reduces decoding time by about 15% for a 3MB image.
-  if (write_transparent_pixels) {
-    for (; row_begin != row_end; ++row_begin, ++current_address) {
-      const size_t source_value = *row_begin;
-      if ((source_value != transparent_pixel) &&
-          (source_value < color_table.size())) {
-        *current_address = color_table_iter[source_value];
-      } else {
-        *current_address = 0;
-        current_buffer_saw_alpha_ = true;
-      }
-    }
-  } else {
-    for (; row_begin != row_end; ++row_begin, ++current_address) {
-      const size_t source_value = *row_begin;
-      if ((source_value != transparent_pixel) &&
-          (source_value < color_table.size()))
-        *current_address = color_table_iter[source_value];
-      else
-        current_buffer_saw_alpha_ = true;
-    }
-  }
-
-  // Tell the frame to copy the row data if need be.
-  if (repeat_count > 1)
-    buffer.CopyRowNTimes(x_begin, x_end, y_begin, y_end);
-
-  buffer.SetPixelsChanged(true);
-  return true;
-}
-
-bool GIFImageDecoder::ParseCompleted() const {
-  return reader_ && reader_->ParseCompleted();
-}
-
-bool GIFImageDecoder::FrameComplete(size_t frame_index) {
-  // Initialize the frame if necessary.  Some GIFs insert do-nothing frames,
-  // in which case we never reach HaveDecodedRow() before getting here.
-  if (!InitFrameBuffer(frame_index))
-    return SetFailed();
-
-  if (!current_buffer_saw_alpha_)
-    CorrectAlphaWhenFrameBufferSawNoAlpha(frame_index);
-
-  frame_buffer_cache_[frame_index].SetStatus(ImageFrame::kFrameComplete);
-
-  return true;
-}
-
-void GIFImageDecoder::ClearFrameBuffer(size_t frame_index) {
-  if (reader_ && frame_buffer_cache_[frame_index].GetStatus() ==
-                     ImageFrame::kFramePartial) {
-    // Reset the state of the partial frame in the reader so that the frame
-    // can be decoded again when requested.
-    reader_->ClearDecodeState(frame_index);
-  }
-  ImageDecoder::ClearFrameBuffer(frame_index);
-}
-
-size_t GIFImageDecoder::DecodeFrameCount() {
-  Parse(kGIFFrameCountQuery);
-  // If decoding fails, |reader_| will have been destroyed.  Instead of
-  // returning 0 in this case, return the existing number of frames.  This way
-  // if we get halfway through the image before decoding fails, we won't
-  // suddenly start reporting that the image has zero frames.
-  return Failed() ? frame_buffer_cache_.size() : reader_->ImagesCount();
-}
-
-void GIFImageDecoder::InitializeNewFrame(size_t index) {
-  ImageFrame* buffer = &frame_buffer_cache_[index];
-  const GIFFrameContext* frame_context = reader_->FrameContext(index);
-  buffer->SetOriginalFrameRect(
-      Intersection(frame_context->FrameRect(), IntRect(IntPoint(), Size())));
-  buffer->SetDuration(frame_context->DelayTime());
-  buffer->SetDisposalMethod(frame_context->GetDisposalMethod());
-  buffer->SetRequiredPreviousFrameIndex(
-      FindRequiredPreviousFrame(index, false));
-}
-
-void GIFImageDecoder::Decode(size_t index) {
-  Parse(kGIFFrameCountQuery);
-
-  if (Failed())
-    return;
-
-  UpdateAggressivePurging(index);
-
-  Vector<size_t> frames_to_decode = FindFramesToDecode(index);
-  for (auto i = frames_to_decode.rbegin(); i != frames_to_decode.rend(); ++i) {
-    if (!reader_->Decode(*i)) {
-      SetFailed();
-      return;
-    }
-
-    // If this returns false, we need more data to continue decoding.
-    if (!PostDecodeProcessing(*i))
-      break;
-  }
-
-  // It is also a fatal error if all data is received and we have decoded all
-  // frames available but the file is truncated.
-  if (index >= frame_buffer_cache_.size() - 1 && IsAllDataReceived() &&
-      reader_ && !reader_->ParseCompleted())
-    SetFailed();
-}
-
-void GIFImageDecoder::Parse(GIFParseQuery query) {
-  if (Failed())
-    return;
-
-  if (!reader_) {
-    reader_ = WTF::MakeUnique<GIFImageReader>(this);
-    reader_->SetData(data_);
-  }
-
-  if (!reader_->Parse(query))
-    SetFailed();
-}
-
-void GIFImageDecoder::OnInitFrameBuffer(size_t frame_index) {
-  current_buffer_saw_alpha_ = false;
-}
-
-bool GIFImageDecoder::CanReusePreviousFrameBuffer(size_t frame_index) const {
-  DCHECK(frame_index < frame_buffer_cache_.size());
-  return frame_buffer_cache_[frame_index].GetDisposalMethod() !=
-         ImageFrame::kDisposeOverwritePrevious;
+  // SkCodec sets SkCodec::FrameInfo::fRequiredFrame to the earliest frame which
+  // can be used. This might come up when several frames update the same
+  // subregion. If that same subregion is about to be overwritten, it doesn't
+  // matter which frame in that chain is provided.
+  size_t previous_reference_frame_index = kNotFound;
+  if (required_previous_frame_index != kNotFound) {
+    // Loop backwards because the frames most likely to be in cache are the most
+    // recent.
+    for (size_t i = dependent_index - 1; i != required_previous_frame_index;
+         i--) {
+      const ImageFrame& frame = frame_buffer_cache_[i];
+
+      if (frame.GetDisposalMethod() == ImageFrame::kDisposeOverwritePrevious)
+        continue;
+
+      if (frame.GetStatus() == ImageFrame::kFrameComplete) {
+        previous_reference_frame_index = i;
+        break;
+      }
+    }
+  }
+
+  return previous_reference_frame_index;
 }
 
 }  // namespace blink