Move WEBPImageDecoder to SkCodec

third_party/WebKit/Source/platform/image-decoders/webp/WEBPImageDecoder.h

 /*
  * Copyright (C) 2010 Google 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
@@ skipping 11 matching lines @@
  * (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.
  */
 
 #ifndef WEBPImageDecoder_h
 #define WEBPImageDecoder_h
 
+#include <memory>
 #include "platform/image-decoders/ImageDecoder.h"
-#include "webp/decode.h"
-#include "webp/demux.h"
-
-class SkData;
+#include "platform/wtf/Noncopyable.h"
+#include "platform/wtf/RefPtr.h"
+#include "third_party/skia/include/codec/SkCodec.h"
 
 namespace blink {
 
+class SegmentStream;
+
 class PLATFORM_EXPORT WEBPImageDecoder final : public ImageDecoder {
   WTF_MAKE_NONCOPYABLE(WEBPImageDecoder);
 
  public:
   WEBPImageDecoder(AlphaOption, const ColorBehavior&, size_t max_decoded_bytes);
+  WEBPImageDecoder(WEBPImageDecoder&&) = default;
+  WEBPImageDecoder& operator=(WEBPImageDecoder&&) = default;
   ~WEBPImageDecoder() override;
 
   // ImageDecoder:
   String FilenameExtension() const override { return "webp"; }
   void OnSetData(SegmentReader* data) override;
   int RepetitionCount() const override;
   bool FrameIsReceivedAtIndex(size_t) const override;
   float FrameDurationAtIndex(size_t) const override;
+  // CAUTION: SetFailed() deletes |codec_|. Be careful to avoid
+  // accessing deleted memory.
+  bool SetFailed() override;
+
+  size_t ClearCacheExceptFrame(size_t) override;
 
  private:
   // ImageDecoder:
-  virtual void DecodeSize() { UpdateDemuxer(); }
+  void DecodeSize() override {}
   size_t DecodeFrameCount() override;
   void InitializeNewFrame(size_t) override;
   void Decode(size_t) override;
 
-  bool DecodeSingleFrame(const uint8_t* data_bytes,
-                         size_t data_size,
-                         size_t frame_index);
-
   // For WebP images, the frame status needs to be FrameComplete to decode
   // subsequent frames that depend on frame |index|. The reason for this is that
-  // WebP uses the previous frame for alpha blending, in ApplyPostProcessing().
+  // WebP uses the previous frame for alpha blending.
   //
   // Before calling this, verify that frame |index| exists by checking that
   // |index| is smaller than |frame_buffer_cache_|.size().
   bool FrameStatusSufficientForSuccessors(size_t index) override {
     DCHECK(index < frame_buffer_cache_.size());
     return frame_buffer_cache_[index].GetStatus() == ImageFrame::kFrameComplete;
   }
 
-  WebPIDecoder* decoder_;
-  WebPDecBuffer decoder_buffer_;
-  int format_flags_;
-  bool frame_background_has_alpha_;
+  // When a frame depends on a previous frame's content, there is a list of
+  // candidate reference frames. This function will find a previous frame from
+  // that list which satisfies the requirements of being a reference frame.
+  size_t GetViableReferenceFrameIndex(size_t) const;
 
-  void ReadColorProfile();
-  bool UpdateDemuxer();
-
-  // Set |frame_background_has_alpha_| based on this frame's characteristics.
-  // Before calling this method, the caller must verify that the frame exists.
-  void OnInitFrameBuffer(size_t frame_index) override;
-
-  // When the blending method of this frame is BlendAtopPreviousFrame, the
-  // previous frame's buffer is necessary to decode this frame in
-  // ApplyPostProcessing, so we can't take over the data. Before calling this
-  // method, the caller must verify that the frame exists.
-  bool CanReusePreviousFrameBuffer(size_t frame_index) const override;
-
-  void ApplyPostProcessing(size_t frame_index);
-  void ClearFrameBuffer(size_t frame_index) override;
-
-  WebPDemuxer* demux_;
-  WebPDemuxState demux_state_;
-  bool have_already_parsed_this_data_;
-  int repetition_count_;
-  int decoded_height_;
-
-  typedef void (*AlphaBlendFunction)(ImageFrame&, ImageFrame&, int, int, int);
-  AlphaBlendFunction blend_function_;
-
-  void Clear();
-  void ClearDecoder();
-
-  // FIXME: Update libwebp's API so it does not require copying the data on each
-  // update.
-  sk_sp<SkData> consolidated_data_;
+  std::unique_ptr<SkCodec> codec_;
+  // |codec_| owns the SegmentStream, but we need access to it to append more
+  // data as it arrives.
+  SegmentStream* segment_stream_;
+  mutable int repetition_count_ = kAnimationLoopOnce;
 };
 
 }  // namespace blink
 
 #endif