Add m-esr52 at 52.6.0

1 files changed, 1724 insertions, 0 deletions

diff --git a/image/RasterImage.cpp b/image/RasterImage.cpp
new file mode 100644
index 000000000..aad705473
--- /dev/null
+++ b/image/RasterImage.cpp
@@ -0,0 +1,1724 @@
+/* -*- 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 http://mozilla.org/MPL/2.0/. */
+
+// Must #include ImageLogging.h before any IPDL-generated files or other files
+// that #include prlog.h
+#include "ImageLogging.h"
+
+#include "RasterImage.h"
+
+#include "gfxPlatform.h"
+#include "nsComponentManagerUtils.h"
+#include "nsError.h"
+#include "Decoder.h"
+#include "prenv.h"
+#include "prsystem.h"
+#include "IDecodingTask.h"
+#include "ImageContainer.h"
+#include "ImageRegion.h"
+#include "Layers.h"
+#include "LookupResult.h"
+#include "nsIConsoleService.h"
+#include "nsIInputStream.h"
+#include "nsIScriptError.h"
+#include "nsISupportsPrimitives.h"
+#include "nsPresContext.h"
+#include "SourceBuffer.h"
+#include "SurfaceCache.h"
+#include "FrameAnimator.h"
+
+#include "gfxContext.h"
+
+#include "mozilla/gfx/2D.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/Likely.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/Move.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/Services.h"
+#include <stdint.h>
+#include "mozilla/Telemetry.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/Tuple.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/gfx/Scale.h"
+
+#include "GeckoProfiler.h"
+#include "gfx2DGlue.h"
+#include "gfxPrefs.h"
+#include <algorithm>
+
+namespace mozilla {
+
+using namespace gfx;
+using namespace layers;
+
+namespace image {
+
+using std::ceil;
+using std::min;
+
+#ifndef DEBUG
+NS_IMPL_ISUPPORTS(RasterImage, imgIContainer, nsIProperties)
+#else
+NS_IMPL_ISUPPORTS(RasterImage, imgIContainer, nsIProperties,
+                  imgIContainerDebug)
+#endif
+
+//******************************************************************************
+RasterImage::RasterImage(ImageURL* aURI /* = nullptr */) :
+  ImageResource(aURI), // invoke superclass's constructor
+  mSize(0,0),
+  mLockCount(0),
+  mDecodeCount(0),
+  mRequestedSampleSize(0),
+  mImageProducerID(ImageContainer::AllocateProducerID()),
+  mLastFrameID(0),
+  mLastImageContainerDrawResult(DrawResult::NOT_READY),
+#ifdef DEBUG
+  mFramesNotified(0),
+#endif
+  mSourceBuffer(WrapNotNull(new SourceBuffer())),
+  mHasSize(false),
+  mTransient(false),
+  mSyncLoad(false),
+  mDiscardable(false),
+  mHasSourceData(false),
+  mHasBeenDecoded(false),
+  mPendingAnimation(false),
+  mAnimationFinished(false),
+  mWantFullDecode(false)
+{
+}
+
+//******************************************************************************
+RasterImage::~RasterImage()
+{
+  // Make sure our SourceBuffer is marked as complete. This will ensure that any
+  // outstanding decoders terminate.
+  if (!mSourceBuffer->IsComplete()) {
+    mSourceBuffer->Complete(NS_ERROR_ABORT);
+  }
+
+  // Release all frames from the surface cache.
+  SurfaceCache::RemoveImage(ImageKey(this));
+
+  // Record Telemetry.
+  Telemetry::Accumulate(Telemetry::IMAGE_DECODE_COUNT, mDecodeCount);
+}
+
+nsresult
+RasterImage::Init(const char* aMimeType,
+                  uint32_t aFlags)
+{
+  // We don't support re-initialization
+  if (mInitialized) {
+    return NS_ERROR_ILLEGAL_VALUE;
+  }
+
+  // Not sure an error can happen before init, but be safe
+  if (mError) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // We want to avoid redecodes for transient images.
+  MOZ_ASSERT_IF(aFlags & INIT_FLAG_TRANSIENT,
+                !(aFlags & INIT_FLAG_DISCARDABLE));
+
+  // Store initialization data
+  mDiscardable = !!(aFlags & INIT_FLAG_DISCARDABLE);
+  mWantFullDecode = !!(aFlags & INIT_FLAG_DECODE_IMMEDIATELY);
+  mTransient = !!(aFlags & INIT_FLAG_TRANSIENT);
+  mSyncLoad = !!(aFlags & INIT_FLAG_SYNC_LOAD);
+
+  // Use the MIME type to select a decoder type, and make sure there *is* a
+  // decoder for this MIME type.
+  NS_ENSURE_ARG_POINTER(aMimeType);
+  mDecoderType = DecoderFactory::GetDecoderType(aMimeType);
+  if (mDecoderType == DecoderType::UNKNOWN) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // Lock this image's surfaces in the SurfaceCache if we're not discardable.
+  if (!mDiscardable) {
+    mLockCount++;
+    SurfaceCache::LockImage(ImageKey(this));
+  }
+
+  if (!mSyncLoad) {
+    // Create an async metadata decoder and verify we succeed in doing so.
+    nsresult rv = DecodeMetadata(DECODE_FLAGS_DEFAULT);
+    if (NS_FAILED(rv)) {
+      return NS_ERROR_FAILURE;
+    }
+  }
+
+  // Mark us as initialized
+  mInitialized = true;
+
+  return NS_OK;
+}
+
+//******************************************************************************
+NS_IMETHODIMP_(void)
+RasterImage::RequestRefresh(const TimeStamp& aTime)
+{
+  if (HadRecentRefresh(aTime)) {
+    return;
+  }
+
+  EvaluateAnimation();
+
+  if (!mAnimating) {
+    return;
+  }
+
+  RefreshResult res;
+  if (mAnimationState) {
+    MOZ_ASSERT(mFrameAnimator);
+    res = mFrameAnimator->RequestRefresh(*mAnimationState, aTime);
+  }
+
+  if (res.mFrameAdvanced) {
+    // Notify listeners that our frame has actually changed, but do this only
+    // once for all frames that we've now passed (if AdvanceFrame() was called
+    // more than once).
+    #ifdef DEBUG
+      mFramesNotified++;
+    #endif
+
+    NotifyProgress(NoProgress, res.mDirtyRect);
+  }
+
+  if (res.mAnimationFinished) {
+    mAnimationFinished = true;
+    EvaluateAnimation();
+  }
+}
+
+//******************************************************************************
+NS_IMETHODIMP
+RasterImage::GetWidth(int32_t* aWidth)
+{
+  NS_ENSURE_ARG_POINTER(aWidth);
+
+  if (mError) {
+    *aWidth = 0;
+    return NS_ERROR_FAILURE;
+  }
+
+  *aWidth = mSize.width;
+  return NS_OK;
+}
+
+//******************************************************************************
+NS_IMETHODIMP
+RasterImage::GetHeight(int32_t* aHeight)
+{
+  NS_ENSURE_ARG_POINTER(aHeight);
+
+  if (mError) {
+    *aHeight = 0;
+    return NS_ERROR_FAILURE;
+  }
+
+  *aHeight = mSize.height;
+  return NS_OK;
+}
+
+//******************************************************************************
+NS_IMETHODIMP
+RasterImage::GetIntrinsicSize(nsSize* aSize)
+{
+  if (mError) {
+    return NS_ERROR_FAILURE;
+  }
+
+  *aSize = nsSize(nsPresContext::CSSPixelsToAppUnits(mSize.width),
+                  nsPresContext::CSSPixelsToAppUnits(mSize.height));
+  return NS_OK;
+}
+
+//******************************************************************************
+NS_IMETHODIMP
+RasterImage::GetIntrinsicRatio(nsSize* aRatio)
+{
+  if (mError) {
+    return NS_ERROR_FAILURE;
+  }
+
+  *aRatio = nsSize(mSize.width, mSize.height);
+  return NS_OK;
+}
+
+NS_IMETHODIMP_(Orientation)
+RasterImage::GetOrientation()
+{
+  return mOrientation;
+}
+
+//******************************************************************************
+NS_IMETHODIMP
+RasterImage::GetType(uint16_t* aType)
+{
+  NS_ENSURE_ARG_POINTER(aType);
+
+  *aType = imgIContainer::TYPE_RASTER;
+  return NS_OK;
+}
+
+LookupResult
+RasterImage::LookupFrameInternal(const IntSize& aSize,
+                                 uint32_t aFlags,
+                                 PlaybackType aPlaybackType)
+{
+  if (mAnimationState && aPlaybackType == PlaybackType::eAnimated) {
+    MOZ_ASSERT(mFrameAnimator);
+    MOZ_ASSERT(ToSurfaceFlags(aFlags) == DefaultSurfaceFlags(),
+               "Can't composite frames with non-default surface flags");
+    const size_t index = mAnimationState->GetCurrentAnimationFrameIndex();
+    return mFrameAnimator->GetCompositedFrame(index);
+  }
+
+  SurfaceFlags surfaceFlags = ToSurfaceFlags(aFlags);
+
+  // We don't want any substitution for sync decodes, and substitution would be
+  // illegal when high quality downscaling is disabled, so we use
+  // SurfaceCache::Lookup in this case.
+  if ((aFlags & FLAG_SYNC_DECODE) || !(aFlags & FLAG_HIGH_QUALITY_SCALING)) {
+    return SurfaceCache::Lookup(ImageKey(this),
+                                RasterSurfaceKey(aSize,
+                                                 surfaceFlags,
+                                                 PlaybackType::eStatic));
+  }
+
+  // We'll return the best match we can find to the requested frame.
+  return SurfaceCache::LookupBestMatch(ImageKey(this),
+                                       RasterSurfaceKey(aSize,
+                                                        surfaceFlags,
+                                                        PlaybackType::eStatic));
+}
+
+DrawableSurface
+RasterImage::LookupFrame(const IntSize& aSize,
+                         uint32_t aFlags,
+                         PlaybackType aPlaybackType)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // If we're opaque, we don't need to care about premultiplied alpha, because
+  // that can only matter for frames with transparency.
+  if (IsOpaque()) {
+    aFlags &= ~FLAG_DECODE_NO_PREMULTIPLY_ALPHA;
+  }
+
+  IntSize requestedSize = CanDownscaleDuringDecode(aSize, aFlags)
+                        ? aSize : mSize;
+  if (requestedSize.IsEmpty()) {
+    return DrawableSurface();  // Can't decode to a surface of zero size.
+  }
+
+  LookupResult result =
+    LookupFrameInternal(requestedSize, aFlags, aPlaybackType);
+
+  if (!result && !mHasSize) {
+    // We can't request a decode without knowing our intrinsic size. Give up.
+    return DrawableSurface();
+  }
+
+  if (result.Type() == MatchType::NOT_FOUND ||
+      result.Type() == MatchType::SUBSTITUTE_BECAUSE_NOT_FOUND ||
+      ((aFlags & FLAG_SYNC_DECODE) && !result)) {
+    // We don't have a copy of this frame, and there's no decoder working on
+    // one. (Or we're sync decoding and the existing decoder hasn't even started
+    // yet.) Trigger decoding so it'll be available next time.
+    MOZ_ASSERT(aPlaybackType != PlaybackType::eAnimated ||
+               !mAnimationState || mAnimationState->KnownFrameCount() < 1,
+               "Animated frames should be locked");
+
+    Decode(requestedSize, aFlags, aPlaybackType);
+
+    // If we can sync decode, we should already have the frame.
+    if (aFlags & FLAG_SYNC_DECODE) {
+      result = LookupFrameInternal(requestedSize, aFlags, aPlaybackType);
+    }
+  }
+
+  if (!result) {
+    // We still weren't able to get a frame. Give up.
+    return DrawableSurface();
+  }
+
+  if (result.Surface()->GetCompositingFailed()) {
+    return DrawableSurface();
+  }
+
+  MOZ_ASSERT(!result.Surface()->GetIsPaletted(),
+             "Should not have a paletted frame");
+
+  // Sync decoding guarantees that we got the frame, but if it's owned by an
+  // async decoder that's currently running, the contents of the frame may not
+  // be available yet. Make sure we get everything.
+  if (mHasSourceData && (aFlags & FLAG_SYNC_DECODE)) {
+    result.Surface()->WaitUntilFinished();
+  }
+
+  // If we could have done some decoding in this function we need to check if
+  // that decoding encountered an error and hence aborted the surface. We want
+  // to avoid calling IsAborted if we weren't passed any sync decode flag because
+  // IsAborted acquires the monitor for the imgFrame.
+  if (aFlags & (FLAG_SYNC_DECODE | FLAG_SYNC_DECODE_IF_FAST) &&
+    result.Surface()->IsAborted()) {
+    return DrawableSurface();
+  }
+
+  return Move(result.Surface());
+}
+
+bool
+RasterImage::IsOpaque()
+{
+  if (mError) {
+    return false;
+  }
+
+  Progress progress = mProgressTracker->GetProgress();
+
+  // If we haven't yet finished decoding, the safe answer is "not opaque".
+  if (!(progress & FLAG_DECODE_COMPLETE)) {
+    return false;
+  }
+
+  // Other, we're opaque if FLAG_HAS_TRANSPARENCY is not set.
+  return !(progress & FLAG_HAS_TRANSPARENCY);
+}
+
+NS_IMETHODIMP_(bool)
+RasterImage::WillDrawOpaqueNow()
+{
+  if (!IsOpaque()) {
+    return false;
+  }
+
+  if (mAnimationState) {
+    // We never discard frames of animated images.
+    return true;
+  }
+
+  // If we are not locked our decoded data could get discard at any time (ie
+  // between the call to this function and when we are asked to draw), so we
+  // have to return false if we are unlocked.
+  if (IsUnlocked()) {
+    return false;
+  }
+
+  LookupResult result =
+    SurfaceCache::LookupBestMatch(ImageKey(this),
+                                  RasterSurfaceKey(mSize,
+                                                   DefaultSurfaceFlags(),
+                                                   PlaybackType::eStatic));
+  MatchType matchType = result.Type();
+  if (matchType == MatchType::NOT_FOUND || matchType == MatchType::PENDING ||
+      !result.Surface()->IsFinished()) {
+    return false;
+  }
+
+  return true;
+}
+
+void
+RasterImage::OnSurfaceDiscarded()
+{
+  MOZ_ASSERT(mProgressTracker);
+
+  NS_DispatchToMainThread(NewRunnableMethod(mProgressTracker, &ProgressTracker::OnDiscard));
+}
+
+//******************************************************************************
+NS_IMETHODIMP
+RasterImage::GetAnimated(bool* aAnimated)
+{
+  if (mError) {
+    return NS_ERROR_FAILURE;
+  }
+
+  NS_ENSURE_ARG_POINTER(aAnimated);
+
+  // If we have an AnimationState, we can know for sure.
+  if (mAnimationState) {
+    *aAnimated = true;
+    return NS_OK;
+  }
+
+  // Otherwise, we need to have been decoded to know for sure, since if we were
+  // decoded at least once mAnimationState would have been created for animated
+  // images. This is true even though we check for animation during the
+  // metadata decode, because we may still discover animation only during the
+  // full decode for corrupt images.
+  if (!mHasBeenDecoded) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  // We know for sure
+  *aAnimated = false;
+
+  return NS_OK;
+}
+
+//******************************************************************************
+NS_IMETHODIMP_(int32_t)
+RasterImage::GetFirstFrameDelay()
+{
+  if (mError) {
+    return -1;
+  }
+
+  bool animated = false;
+  if (NS_FAILED(GetAnimated(&animated)) || !animated) {
+    return -1;
+  }
+
+  MOZ_ASSERT(mAnimationState, "Animated images should have an AnimationState");
+  return mAnimationState->FirstFrameTimeout().AsEncodedValueDeprecated();
+}
+
+NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
+RasterImage::GetFrame(uint32_t aWhichFrame,
+                      uint32_t aFlags)
+{
+  return GetFrameInternal(mSize, aWhichFrame, aFlags).second().forget();
+}
+
+NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
+RasterImage::GetFrameAtSize(const IntSize& aSize,
+                            uint32_t aWhichFrame,
+                            uint32_t aFlags)
+{
+  return GetFrameInternal(aSize, aWhichFrame, aFlags).second().forget();
+}
+
+Pair<DrawResult, RefPtr<SourceSurface>>
+RasterImage::GetFrameInternal(const IntSize& aSize,
+                              uint32_t aWhichFrame,
+                              uint32_t aFlags)
+{
+  MOZ_ASSERT(aWhichFrame <= FRAME_MAX_VALUE);
+
+  if (aSize.IsEmpty()) {
+    return MakePair(DrawResult::BAD_ARGS, RefPtr<SourceSurface>());
+  }
+
+  if (aWhichFrame > FRAME_MAX_VALUE) {
+    return MakePair(DrawResult::BAD_ARGS, RefPtr<SourceSurface>());
+  }
+
+  if (mError) {
+    return MakePair(DrawResult::BAD_IMAGE, RefPtr<SourceSurface>());
+  }
+
+  // Get the frame. If it's not there, it's probably the caller's fault for
+  // not waiting for the data to be loaded from the network or not passing
+  // FLAG_SYNC_DECODE.
+  DrawableSurface surface =
+    LookupFrame(aSize, aFlags, ToPlaybackType(aWhichFrame));
+  if (!surface) {
+    // The OS threw this frame away and we couldn't redecode it.
+    return MakePair(DrawResult::TEMPORARY_ERROR, RefPtr<SourceSurface>());
+  }
+
+  RefPtr<SourceSurface> sourceSurface = surface->GetSourceSurface();
+
+  if (!surface->IsFinished()) {
+    return MakePair(DrawResult::INCOMPLETE, Move(sourceSurface));
+  }
+
+  return MakePair(DrawResult::SUCCESS, Move(sourceSurface));
+}
+
+Pair<DrawResult, RefPtr<layers::Image>>
+RasterImage::GetCurrentImage(ImageContainer* aContainer, uint32_t aFlags)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aContainer);
+
+  DrawResult drawResult;
+  RefPtr<SourceSurface> surface;
+  Tie(drawResult, surface) =
+    GetFrameInternal(mSize, FRAME_CURRENT, aFlags | FLAG_ASYNC_NOTIFY);
+  if (!surface) {
+    // The OS threw out some or all of our buffer. We'll need to wait for the
+    // redecode (which was automatically triggered by GetFrame) to complete.
+    return MakePair(drawResult, RefPtr<layers::Image>());
+  }
+
+  RefPtr<layers::Image> image = new layers::SourceSurfaceImage(surface);
+  return MakePair(drawResult, Move(image));
+}
+
+NS_IMETHODIMP_(bool)
+RasterImage::IsImageContainerAvailable(LayerManager* aManager, uint32_t aFlags)
+{
+  int32_t maxTextureSize = aManager->GetMaxTextureSize();
+  if (!mHasSize ||
+      mSize.width > maxTextureSize ||
+      mSize.height > maxTextureSize) {
+    return false;
+  }
+
+  return true;
+}
+
+NS_IMETHODIMP_(already_AddRefed<ImageContainer>)
+RasterImage::GetImageContainer(LayerManager* aManager, uint32_t aFlags)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aManager);
+  MOZ_ASSERT((aFlags & ~(FLAG_SYNC_DECODE |
+                         FLAG_SYNC_DECODE_IF_FAST |
+                         FLAG_ASYNC_NOTIFY))
+               == FLAG_NONE,
+             "Unsupported flag passed to GetImageContainer");
+
+  int32_t maxTextureSize = aManager->GetMaxTextureSize();
+  if (!mHasSize ||
+      mSize.width > maxTextureSize ||
+      mSize.height > maxTextureSize) {
+    return nullptr;
+  }
+
+  if (IsUnlocked() && mProgressTracker) {
+    mProgressTracker->OnUnlockedDraw();
+  }
+
+  RefPtr<layers::ImageContainer> container = mImageContainer.get();
+
+  bool mustRedecode =
+    (aFlags & (FLAG_SYNC_DECODE | FLAG_SYNC_DECODE_IF_FAST)) &&
+    mLastImageContainerDrawResult != DrawResult::SUCCESS &&
+    mLastImageContainerDrawResult != DrawResult::BAD_IMAGE;
+
+  if (container && !mustRedecode) {
+    return container.forget();
+  }
+
+  // We need a new ImageContainer, so create one.
+  container = LayerManager::CreateImageContainer();
+
+  DrawResult drawResult;
+  RefPtr<layers::Image> image;
+  Tie(drawResult, image) = GetCurrentImage(container, aFlags);
+  if (!image) {
+    return nullptr;
+  }
+
+  // |image| holds a reference to a SourceSurface which in turn holds a lock on
+  // the current frame's VolatileBuffer, ensuring that it doesn't get freed as
+  // long as the layer system keeps this ImageContainer alive.
+  AutoTArray<ImageContainer::NonOwningImage, 1> imageList;
+  imageList.AppendElement(ImageContainer::NonOwningImage(image, TimeStamp(),
+                                                         mLastFrameID++,
+                                                         mImageProducerID));
+  container->SetCurrentImagesInTransaction(imageList);
+
+  mLastImageContainerDrawResult = drawResult;
+  mImageContainer = container;
+
+  return container.forget();
+}
+
+void
+RasterImage::UpdateImageContainer()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  RefPtr<layers::ImageContainer> container = mImageContainer.get();
+  if (!container) {
+    return;
+  }
+
+  DrawResult drawResult;
+  RefPtr<layers::Image> image;
+  Tie(drawResult, image) = GetCurrentImage(container, FLAG_NONE);
+  if (!image) {
+    return;
+  }
+
+  mLastImageContainerDrawResult = drawResult;
+  AutoTArray<ImageContainer::NonOwningImage, 1> imageList;
+  imageList.AppendElement(ImageContainer::NonOwningImage(image, TimeStamp(),
+                                                         mLastFrameID++,
+                                                         mImageProducerID));
+  container->SetCurrentImages(imageList);
+}
+
+size_t
+RasterImage::SizeOfSourceWithComputedFallback(MallocSizeOf aMallocSizeOf) const
+{
+  return mSourceBuffer->SizeOfIncludingThisWithComputedFallback(aMallocSizeOf);
+}
+
+void
+RasterImage::CollectSizeOfSurfaces(nsTArray<SurfaceMemoryCounter>& aCounters,
+                                   MallocSizeOf aMallocSizeOf) const
+{
+  SurfaceCache::CollectSizeOfSurfaces(ImageKey(this), aCounters, aMallocSizeOf);
+  if (mFrameAnimator) {
+    mFrameAnimator->CollectSizeOfCompositingSurfaces(aCounters, aMallocSizeOf);
+  }
+}
+
+bool
+RasterImage::SetMetadata(const ImageMetadata& aMetadata,
+                         bool aFromMetadataDecode)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mError) {
+    return true;
+  }
+
+  if (aMetadata.HasSize()) {
+    IntSize size = aMetadata.GetSize();
+    if (size.width < 0 || size.height < 0) {
+      NS_WARNING("Image has negative intrinsic size");
+      DoError();
+      return true;
+    }
+
+    MOZ_ASSERT(aMetadata.HasOrientation());
+    Orientation orientation = aMetadata.GetOrientation();
+
+    // If we already have a size, check the new size against the old one.
+    if (mHasSize && (size != mSize || orientation != mOrientation)) {
+      NS_WARNING("Image changed size or orientation on redecode! "
+                 "This should not happen!");
+      DoError();
+      return true;
+    }
+
+    // Set the size and flag that we have it.
+    mSize = size;
+    mOrientation = orientation;
+    mHasSize = true;
+  }
+
+  if (mHasSize && aMetadata.HasAnimation() && !mAnimationState) {
+    // We're becoming animated, so initialize animation stuff.
+    mAnimationState.emplace(mAnimationMode);
+    mFrameAnimator = MakeUnique<FrameAnimator>(this, mSize);
+
+    // We don't support discarding animated images (See bug 414259).
+    // Lock the image and throw away the key.
+    LockImage();
+
+    if (!aFromMetadataDecode) {
+      // The metadata decode reported that this image isn't animated, but we
+      // discovered that it actually was during the full decode. This is a
+      // rare failure that only occurs for corrupt images. To recover, we need
+      // to discard all existing surfaces and redecode.
+      return false;
+    }
+  }
+
+  if (mAnimationState) {
+    mAnimationState->SetLoopCount(aMetadata.GetLoopCount());
+    mAnimationState->SetFirstFrameTimeout(aMetadata.GetFirstFrameTimeout());
+
+    if (aMetadata.HasLoopLength()) {
+      mAnimationState->SetLoopLength(aMetadata.GetLoopLength());
+    }
+    if (aMetadata.HasFirstFrameRefreshArea()) {
+      mAnimationState
+        ->SetFirstFrameRefreshArea(aMetadata.GetFirstFrameRefreshArea());
+    }
+  }
+
+  if (aMetadata.HasHotspot()) {
+    IntPoint hotspot = aMetadata.GetHotspot();
+
+    nsCOMPtr<nsISupportsPRUint32> intwrapx =
+      do_CreateInstance(NS_SUPPORTS_PRUINT32_CONTRACTID);
+    nsCOMPtr<nsISupportsPRUint32> intwrapy =
+      do_CreateInstance(NS_SUPPORTS_PRUINT32_CONTRACTID);
+    intwrapx->SetData(hotspot.x);
+    intwrapy->SetData(hotspot.y);
+
+    Set("hotspotX", intwrapx);
+    Set("hotspotY", intwrapy);
+  }
+
+  return true;
+}
+
+NS_IMETHODIMP
+RasterImage::SetAnimationMode(uint16_t aAnimationMode)
+{
+  if (mAnimationState) {
+    mAnimationState->SetAnimationMode(aAnimationMode);
+  }
+  return SetAnimationModeInternal(aAnimationMode);
+}
+
+//******************************************************************************
+
+nsresult
+RasterImage::StartAnimation()
+{
+  if (mError) {
+    return NS_ERROR_FAILURE;
+  }
+
+  MOZ_ASSERT(ShouldAnimate(), "Should not animate!");
+
+  // If we're not ready to animate, then set mPendingAnimation, which will cause
+  // us to start animating if and when we do become ready.
+  mPendingAnimation = !mAnimationState || mAnimationState->KnownFrameCount() < 1;
+  if (mPendingAnimation) {
+    return NS_OK;
+  }
+
+  // Don't bother to animate if we're displaying the first frame forever.
+  if (mAnimationState->GetCurrentAnimationFrameIndex() == 0 &&
+      mAnimationState->FirstFrameTimeout() == FrameTimeout::Forever()) {
+    mAnimationFinished = true;
+    return NS_ERROR_ABORT;
+  }
+
+  // We need to set the time that this initial frame was first displayed, as
+  // this is used in AdvanceFrame().
+  mAnimationState->InitAnimationFrameTimeIfNecessary();
+
+  return NS_OK;
+}
+
+//******************************************************************************
+nsresult
+RasterImage::StopAnimation()
+{
+  MOZ_ASSERT(mAnimating, "Should be animating!");
+
+  nsresult rv = NS_OK;
+  if (mError) {
+    rv = NS_ERROR_FAILURE;
+  } else {
+    mAnimationState->SetAnimationFrameTime(TimeStamp());
+  }
+
+  mAnimating = false;
+  return rv;
+}
+
+//******************************************************************************
+NS_IMETHODIMP
+RasterImage::ResetAnimation()
+{
+  if (mError) {
+    return NS_ERROR_FAILURE;
+    }
+
+  mPendingAnimation = false;
+
+  if (mAnimationMode == kDontAnimMode || !mAnimationState ||
+      mAnimationState->GetCurrentAnimationFrameIndex() == 0) {
+    return NS_OK;
+  }
+
+  mAnimationFinished = false;
+
+  if (mAnimating) {
+    StopAnimation();
+  }
+
+  MOZ_ASSERT(mAnimationState, "Should have AnimationState");
+  mAnimationState->ResetAnimation();
+
+  NotifyProgress(NoProgress, mAnimationState->FirstFrameRefreshArea());
+
+  // Start the animation again. It may not have been running before, if
+  // mAnimationFinished was true before entering this function.
+  EvaluateAnimation();
+
+  return NS_OK;
+}
+
+//******************************************************************************
+NS_IMETHODIMP_(void)
+RasterImage::SetAnimationStartTime(const TimeStamp& aTime)
+{
+  if (mError || mAnimationMode == kDontAnimMode || mAnimating || !mAnimationState) {
+    return;
+  }
+
+  mAnimationState->SetAnimationFrameTime(aTime);
+}
+
+NS_IMETHODIMP_(float)
+RasterImage::GetFrameIndex(uint32_t aWhichFrame)
+{
+  MOZ_ASSERT(aWhichFrame <= FRAME_MAX_VALUE, "Invalid argument");
+  return (aWhichFrame == FRAME_FIRST || !mAnimationState)
+         ? 0.0f
+         : mAnimationState->GetCurrentAnimationFrameIndex();
+}
+
+NS_IMETHODIMP_(IntRect)
+RasterImage::GetImageSpaceInvalidationRect(const IntRect& aRect)
+{
+  return aRect;
+}
+
+nsresult
+RasterImage::OnImageDataComplete(nsIRequest*, nsISupports*, nsresult aStatus,
+                                 bool aLastPart)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // Record that we have all the data we're going to get now.
+  mHasSourceData = true;
+
+  // Let decoders know that there won't be any more data coming.
+  mSourceBuffer->Complete(aStatus);
+
+  // Allow a synchronous metadata decode if mSyncLoad was set, or if we're
+  // running on a single thread (in which case waiting for the async metadata
+  // decoder could delay this image's load event quite a bit), or if this image
+  // is transient.
+  bool canSyncDecodeMetadata = mSyncLoad || mTransient ||
+                               DecodePool::NumberOfCores() < 2;
+
+  if (canSyncDecodeMetadata && !mHasSize) {
+    // We're loading this image synchronously, so it needs to be usable after
+    // this call returns.  Since we haven't gotten our size yet, we need to do a
+    // synchronous metadata decode here.
+    DecodeMetadata(FLAG_SYNC_DECODE);
+  }
+
+  // Determine our final status, giving precedence to Necko failure codes. We
+  // check after running the metadata decode in case it triggered an error.
+  nsresult finalStatus = mError ? NS_ERROR_FAILURE : NS_OK;
+  if (NS_FAILED(aStatus)) {
+    finalStatus = aStatus;
+  }
+
+  // If loading failed, report an error.
+  if (NS_FAILED(finalStatus)) {
+    DoError();
+  }
+
+  Progress loadProgress = LoadCompleteProgress(aLastPart, mError, finalStatus);
+
+  if (!mHasSize && !mError) {
+    // We don't have our size yet, so we'll fire the load event in SetSize().
+    MOZ_ASSERT(!canSyncDecodeMetadata,
+               "Firing load async after metadata sync decode?");
+    NotifyProgress(FLAG_ONLOAD_BLOCKED);
+    mLoadProgress = Some(loadProgress);
+    return finalStatus;
+  }
+
+  NotifyForLoadEvent(loadProgress);
+
+  return finalStatus;
+}
+
+void
+RasterImage::NotifyForLoadEvent(Progress aProgress)
+{
+  MOZ_ASSERT(mHasSize || mError, "Need to know size before firing load event");
+  MOZ_ASSERT(!mHasSize ||
+             (mProgressTracker->GetProgress() & FLAG_SIZE_AVAILABLE),
+             "Should have notified that the size is available if we have it");
+
+  // If we encountered an error, make sure we notify for that as well.
+  if (mError) {
+    aProgress |= FLAG_HAS_ERROR;
+  }
+
+  // Notify our listeners, which will fire this image's load event.
+  NotifyProgress(aProgress);
+}
+
+nsresult
+RasterImage::OnImageDataAvailable(nsIRequest*,
+                                  nsISupports*,
+                                  nsIInputStream* aInputStream,
+                                  uint64_t,
+                                  uint32_t aCount)
+{
+  nsresult rv = mSourceBuffer->AppendFromInputStream(aInputStream, aCount);
+  if (NS_FAILED(rv)) {
+    DoError();
+  }
+  return rv;
+}
+
+nsresult
+RasterImage::SetSourceSizeHint(uint32_t aSizeHint)
+{
+  return mSourceBuffer->ExpectLength(aSizeHint);
+}
+
+/********* Methods to implement lazy allocation of nsIProperties object *******/
+NS_IMETHODIMP
+RasterImage::Get(const char* prop, const nsIID& iid, void** result)
+{
+  if (!mProperties) {
+    return NS_ERROR_FAILURE;
+  }
+  return mProperties->Get(prop, iid, result);
+}
+
+NS_IMETHODIMP
+RasterImage::Set(const char* prop, nsISupports* value)
+{
+  if (!mProperties) {
+    mProperties = do_CreateInstance("@mozilla.org/properties;1");
+  }
+  if (!mProperties) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+  return mProperties->Set(prop, value);
+}
+
+NS_IMETHODIMP
+RasterImage::Has(const char* prop, bool* _retval)
+{
+  NS_ENSURE_ARG_POINTER(_retval);
+  if (!mProperties) {
+    *_retval = false;
+    return NS_OK;
+  }
+  return mProperties->Has(prop, _retval);
+}
+
+NS_IMETHODIMP
+RasterImage::Undefine(const char* prop)
+{
+  if (!mProperties) {
+    return NS_ERROR_FAILURE;
+  }
+  return mProperties->Undefine(prop);
+}
+
+NS_IMETHODIMP
+RasterImage::GetKeys(uint32_t* count, char*** keys)
+{
+  if (!mProperties) {
+    *count = 0;
+    *keys = nullptr;
+    return NS_OK;
+  }
+  return mProperties->GetKeys(count, keys);
+}
+
+void
+RasterImage::Discard()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(CanDiscard(), "Asked to discard but can't");
+  MOZ_ASSERT(!mAnimationState, "Asked to discard for animated image");
+
+  // Delete all the decoded frames.
+  SurfaceCache::RemoveImage(ImageKey(this));
+
+  // Notify that we discarded.
+  if (mProgressTracker) {
+    mProgressTracker->OnDiscard();
+  }
+}
+
+bool
+RasterImage::CanDiscard() {
+  return mHasSourceData &&       // ...have the source data...
+         !mAnimationState;       // Can never discard animated images
+}
+
+NS_IMETHODIMP
+RasterImage::StartDecoding()
+{
+  if (mError) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!mHasSize) {
+    mWantFullDecode = true;
+    return NS_OK;
+  }
+
+  return RequestDecodeForSize(mSize, FLAG_SYNC_DECODE_IF_FAST);
+}
+
+NS_IMETHODIMP
+RasterImage::RequestDecodeForSize(const IntSize& aSize, uint32_t aFlags)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mError) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!mHasSize) {
+    return NS_OK;
+  }
+
+  // Decide whether to sync decode images we can decode quickly. Here we are
+  // explicitly trading off flashing for responsiveness in the case that we're
+  // redecoding an image (see bug 845147).
+  bool shouldSyncDecodeIfFast =
+    !mHasBeenDecoded && (aFlags & FLAG_SYNC_DECODE_IF_FAST);
+
+  uint32_t flags = shouldSyncDecodeIfFast
+                 ? aFlags
+                 : aFlags & ~FLAG_SYNC_DECODE_IF_FAST;
+
+  // Perform a frame lookup, which will implicitly start decoding if needed.
+  LookupFrame(aSize, flags, mAnimationState ? PlaybackType::eAnimated
+                                            : PlaybackType::eStatic);
+
+  return NS_OK;
+}
+
+static void
+LaunchDecodingTask(IDecodingTask* aTask,
+                   RasterImage* aImage,
+                   uint32_t aFlags,
+                   bool aHaveSourceData)
+{
+  if (aHaveSourceData) {
+    // If we have all the data, we can sync decode if requested.
+    if (aFlags & imgIContainer::FLAG_SYNC_DECODE) {
+      PROFILER_LABEL_PRINTF("DecodePool", "SyncRunIfPossible",
+        js::ProfileEntry::Category::GRAPHICS,
+        "%s", aImage->GetURIString().get());
+      DecodePool::Singleton()->SyncRunIfPossible(aTask);
+      return;
+    }
+
+    if (aFlags & imgIContainer::FLAG_SYNC_DECODE_IF_FAST) {
+      PROFILER_LABEL_PRINTF("DecodePool", "SyncRunIfPreferred",
+        js::ProfileEntry::Category::GRAPHICS,
+        "%s", aImage->GetURIString().get());
+      DecodePool::Singleton()->SyncRunIfPreferred(aTask);
+      return;
+    }
+  }
+
+  // Perform an async decode. We also take this path if we don't have all the
+  // source data yet, since sync decoding is impossible in that situation.
+  DecodePool::Singleton()->AsyncRun(aTask);
+}
+
+NS_IMETHODIMP
+RasterImage::Decode(const IntSize& aSize,
+                    uint32_t aFlags,
+                    PlaybackType aPlaybackType)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mError) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // If we don't have a size yet, we can't do any other decoding.
+  if (!mHasSize) {
+    mWantFullDecode = true;
+    return NS_OK;
+  }
+
+  // We're about to decode again, which may mean that some of the previous sizes
+  // we've decoded at aren't useful anymore. We can allow them to expire from
+  // the cache by unlocking them here. When the decode finishes, it will send an
+  // invalidation that will cause all instances of this image to redraw. If this
+  // image is locked, any surfaces that are still useful will become locked
+  // again when LookupFrame touches them, and the remainder will eventually
+  // expire.
+  SurfaceCache::UnlockEntries(ImageKey(this));
+
+  // Determine which flags we need to decode this image with.
+  DecoderFlags decoderFlags = DefaultDecoderFlags();
+  if (aFlags & FLAG_ASYNC_NOTIFY) {
+    decoderFlags |= DecoderFlags::ASYNC_NOTIFY;
+  }
+  if (mTransient) {
+    decoderFlags |= DecoderFlags::IMAGE_IS_TRANSIENT;
+  }
+  if (mHasBeenDecoded) {
+    decoderFlags |= DecoderFlags::IS_REDECODE;
+  }
+
+  SurfaceFlags surfaceFlags = ToSurfaceFlags(aFlags);
+  if (IsOpaque()) {
+    // If there's no transparency, it doesn't matter whether we premultiply
+    // alpha or not.
+    surfaceFlags &= ~SurfaceFlags::NO_PREMULTIPLY_ALPHA;
+  }
+
+  // Create a decoder.
+  RefPtr<IDecodingTask> task;
+  if (mAnimationState && aPlaybackType == PlaybackType::eAnimated) {
+    task = DecoderFactory::CreateAnimationDecoder(mDecoderType, WrapNotNull(this),
+                                                  mSourceBuffer, mSize,
+                                                  decoderFlags, surfaceFlags);
+  } else {
+    task = DecoderFactory::CreateDecoder(mDecoderType, WrapNotNull(this),
+                                         mSourceBuffer, mSize, aSize,
+                                         decoderFlags, surfaceFlags,
+                                         mRequestedSampleSize);
+  }
+
+  // Make sure DecoderFactory was able to create a decoder successfully.
+  if (!task) {
+    return NS_ERROR_FAILURE;
+  }
+
+  mDecodeCount++;
+
+  // We're ready to decode; start the decoder.
+  LaunchDecodingTask(task, this, aFlags, mHasSourceData);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+RasterImage::DecodeMetadata(uint32_t aFlags)
+{
+  if (mError) {
+    return NS_ERROR_FAILURE;
+  }
+
+  MOZ_ASSERT(!mHasSize, "Should not do unnecessary metadata decodes");
+
+  // Create a decoder.
+  RefPtr<IDecodingTask> task =
+    DecoderFactory::CreateMetadataDecoder(mDecoderType, WrapNotNull(this),
+                                          mSourceBuffer, mRequestedSampleSize);
+
+  // Make sure DecoderFactory was able to create a decoder successfully.
+  if (!task) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // We're ready to decode; start the decoder.
+  LaunchDecodingTask(task, this, aFlags, mHasSourceData);
+  return NS_OK;
+}
+
+void
+RasterImage::RecoverFromInvalidFrames(const IntSize& aSize, uint32_t aFlags)
+{
+  if (!mHasSize) {
+    return;
+  }
+
+  NS_WARNING("A RasterImage's frames became invalid. Attempting to recover...");
+
+  // Discard all existing frames, since they're probably all now invalid.
+  SurfaceCache::RemoveImage(ImageKey(this));
+
+  // Relock the image if it's supposed to be locked.
+  if (mLockCount > 0) {
+    SurfaceCache::LockImage(ImageKey(this));
+  }
+
+  // Animated images require some special handling, because we normally require
+  // that they never be discarded.
+  if (mAnimationState) {
+    Decode(mSize, aFlags | FLAG_SYNC_DECODE, PlaybackType::eAnimated);
+    ResetAnimation();
+    return;
+  }
+
+  // For non-animated images, it's fine to recover using an async decode.
+  Decode(aSize, aFlags, PlaybackType::eStatic);
+}
+
+static bool
+HaveSkia()
+{
+#ifdef MOZ_ENABLE_SKIA
+  return true;
+#else
+  return false;
+#endif
+}
+
+bool
+RasterImage::CanDownscaleDuringDecode(const IntSize& aSize, uint32_t aFlags)
+{
+  // Check basic requirements: downscale-during-decode is enabled, Skia is
+  // available, this image isn't transient, we have all the source data and know
+  // our size, and the flags allow us to do it.
+  if (!mHasSize || mTransient || !HaveSkia() ||
+      !gfxPrefs::ImageDownscaleDuringDecodeEnabled() ||
+      !(aFlags & imgIContainer::FLAG_HIGH_QUALITY_SCALING)) {
+    return false;
+  }
+
+  // We don't downscale animated images during decode.
+  if (mAnimationState) {
+    return false;
+  }
+
+  // Never upscale.
+  if (aSize.width >= mSize.width || aSize.height >= mSize.height) {
+    return false;
+  }
+
+  // Zero or negative width or height is unacceptable.
+  if (aSize.width < 1 || aSize.height < 1) {
+    return false;
+  }
+
+  // There's no point in scaling if we can't store the result.
+  if (!SurfaceCache::CanHold(aSize)) {
+    return false;
+  }
+
+  return true;
+}
+
+DrawResult
+RasterImage::DrawInternal(DrawableSurface&& aSurface,
+                          gfxContext* aContext,
+                          const IntSize& aSize,
+                          const ImageRegion& aRegion,
+                          SamplingFilter aSamplingFilter,
+                          uint32_t aFlags)
+{
+  gfxContextMatrixAutoSaveRestore saveMatrix(aContext);
+  ImageRegion region(aRegion);
+  bool frameIsFinished = aSurface->IsFinished();
+
+  // By now we may have a frame with the requested size. If not, we need to
+  // adjust the drawing parameters accordingly.
+  IntSize finalSize = aSurface->GetImageSize();
+  bool couldRedecodeForBetterFrame = false;
+  if (finalSize != aSize) {
+    gfx::Size scale(double(aSize.width) / finalSize.width,
+                    double(aSize.height) / finalSize.height);
+    aContext->Multiply(gfxMatrix::Scaling(scale.width, scale.height));
+    region.Scale(1.0 / scale.width, 1.0 / scale.height);
+
+    couldRedecodeForBetterFrame = CanDownscaleDuringDecode(aSize, aFlags);
+  }
+
+  if (!aSurface->Draw(aContext, region, aSamplingFilter, aFlags)) {
+    RecoverFromInvalidFrames(aSize, aFlags);
+    return DrawResult::TEMPORARY_ERROR;
+  }
+  if (!frameIsFinished) {
+    return DrawResult::INCOMPLETE;
+  }
+  if (couldRedecodeForBetterFrame) {
+    return DrawResult::WRONG_SIZE;
+  }
+  return DrawResult::SUCCESS;
+}
+
+//******************************************************************************
+NS_IMETHODIMP_(DrawResult)
+RasterImage::Draw(gfxContext* aContext,
+                  const IntSize& aSize,
+                  const ImageRegion& aRegion,
+                  uint32_t aWhichFrame,
+                  SamplingFilter aSamplingFilter,
+                  const Maybe<SVGImageContext>& /*aSVGContext - ignored*/,
+                  uint32_t aFlags)
+{
+  if (aWhichFrame > FRAME_MAX_VALUE) {
+    return DrawResult::BAD_ARGS;
+  }
+
+  if (mError) {
+    return DrawResult::BAD_IMAGE;
+  }
+
+  // Illegal -- you can't draw with non-default decode flags.
+  // (Disabling colorspace conversion might make sense to allow, but
+  // we don't currently.)
+  if (ToSurfaceFlags(aFlags) != DefaultSurfaceFlags()) {
+    return DrawResult::BAD_ARGS;
+  }
+
+  if (!aContext) {
+    return DrawResult::BAD_ARGS;
+  }
+
+  if (IsUnlocked() && mProgressTracker) {
+    mProgressTracker->OnUnlockedDraw();
+  }
+
+  // If we're not using SamplingFilter::GOOD, we shouldn't high-quality scale or
+  // downscale during decode.
+  uint32_t flags = aSamplingFilter == SamplingFilter::GOOD
+                 ? aFlags
+                 : aFlags & ~FLAG_HIGH_QUALITY_SCALING;
+
+  DrawableSurface surface =
+    LookupFrame(aSize, flags, ToPlaybackType(aWhichFrame));
+  if (!surface) {
+    // Getting the frame (above) touches the image and kicks off decoding.
+    if (mDrawStartTime.IsNull()) {
+      mDrawStartTime = TimeStamp::Now();
+    }
+    return DrawResult::NOT_READY;
+  }
+
+  bool shouldRecordTelemetry = !mDrawStartTime.IsNull() &&
+                               surface->IsFinished();
+
+  auto result = DrawInternal(Move(surface), aContext, aSize,
+                             aRegion, aSamplingFilter, flags);
+
+  if (shouldRecordTelemetry) {
+      TimeDuration drawLatency = TimeStamp::Now() - mDrawStartTime;
+      Telemetry::Accumulate(Telemetry::IMAGE_DECODE_ON_DRAW_LATENCY,
+                            int32_t(drawLatency.ToMicroseconds()));
+      mDrawStartTime = TimeStamp();
+  }
+
+  return result;
+}
+
+//******************************************************************************
+
+NS_IMETHODIMP
+RasterImage::LockImage()
+{
+  MOZ_ASSERT(NS_IsMainThread(),
+             "Main thread to encourage serialization with UnlockImage");
+  if (mError) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // Increment the lock count
+  mLockCount++;
+
+  // Lock this image's surfaces in the SurfaceCache.
+  if (mLockCount == 1) {
+    SurfaceCache::LockImage(ImageKey(this));
+  }
+
+  return NS_OK;
+}
+
+//******************************************************************************
+
+NS_IMETHODIMP
+RasterImage::UnlockImage()
+{
+  MOZ_ASSERT(NS_IsMainThread(),
+             "Main thread to encourage serialization with LockImage");
+  if (mError) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // It's an error to call this function if the lock count is 0
+  MOZ_ASSERT(mLockCount > 0,
+             "Calling UnlockImage with mLockCount == 0!");
+  if (mLockCount == 0) {
+    return NS_ERROR_ABORT;
+  }
+
+  // Decrement our lock count
+  mLockCount--;
+
+  // Unlock this image's surfaces in the SurfaceCache.
+  if (mLockCount == 0 ) {
+    SurfaceCache::UnlockImage(ImageKey(this));
+  }
+
+  return NS_OK;
+}
+
+//******************************************************************************
+
+NS_IMETHODIMP
+RasterImage::RequestDiscard()
+{
+  if (mDiscardable &&      // Enabled at creation time...
+      mLockCount == 0 &&   // ...not temporarily disabled...
+      CanDiscard()) {
+    Discard();
+  }
+
+  return NS_OK;
+}
+
+// Indempotent error flagging routine. If a decoder is open, shuts it down.
+void
+RasterImage::DoError()
+{
+  // If we've flagged an error before, we have nothing to do
+  if (mError) {
+    return;
+  }
+
+  // We can't safely handle errors off-main-thread, so dispatch a worker to
+  // do it.
+  if (!NS_IsMainThread()) {
+    HandleErrorWorker::DispatchIfNeeded(this);
+    return;
+  }
+
+  // Put the container in an error state.
+  mError = true;
+
+  // Stop animation and release our FrameAnimator.
+  if (mAnimating) {
+    StopAnimation();
+  }
+  mAnimationState = Nothing();
+  mFrameAnimator = nullptr;
+
+  // Release all locks.
+  mLockCount = 0;
+  SurfaceCache::UnlockImage(ImageKey(this));
+
+  // Release all frames from the surface cache.
+  SurfaceCache::RemoveImage(ImageKey(this));
+
+  // Invalidate to get rid of any partially-drawn image content.
+  NotifyProgress(NoProgress, IntRect(0, 0, mSize.width, mSize.height));
+
+  MOZ_LOG(gImgLog, LogLevel::Error,
+          ("RasterImage: [this=%p] Error detected for image\n", this));
+}
+
+/* static */ void
+RasterImage::HandleErrorWorker::DispatchIfNeeded(RasterImage* aImage)
+{
+  RefPtr<HandleErrorWorker> worker = new HandleErrorWorker(aImage);
+  NS_DispatchToMainThread(worker);
+}
+
+RasterImage::HandleErrorWorker::HandleErrorWorker(RasterImage* aImage)
+  : mImage(aImage)
+{
+  MOZ_ASSERT(mImage, "Should have image");
+}
+
+NS_IMETHODIMP
+RasterImage::HandleErrorWorker::Run()
+{
+  mImage->DoError();
+
+  return NS_OK;
+}
+
+bool
+RasterImage::ShouldAnimate()
+{
+  return ImageResource::ShouldAnimate() &&
+         mAnimationState &&
+         mAnimationState->KnownFrameCount() >= 1 &&
+         !mAnimationFinished;
+}
+
+#ifdef DEBUG
+NS_IMETHODIMP
+RasterImage::GetFramesNotified(uint32_t* aFramesNotified)
+{
+  NS_ENSURE_ARG_POINTER(aFramesNotified);
+
+  *aFramesNotified = mFramesNotified;
+
+  return NS_OK;
+}
+#endif
+
+void
+RasterImage::NotifyProgress(Progress aProgress,
+                            const IntRect& aInvalidRect /* = IntRect() */,
+                            const Maybe<uint32_t>& aFrameCount /* = Nothing() */,
+                            DecoderFlags aDecoderFlags
+                              /* = DefaultDecoderFlags() */,
+                            SurfaceFlags aSurfaceFlags
+                              /* = DefaultSurfaceFlags() */)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // Ensure that we stay alive long enough to finish notifying.
+  RefPtr<RasterImage> image = this;
+
+  const bool wasDefaultFlags = aSurfaceFlags == DefaultSurfaceFlags();
+
+  if (!aInvalidRect.IsEmpty() && wasDefaultFlags) {
+    // Update our image container since we're invalidating.
+    UpdateImageContainer();
+  }
+
+  if (!(aDecoderFlags & DecoderFlags::FIRST_FRAME_ONLY)) {
+    // We may have decoded new animation frames; update our animation state.
+    MOZ_ASSERT_IF(aFrameCount && *aFrameCount > 1, mAnimationState || mError);
+    if (mAnimationState && aFrameCount) {
+      mAnimationState->UpdateKnownFrameCount(*aFrameCount);
+    }
+
+    // If we should start animating right now, do so.
+    if (mAnimationState && aFrameCount == Some(1u) &&
+        mPendingAnimation && ShouldAnimate()) {
+      StartAnimation();
+    }
+  }
+
+  // Tell the observers what happened.
+  image->mProgressTracker->SyncNotifyProgress(aProgress, aInvalidRect);
+}
+
+void
+RasterImage::NotifyDecodeComplete(const DecoderFinalStatus& aStatus,
+                                  const ImageMetadata& aMetadata,
+                                  const DecoderTelemetry& aTelemetry,
+                                  Progress aProgress,
+                                  const IntRect& aInvalidRect,
+                                  const Maybe<uint32_t>& aFrameCount,
+                                  DecoderFlags aDecoderFlags,
+                                  SurfaceFlags aSurfaceFlags)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // If the decoder detected an error, log it to the error console.
+  if (aStatus.mShouldReportError) {
+    ReportDecoderError();
+  }
+
+  // Record all the metadata the decoder gathered about this image.
+  bool metadataOK = SetMetadata(aMetadata, aStatus.mWasMetadataDecode);
+  if (!metadataOK) {
+    // This indicates a serious error that requires us to discard all existing
+    // surfaces and redecode to recover. We'll drop the results from this
+    // decoder on the floor, since they aren't valid.
+    RecoverFromInvalidFrames(mSize,
+                             FromSurfaceFlags(aSurfaceFlags));
+    return;
+  }
+
+  MOZ_ASSERT(mError || mHasSize || !aMetadata.HasSize(),
+             "SetMetadata should've gotten a size");
+
+  if (!aStatus.mWasMetadataDecode && aStatus.mFinished) {
+    // Flag that we've been decoded before.
+    mHasBeenDecoded = true;
+  }
+
+  // Send out any final notifications.
+  NotifyProgress(aProgress, aInvalidRect, aFrameCount,
+                 aDecoderFlags, aSurfaceFlags);
+
+  if (!(aDecoderFlags & DecoderFlags::FIRST_FRAME_ONLY) &&
+      mHasBeenDecoded && mAnimationState) {
+    // We've finished a full decode of all animation frames and our AnimationState
+    // has been notified about them all, so let it know not to expect anymore.
+    mAnimationState->SetDoneDecoding(true);
+  }
+
+  // Do some telemetry if this isn't a metadata decode.
+  if (!aStatus.mWasMetadataDecode) {
+    if (aTelemetry.mChunkCount) {
+      Telemetry::Accumulate(Telemetry::IMAGE_DECODE_CHUNKS, aTelemetry.mChunkCount);
+    }
+
+    if (aStatus.mFinished) {
+      Telemetry::Accumulate(Telemetry::IMAGE_DECODE_TIME,
+                            int32_t(aTelemetry.mDecodeTime.ToMicroseconds()));
+
+      if (aTelemetry.mSpeedHistogram) {
+        Telemetry::Accumulate(*aTelemetry.mSpeedHistogram, aTelemetry.Speed());
+      }
+    }
+  }
+
+  // Only act on errors if we have no usable frames from the decoder.
+  if (aStatus.mHadError &&
+      (!mAnimationState || mAnimationState->KnownFrameCount() == 0)) {
+    DoError();
+  } else if (aStatus.mWasMetadataDecode && !mHasSize) {
+    DoError();
+  }
+
+  // XXX(aosmond): Can we get this far without mFinished == true?
+  if (aStatus.mFinished && aStatus.mWasMetadataDecode) {
+    // If we were waiting to fire the load event, go ahead and fire it now.
+    if (mLoadProgress) {
+      NotifyForLoadEvent(*mLoadProgress);
+      mLoadProgress = Nothing();
+      NotifyProgress(FLAG_ONLOAD_UNBLOCKED);
+    }
+
+    // If we were a metadata decode and a full decode was requested, do it.
+    if (mWantFullDecode) {
+      mWantFullDecode = false;
+      RequestDecodeForSize(mSize, DECODE_FLAGS_DEFAULT);
+    }
+  }
+}
+
+void
+RasterImage::ReportDecoderError()
+{
+  nsCOMPtr<nsIConsoleService> consoleService =
+    do_GetService(NS_CONSOLESERVICE_CONTRACTID);
+  nsCOMPtr<nsIScriptError> errorObject =
+    do_CreateInstance(NS_SCRIPTERROR_CONTRACTID);
+
+  if (consoleService && errorObject) {
+    nsAutoString msg(NS_LITERAL_STRING("Image corrupt or truncated."));
+    nsAutoString src;
+    if (GetURI()) {
+      nsCString uri;
+      if (GetURI()->GetSpecTruncatedTo1k(uri) == ImageURL::TruncatedTo1k) {
+        msg += NS_LITERAL_STRING(" URI in this note truncated due to length.");
+      }
+      src = NS_ConvertUTF8toUTF16(uri);
+    }
+    if (NS_SUCCEEDED(errorObject->InitWithWindowID(
+                       msg,
+                       src,
+                       EmptyString(), 0, 0, nsIScriptError::errorFlag,
+                       "Image", InnerWindowID()
+                     ))) {
+      consoleService->LogMessage(errorObject);
+    }
+  }
+}
+
+already_AddRefed<imgIContainer>
+RasterImage::Unwrap()
+{
+  nsCOMPtr<imgIContainer> self(this);
+  return self.forget();
+}
+
+void
+RasterImage::PropagateUseCounters(nsIDocument*)
+{
+  // No use counters.
+}
+
+IntSize
+RasterImage::OptimalImageSizeForDest(const gfxSize& aDest, uint32_t aWhichFrame,
+                                     SamplingFilter aSamplingFilter, uint32_t aFlags)
+{
+  MOZ_ASSERT(aDest.width >= 0 || ceil(aDest.width) <= INT32_MAX ||
+             aDest.height >= 0 || ceil(aDest.height) <= INT32_MAX,
+             "Unexpected destination size");
+
+  if (mSize.IsEmpty() || aDest.IsEmpty()) {
+    return IntSize(0, 0);
+  }
+
+  IntSize destSize = IntSize::Ceil(aDest.width, aDest.height);
+
+  if (aSamplingFilter == SamplingFilter::GOOD &&
+      CanDownscaleDuringDecode(destSize, aFlags)) {
+    return destSize;
+  }
+
+  // We can't scale to this size. Use our intrinsic size for now.
+  return mSize;
+}
+
+} // namespace image
+} // namespace mozilla