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/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) {}
 
 void GIFImageDecoder::OnSetData(SegmentReader* data) {
-  if (reader_)
-    reader_->SetData(data);
+  if (!data) {
+    if (segment_stream_)
+      segment_stream_->SetReader(nullptr);
+    return;
+  }
+
+  if (!segment_stream_)
+    segment_stream_ = new SegmentStream();
+
+  segment_stream_->SetReader(PassRefPtr<SegmentReader>(data));
+
+  if (!codec_) {
+    SkCodec::Result stream_creation_result;
+    codec_.reset(SkCodec::NewFromStream(segment_stream_,
+                                        &stream_creation_result, nullptr));
+    switch (stream_creation_result) {
+      case SkCodec::kSuccess: {
+        // SkCodec::NewFromStream 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 NewFromStream.
+        // It is deleted if NewFromStream fails.
+        // If NewFromStream 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())

[scroggo_chromium, 2017/07/21 19:01:41]

The fact that segment_stream_ has been cleared doesn't necessarily mean we want
to loop once, does it? Then shouldn't we be using the last value we sent?

[cblume, 2017/07/21 22:50:00]

kAnimationLoopOnce is the value we return when we haven't found the actual
repetition count. It is the default.

But you're right, it would be strange to go back to the default. That would also
be a point where we aren't actually hiding the fact that the stream was cleared.

We could keep a cached copy that defaults to kAnimationLoopOnce. On each call to
RepetitionCount() it can update the cached copy if it can and return that.

I'll do that.


Just a head's up: Because this method is const, I'll have to make the cached
copy mutable. This isn't pretty and it actually violates a silent change in
C++11 where const & mutable mean thread safe. The better solution will be to
change the ImageDecoder API to be correct about const. (It was already arguably
wrong since it made changes in the underlying readers.)

An alternative would be to DCHECK() instead. But that gets back into the
spaghetti design we want to move away from. So I'm happy with the mutable for
now.

+    return kAnimationLoopOnce;
+
+  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)
+        return kAnimationNone;
+
+      return kAnimationLoopOnce;
+    }
+    case SkCodec::kRepetitionCountInfinite:
+      return kAnimationLoopInfinite;
+    default:
+      return repetition_count;
+  }
+}
+
+bool GIFImageDecoder::FrameIsReceivedAtIndex(size_t index) const {
+  if (!codec_ || segment_stream_->IsCleared())

[scroggo_chromium, 2017/07/21 19:01:41]

I suspect if IsCleared we want to return some sort of cached value.

If we go ahead and only report complete frames, we can 

  return index < frame_buffer_cache_.size();

But we still need to treat the first frame differently.

[cblume, 2017/07/24 05:54:47]

Done.
I am keeping a cached copy and checking if the frame is fully received via
SkCodec::FrameInfo::fFullyReceived.

Interestingly, using fFullyReceived required a slight tweak to the test. It
looks like once SkCodec reports that there is a second frame, it also reports
the frame is fully received. Did we already land the
only-report-fully-received-frames thing? I'm guessing so.

[scroggo_chromium, 2017/07/25 19:02:00]

Once it reports the second frame, the first frame will be reported as fully
received.

We had discussed a while ago making SkCodec report only complete frames, but
ended up adding fFullyReceived instead.

[cblume, 2017/07/26 07:43:29]

Right right. That's not what I mean though.
Once the second frame was reported at all, the *second* frame was marked as
complete. (Along with the first)

I'll make another comment on the test which I changed to explain what I mean.

+    return false;
+
+  if (static_cast<size_t>(codec_->getFrameCount()) <= index)
+    return false;
+
+  SkCodec::FrameInfo frame_info;
+  codec_->getFrameInfo(index, &frame_info);
+  return frame_info.fFullyReceived;
+}
+
+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();
+
+  return codec_->getFrameCount();
+}
+
+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())

[scroggo_chromium, 2017/07/21 19:01:41]

You already check for this on line 209. I think it's fine to combine them here
if you remove the later one.

[cblume, 2017/07/21 22:50:00]

Done.

+    return;
+
+  DCHECK(!Failed());
+
+  DCHECK_LT(index, frame_buffer_cache_.size());
+
+  if (segment_stream_->IsCleared())
+    return;
+
+  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(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