author Seth Fowler <>
Thu, 18 Aug 2016 00:06:41 -0700
changeset 351488 cfb1f1eeceb36952195fd255d5a7a5f017771cbd
parent 351487 02f9e27b988dd63dce023fbca505ac74a1e8a1f6
child 352847 8f8d3c106410aed2252be6180c542aef3b8ad738
permissions -rw-r--r--
Bug 1293472 (Part 3) - Store animated images in the surface cache as a sequence of frames, rather than each frame getting its own cache entry. r=dholbert,edwin,njn

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at */

 * An ISurfaceProvider for animated images.

#ifndef mozilla_image_AnimationSurfaceProvider_h
#define mozilla_image_AnimationSurfaceProvider_h

#include "FrameAnimator.h"
#include "IDecodingTask.h"
#include "ISurfaceProvider.h"

namespace mozilla {
namespace image {

 * An ISurfaceProvider that manages the decoding of animated images and
 * dynamically generates surfaces for the current playback state of the
 * animation.
class AnimationSurfaceProvider final
  : public ISurfaceProvider
  , public IDecodingTask
  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(AnimationSurfaceProvider, override)

  AnimationSurfaceProvider(NotNull<RasterImage*> aImage,
                           NotNull<Decoder*> aDecoder,
                           const SurfaceKey& aSurfaceKey);

  // ISurfaceProvider implementation.

  // We use the ISurfaceProvider constructor of DrawableSurface to indicate that
  // our surfaces are computed lazily.
  DrawableSurface Surface() override { return DrawableSurface(WrapNotNull(this)); }

  bool IsFinished() const override;
  size_t LogicalSizeInBytes() const override;
  void AddSizeOfExcludingThis(MallocSizeOf aMallocSizeOf,
                              size_t& aHeapSizeOut,
                              size_t& aNonHeapSizeOut) override;

  DrawableFrameRef DrawableRef(size_t aFrame) override;

  // Animation frames are always locked. This is because we only want to release
  // their memory atomically (due to the surface cache discarding them). If they
  // were unlocked, the OS could end up releasing the memory of random frames
  // from the middle of the animation, which is not worth the complexity of
  // dealing with.
  bool IsLocked() const override { return true; }
  void SetLocked(bool) override { }

  // IDecodingTask implementation.

  void Run() override;
  bool ShouldPreferSyncRun() const override;

  // Full decodes are low priority compared to metadata decodes because they
  // don't block layout or page load.
  TaskPriority Priority() const override { return TaskPriority::eLow; }

  virtual ~AnimationSurfaceProvider();

  void DropImageReference();
  void CheckForNewFrameAtYield();
  void CheckForNewFrameAtTerminalState();
  void AnnounceSurfaceAvailable();
  void FinishDecoding();

  /// The image associated with our decoder.
  RefPtr<RasterImage> mImage;

  /// A mutex to protect mDecoder. Always taken before mFramesMutex.
  mutable Mutex mDecodingMutex;

  /// The decoder used to decode this animation.
  RefPtr<Decoder> mDecoder;

  /// A mutex to protect mFrames. Always taken after mDecodingMutex.
  mutable Mutex mFramesMutex;

  /// The frames of this animation, in order.
  nsTArray<RawAccessFrameRef> mFrames;

  /// The key under which we're stored as a cache entry in the surface cache.
  const SurfaceKey mSurfaceKey;

} // namespace image
} // namespace mozilla

#endif // mozilla_image_AnimationSurfaceProvider_h