/* -*- 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/. */

#include "VectorImage.h"

#include "gfx2DGlue.h"

#include "gfxContext.h"

#include "gfxDrawable.h"

#include "gfxPlatform.h"

#include "gfxUtils.h"

#include "imgFrame.h"

#include "mozilla/AutoRestore.h"

#include "mozilla/MemoryReporting.h"

#include "mozilla/dom/SVGSVGElement.h"

#include "mozilla/gfx/2D.h"

#include "mozilla/gfx/gfxVars.h"

#include "mozilla/RefPtr.h"

#include "mozilla/Tuple.h"

#include "nsIDOMEvent.h"

#include "nsIPresShell.h"

#include "nsIStreamListener.h"

#include "nsMimeTypes.h"

#include "nsPresContext.h"

#include "nsRect.h"

#include "nsString.h"

#include "nsStubDocumentObserver.h"

#include "SVGObserverUtils.h"  // for nsSVGRenderingObserver

#include "nsWindowSizes.h"

#include "ImageRegion.h"

#include "ISurfaceProvider.h"

#include "LookupResult.h"

#include "Orientation.h"

#include "SVGDocumentWrapper.h"

#include "SVGDrawingParameters.h"

#include "nsIDOMEventListener.h"

#include "SurfaceCache.h"

#include "nsDocument.h"

// undef the GetCurrentTime macro defined in WinBase.h from the MS Platform SDK

#undef GetCurrentTime

namespace mozilla {

using namespace dom;

using namespace dom::SVGPreserveAspectRatioBinding;

using namespace gfx;

using namespace layers;

namespace image {

// Helper-class: SVGRootRenderingObserver

class SVGRootRenderingObserver final : public nsSVGRenderingObserver {

 public:

  NS_DECL_ISUPPORTS

  SVGRootRenderingObserver(SVGDocumentWrapper* aDocWrapper,

                           VectorImage* aVectorImage)

      : nsSVGRenderingObserver(),

        mDocWrapper(aDocWrapper),

        mVectorImage(aVectorImage),

        mHonoringInvalidations(true) {

    MOZ_ASSERT(mDocWrapper, "Need a non-null SVG document wrapper");

    MOZ_ASSERT(mVectorImage, "Need a non-null VectorImage");

    StartObserving();

    Element* elem = GetTarget();

    MOZ_ASSERT(elem, "no root SVG node for us to observe");

    SVGObserverUtils::AddRenderingObserver(elem, this);

    mInObserverList = true;

  }

  void ResumeHonoringInvalidations() { mHonoringInvalidations = true; }

 protected:

  virtual ~SVGRootRenderingObserver() { StopObserving(); }

  virtual Element* GetTarget() override {

    return mDocWrapper->GetRootSVGElem();

  }

  virtual void OnRenderingChange() override {

    Element* elem = GetTarget();

    MOZ_ASSERT(elem, "missing root SVG node");

    if (mHonoringInvalidations && !mDocWrapper->ShouldIgnoreInvalidation()) {

      nsIFrame* frame = elem->GetPrimaryFrame();

      if (!frame || frame->PresShell()->IsDestroying()) {

        // We're being destroyed. Bail out.

        return;

      }

      // Ignore further invalidations until we draw.

      mHonoringInvalidations = false;

      mVectorImage->InvalidateObserversOnNextRefreshDriverTick();

    }

    // Our caller might've removed us from rendering-observer list.

    // Add ourselves back!

    if (!mInObserverList) {

      SVGObserverUtils::AddRenderingObserver(elem, this);

      mInObserverList = true;

    }

  }

  // Private data

  const RefPtr<SVGDocumentWrapper> mDocWrapper;

  VectorImage* const mVectorImage;  // Raw pointer because it owns me.

  bool mHonoringInvalidations;

};

NS_IMPL_ISUPPORTS(SVGRootRenderingObserver, nsIMutationObserver)

class SVGParseCompleteListener final : public nsStubDocumentObserver {

 public:

  NS_DECL_ISUPPORTS

  SVGParseCompleteListener(nsIDocument* aDocument, VectorImage* aImage)

      : mDocument(aDocument), mImage(aImage) {

    MOZ_ASSERT(mDocument, "Need an SVG document");

    MOZ_ASSERT(mImage, "Need an image");

    mDocument->AddObserver(this);

  }

 private:

  ~SVGParseCompleteListener() {

    if (mDocument) {

      // The document must have been destroyed before we got our event.

      // Otherwise this can't happen, since documents hold strong references to

      // their observers.

      Cancel();

    }

  }

 public:

  void EndLoad(nsIDocument* aDocument) override {

    MOZ_ASSERT(aDocument == mDocument, "Got EndLoad for wrong document?");

    // OnSVGDocumentParsed will release our owner's reference to us, so ensure

    // we stick around long enough to complete our work.

    RefPtr<SVGParseCompleteListener> kungFuDeathGrip(this);

    mImage->OnSVGDocumentParsed();

  }

  void Cancel() {

    MOZ_ASSERT(mDocument, "Duplicate call to Cancel");

    if (mDocument) {

      mDocument->RemoveObserver(this);

      mDocument = nullptr;

    }

  }

 private:

  nsCOMPtr<nsIDocument> mDocument;

  VectorImage* const mImage;  // Raw pointer to owner.

};

NS_IMPL_ISUPPORTS(SVGParseCompleteListener, nsIDocumentObserver)

class SVGLoadEventListener final : public nsIDOMEventListener {

 public:

  NS_DECL_ISUPPORTS

  SVGLoadEventListener(nsIDocument* aDocument, VectorImage* aImage)

      : mDocument(aDocument), mImage(aImage) {

    MOZ_ASSERT(mDocument, "Need an SVG document");

    MOZ_ASSERT(mImage, "Need an image");

    mDocument->AddEventListener(NS_LITERAL_STRING("MozSVGAsImageDocumentLoad"),

                                this, true, false);

    mDocument->AddEventListener(NS_LITERAL_STRING("SVGAbort"), this, true,

                                false);

    mDocument->AddEventListener(NS_LITERAL_STRING("SVGError"), this, true,

                                false);

  }

 private:

  ~SVGLoadEventListener() {

    if (mDocument) {

      // The document must have been destroyed before we got our event.

      // Otherwise this can't happen, since documents hold strong references to

      // their observers.

      Cancel();

    }

  }

 public:

  NS_IMETHOD HandleEvent(nsIDOMEvent* aEvent) override {

    MOZ_ASSERT(mDocument, "Need an SVG document. Received multiple events?");

    // OnSVGDocumentLoaded/OnSVGDocumentError will release our owner's reference

    // to us, so ensure we stick around long enough to complete our work.

    RefPtr<SVGLoadEventListener> kungFuDeathGrip(this);

    nsAutoString eventType;

    aEvent->GetType(eventType);

    MOZ_ASSERT(eventType.EqualsLiteral("MozSVGAsImageDocumentLoad") ||

                   eventType.EqualsLiteral("SVGAbort") ||

                   eventType.EqualsLiteral("SVGError"),

               "Received unexpected event");

    if (eventType.EqualsLiteral("MozSVGAsImageDocumentLoad")) {

      mImage->OnSVGDocumentLoaded();

    } else {

      mImage->OnSVGDocumentError();

    }

    return NS_OK;

  }

  void Cancel() {

    MOZ_ASSERT(mDocument, "Duplicate call to Cancel");

    if (mDocument) {

      mDocument->RemoveEventListener(

          NS_LITERAL_STRING("MozSVGAsImageDocumentLoad"), this, true);

      mDocument->RemoveEventListener(NS_LITERAL_STRING("SVGAbort"), this, true);

      mDocument->RemoveEventListener(NS_LITERAL_STRING("SVGError"), this, true);

      mDocument = nullptr;

    }

  }

 private:

  nsCOMPtr<nsIDocument> mDocument;

  VectorImage* const mImage;  // Raw pointer to owner.

};

NS_IMPL_ISUPPORTS(SVGLoadEventListener, nsIDOMEventListener)

// Helper-class: SVGDrawingCallback

class SVGDrawingCallback : public gfxDrawingCallback {

 public:

  SVGDrawingCallback(SVGDocumentWrapper* aSVGDocumentWrapper,

                     const IntSize& aViewportSize, const IntSize& aSize,

                     uint32_t aImageFlags)

      : mSVGDocumentWrapper(aSVGDocumentWrapper),

        mViewportSize(aViewportSize),

        mSize(aSize),

        mImageFlags(aImageFlags) {}

  virtual bool operator()(gfxContext* aContext, const gfxRect& aFillRect,

                          const SamplingFilter aSamplingFilter,

                          const gfxMatrix& aTransform) override;

 private:

  RefPtr<SVGDocumentWrapper> mSVGDocumentWrapper;

  const IntSize mViewportSize;

  const IntSize mSize;

  uint32_t mImageFlags;

};

// Based loosely on nsSVGIntegrationUtils' PaintFrameCallback::operator()

bool SVGDrawingCallback::operator()(gfxContext* aContext,

                                    const gfxRect& aFillRect,

                                    const SamplingFilter aSamplingFilter,

                                    const gfxMatrix& aTransform) {

  MOZ_ASSERT(mSVGDocumentWrapper, "need an SVGDocumentWrapper");

  // Get (& sanity-check) the helper-doc's presShell

  nsCOMPtr<nsIPresShell> presShell;

  if (NS_FAILED(mSVGDocumentWrapper->GetPresShell(getter_AddRefs(presShell)))) {

    NS_WARNING("Unable to draw -- presShell lookup failed");

    return false;

  }

  MOZ_ASSERT(presShell, "GetPresShell succeeded but returned null");

  gfxContextAutoSaveRestore contextRestorer(aContext);

  // Clip to aFillRect so that we don't paint outside.

  aContext->NewPath();

  aContext->Rectangle(aFillRect);

  aContext->Clip();

  gfxMatrix matrix = aTransform;

  if (!matrix.Invert()) {

    return false;

  }

  aContext->SetMatrixDouble(

      aContext->CurrentMatrixDouble().PreMultiply(matrix).PreScale(

          double(mSize.width) / mViewportSize.width,

          double(mSize.height) / mViewportSize.height));

  nsPresContext* presContext = presShell->GetPresContext();

  MOZ_ASSERT(presContext, "pres shell w/out pres context");

  nsRect svgRect(0, 0, presContext->DevPixelsToAppUnits(mViewportSize.width),

                 presContext->DevPixelsToAppUnits(mViewportSize.height));

  uint32_t renderDocFlags = nsIPresShell::RENDER_IGNORE_VIEWPORT_SCROLLING;

  if (!(mImageFlags & imgIContainer::FLAG_SYNC_DECODE)) {

    renderDocFlags |= nsIPresShell::RENDER_ASYNC_DECODE_IMAGES;

  }

  presShell->RenderDocument(svgRect, renderDocFlags,

                            NS_RGBA(0, 0, 0, 0),  // transparent

                            aContext);

  return true;

}

class MOZ_STACK_CLASS AutoRestoreSVGState final {

 public:

  AutoRestoreSVGState(const SVGDrawingParameters& aParams,

                      SVGDocumentWrapper* aSVGDocumentWrapper, bool& aIsDrawing,

                      bool aContextPaint)

      : mIsDrawing(aIsDrawing)

        // Apply any 'preserveAspectRatio' override (if specified) to the root

        // element:

        ,

        mPAR(aParams.svgContext, aSVGDocumentWrapper->GetRootSVGElem())

        // Set the animation time:

        ,

        mTime(aSVGDocumentWrapper->GetRootSVGElem(), aParams.animationTime) {

    MOZ_ASSERT(!aIsDrawing);

    aIsDrawing = true;

    // Set context paint (if specified) on the document:

    if (aContextPaint) {

      mContextPaint.emplace(aParams.svgContext->GetContextPaint(),

                            aSVGDocumentWrapper->GetDocument());

    }

  }

 private:

  AutoRestore<bool> mIsDrawing;

  AutoPreserveAspectRatioOverride mPAR;

  AutoSVGTimeSetRestore mTime;

  Maybe<AutoSetRestoreSVGContextPaint> mContextPaint;

};

// Implement VectorImage's nsISupports-inherited methods

NS_IMPL_ISUPPORTS(VectorImage, imgIContainer, nsIStreamListener,

                  nsIRequestObserver)

//------------------------------------------------------------------------------

// Constructor / Destructor

VectorImage::VectorImage(ImageURL* aURI /* = nullptr */)

    : ImageResource(aURI),  // invoke superclass's constructor

      mLockCount(0),

      mIsInitialized(false),

      mIsFullyLoaded(false),

      mIsDrawing(false),

      mHaveAnimations(false),

      mHasPendingInvalidation(false) {}

VectorImage::~VectorImage() {

  CancelAllListeners();

  SurfaceCache::RemoveImage(ImageKey(this));

}

//------------------------------------------------------------------------------

// Methods inherited from Image.h

nsresult VectorImage::Init(const char* aMimeType, uint32_t aFlags) {

  // We don't support re-initialization

  if (mIsInitialized) {

    return NS_ERROR_ILLEGAL_VALUE;

  }

  MOZ_ASSERT(!mIsFullyLoaded && !mHaveAnimations && !mError,

             "Flags unexpectedly set before initialization");

  MOZ_ASSERT(!strcmp(aMimeType, IMAGE_SVG_XML), "Unexpected mimetype");

  mDiscardable = !!(aFlags & INIT_FLAG_DISCARDABLE);

  // Lock this image's surfaces in the SurfaceCache if we're not discardable.

  if (!mDiscardable) {

    mLockCount++;

    SurfaceCache::LockImage(ImageKey(this));

  }

  mIsInitialized = true;

  return NS_OK;

}

size_t VectorImage::SizeOfSourceWithComputedFallback(

    SizeOfState& aState) const {

  if (!mSVGDocumentWrapper) {

    return 0;  // No document, so no memory used for the document.

  }

  nsIDocument* doc = mSVGDocumentWrapper->GetDocument();

  if (!doc) {

    return 0;  // No document, so no memory used for the document.

  }

  nsWindowSizes windowSizes(aState);

  doc->DocAddSizeOfIncludingThis(windowSizes);

  if (windowSizes.getTotalSize() == 0) {

    // MallocSizeOf fails on this platform. Because we also use this method for

    // determining the size of cache entries, we need to return something

    // reasonable here. Unfortunately, there's no way to estimate the document's

    // size accurately, so we just use a constant value of 100KB, which will

    // generally underestimate the true size.

    return 100 * 1024;

  }

  return windowSizes.getTotalSize();

}

void VectorImage::CollectSizeOfSurfaces(

    nsTArray<SurfaceMemoryCounter>& aCounters,

    MallocSizeOf aMallocSizeOf) const {

  SurfaceCache::CollectSizeOfSurfaces(ImageKey(this), aCounters, aMallocSizeOf);

}

nsresult VectorImage::OnImageDataComplete(nsIRequest* aRequest,

                                          nsISupports* aContext,

                                          nsresult aStatus, bool aLastPart) {

  // Call our internal OnStopRequest method, which only talks to our embedded

  // SVG document. This won't have any effect on our ProgressTracker.

  nsresult finalStatus = OnStopRequest(aRequest, aContext, aStatus);

  // Give precedence to Necko failure codes.

  if (NS_FAILED(aStatus)) {

    finalStatus = aStatus;

  }

  Progress loadProgress = LoadCompleteProgress(aLastPart, mError, finalStatus);

  if (mIsFullyLoaded || mError) {

    // Our document is loaded, so we're ready to notify now.

    mProgressTracker->SyncNotifyProgress(loadProgress);

  } else {

    // Record our progress so far; we'll actually send the notifications in

    // OnSVGDocumentLoaded or OnSVGDocumentError.

    mLoadProgress = Some(loadProgress);

  }

  return finalStatus;

}

nsresult VectorImage::OnImageDataAvailable(nsIRequest* aRequest,

                                           nsISupports* aContext,

                                           nsIInputStream* aInStr,

                                           uint64_t aSourceOffset,

                                           uint32_t aCount) {

  return OnDataAvailable(aRequest, aContext, aInStr, aSourceOffset, aCount);

}

nsresult VectorImage::StartAnimation() {

  if (mError) {

    return NS_ERROR_FAILURE;

  }

  MOZ_ASSERT(ShouldAnimate(), "Should not animate!");

  mSVGDocumentWrapper->StartAnimation();

  return NS_OK;

}

nsresult VectorImage::StopAnimation() {

  nsresult rv = NS_OK;

  if (mError) {

    rv = NS_ERROR_FAILURE;

  } else {

    MOZ_ASSERT(mIsFullyLoaded && mHaveAnimations,

               "Should not have been animating!");

    mSVGDocumentWrapper->StopAnimation();

  }

  mAnimating = false;

  return rv;

}

bool VectorImage::ShouldAnimate() {

  return ImageResource::ShouldAnimate() && mIsFullyLoaded && mHaveAnimations;

}

NS_IMETHODIMP_(void)

VectorImage::SetAnimationStartTime(const TimeStamp& aTime) {

  // We don't care about animation start time.

}

//------------------------------------------------------------------------------

// imgIContainer methods

//******************************************************************************

NS_IMETHODIMP

VectorImage::GetWidth(int32_t* aWidth) {

  if (mError || !mIsFullyLoaded) {

    // XXXdholbert Technically we should leave outparam untouched when we

    // fail. But since many callers don't check for failure, we set it to 0 on

    // failure, for sane/predictable results.

    *aWidth = 0;

    return NS_ERROR_FAILURE;

  }

  SVGSVGElement* rootElem = mSVGDocumentWrapper->GetRootSVGElem();

  MOZ_ASSERT(rootElem,

             "Should have a root SVG elem, since we finished "

             "loading without errors");

  int32_t rootElemWidth = rootElem->GetIntrinsicWidth();

  if (rootElemWidth < 0) {

    *aWidth = 0;

    return NS_ERROR_FAILURE;

  }

  *aWidth = rootElemWidth;

  return NS_OK;

}

//******************************************************************************

nsresult VectorImage::GetNativeSizes(nsTArray<IntSize>& aNativeSizes) const {

  return NS_ERROR_NOT_IMPLEMENTED;

}

//******************************************************************************

size_t VectorImage::GetNativeSizesLength() const { return 0; }

//******************************************************************************

NS_IMETHODIMP_(void)

VectorImage::RequestRefresh(const TimeStamp& aTime) {

  if (HadRecentRefresh(aTime)) {

    return;

  }

  PendingAnimationTracker* tracker =

      mSVGDocumentWrapper->GetDocument()->GetPendingAnimationTracker();

  if (tracker && ShouldAnimate()) {

    tracker->TriggerPendingAnimationsOnNextTick(aTime);

  }

  EvaluateAnimation();

  mSVGDocumentWrapper->TickRefreshDriver();

  if (mHasPendingInvalidation) {

    mHasPendingInvalidation = false;

    SendInvalidationNotifications();

  }

}

void VectorImage::SendInvalidationNotifications() {

  // Animated images don't send out invalidation notifications as soon as

  // they're generated. Instead, InvalidateObserversOnNextRefreshDriverTick

  // records that there are pending invalidations and then returns immediately.

  // The notifications are actually sent from RequestRefresh(). We send these

  // notifications there to ensure that there is actually a document observing

  // us. Otherwise, the notifications are just wasted effort.

  //

  // Non-animated images call this method directly from

  // InvalidateObserversOnNextRefreshDriverTick, because RequestRefresh is never

  // called for them. Ordinarily this isn't needed, since we send out

  // invalidation notifications in OnSVGDocumentLoaded, but in rare cases the

  // SVG document may not be 100% ready to render at that time. In those cases

  // we would miss the subsequent invalidations if we didn't send out the

  // notifications directly in |InvalidateObservers...|.

  if (mProgressTracker) {

    SurfaceCache::RemoveImage(ImageKey(this));

    mProgressTracker->SyncNotifyProgress(FLAG_FRAME_COMPLETE,

                                         GetMaxSizedIntRect());

  }

  UpdateImageContainer();

}

NS_IMETHODIMP_(IntRect)

VectorImage::GetImageSpaceInvalidationRect(const IntRect& aRect) {

  return aRect;

}

//******************************************************************************

NS_IMETHODIMP

VectorImage::GetHeight(int32_t* aHeight) {

  if (mError || !mIsFullyLoaded) {

    // XXXdholbert Technically we should leave outparam untouched when we

    // fail. But since many callers don't check for failure, we set it to 0 on

    // failure, for sane/predictable results.

    *aHeight = 0;

    return NS_ERROR_FAILURE;

  }

  SVGSVGElement* rootElem = mSVGDocumentWrapper->GetRootSVGElem();

  MOZ_ASSERT(rootElem,

             "Should have a root SVG elem, since we finished "

             "loading without errors");

  int32_t rootElemHeight = rootElem->GetIntrinsicHeight();

  if (rootElemHeight < 0) {

    *aHeight = 0;

    return NS_ERROR_FAILURE;

  }

  *aHeight = rootElemHeight;

  return NS_OK;

}

//******************************************************************************

NS_IMETHODIMP

VectorImage::GetIntrinsicSize(nsSize* aSize) {

  if (mError || !mIsFullyLoaded) {

    return NS_ERROR_FAILURE;

  }

  nsIFrame* rootFrame = mSVGDocumentWrapper->GetRootLayoutFrame();

  if (!rootFrame) {

    return NS_ERROR_FAILURE;

  }

  *aSize = nsSize(-1, -1);

  IntrinsicSize rfSize = rootFrame->GetIntrinsicSize();

  if (rfSize.width.GetUnit() == eStyleUnit_Coord) {

    aSize->width = rfSize.width.GetCoordValue();

  }

  if (rfSize.height.GetUnit() == eStyleUnit_Coord) {

    aSize->height = rfSize.height.GetCoordValue();

  }

  return NS_OK;

}

//******************************************************************************

NS_IMETHODIMP

VectorImage::GetIntrinsicRatio(nsSize* aRatio) {

  if (mError || !mIsFullyLoaded) {

    return NS_ERROR_FAILURE;

  }

  nsIFrame* rootFrame = mSVGDocumentWrapper->GetRootLayoutFrame();

  if (!rootFrame) {

    return NS_ERROR_FAILURE;

  }

  *aRatio = rootFrame->GetIntrinsicRatio();

  return NS_OK;

}

NS_IMETHODIMP_(Orientation)

VectorImage::GetOrientation() { return Orientation(); }

//******************************************************************************

NS_IMETHODIMP

VectorImage::GetType(uint16_t* aType) {

  NS_ENSURE_ARG_POINTER(aType);

  *aType = imgIContainer::TYPE_VECTOR;

  return NS_OK;

}

//******************************************************************************

NS_IMETHODIMP

VectorImage::GetAnimated(bool* aAnimated) {

  if (mError || !mIsFullyLoaded) {

    return NS_ERROR_FAILURE;

  }

  *aAnimated = mSVGDocumentWrapper->IsAnimated();

  return NS_OK;

}

//******************************************************************************

int32_t VectorImage::GetFirstFrameDelay() {

  if (mError) {

    return -1;

  }

  if (!mSVGDocumentWrapper->IsAnimated()) {

    return -1;

  }

  // We don't really have a frame delay, so just pretend that we constantly

  // need updates.

  return 0;

}

NS_IMETHODIMP_(bool)

VectorImage::WillDrawOpaqueNow() {

  return false;  // In general, SVG content is not opaque.

}

//******************************************************************************

NS_IMETHODIMP_(already_AddRefed<SourceSurface>)

VectorImage::GetFrame(uint32_t aWhichFrame, uint32_t aFlags) {

  if (mError) {

    return nullptr;

  }

  // Look up height & width

  // ----------------------

  SVGSVGElement* svgElem = mSVGDocumentWrapper->GetRootSVGElem();

  MOZ_ASSERT(svgElem,

             "Should have a root SVG elem, since we finished "

             "loading without errors");

  nsIntSize imageIntSize(svgElem->GetIntrinsicWidth(),

                         svgElem->GetIntrinsicHeight());

  if (imageIntSize.IsEmpty()) {

    // We'll get here if our SVG doc has a percent-valued or negative width or

    // height.

    return nullptr;

  }

  return GetFrameAtSize(imageIntSize, aWhichFrame, aFlags);

}

NS_IMETHODIMP_(already_AddRefed<SourceSurface>)

VectorImage::GetFrameAtSize(const IntSize& aSize, uint32_t aWhichFrame,

                            uint32_t aFlags) {

#ifdef DEBUG

  NotifyDrawingObservers();

#endif

  auto result = GetFrameInternal(aSize, Nothing(), aWhichFrame, aFlags);

  return Get<2>(result).forget();

}

Tuple<ImgDrawResult, IntSize, RefPtr<SourceSurface>>

VectorImage::GetFrameInternal(const IntSize& aSize,

                              const Maybe<SVGImageContext>& aSVGContext,

                              uint32_t aWhichFrame, uint32_t aFlags) {

  MOZ_ASSERT(aWhichFrame <= FRAME_MAX_VALUE);

  if (aSize.IsEmpty() || aWhichFrame > FRAME_MAX_VALUE) {

    return MakeTuple(ImgDrawResult::BAD_ARGS, aSize, RefPtr<SourceSurface>());

  }

  if (mError) {

    return MakeTuple(ImgDrawResult::BAD_IMAGE, aSize, RefPtr<SourceSurface>());

  }

  if (!mIsFullyLoaded) {

    return MakeTuple(ImgDrawResult::NOT_READY, aSize, RefPtr<SourceSurface>());

  }

  RefPtr<SourceSurface> sourceSurface =

      LookupCachedSurface(aSize, aSVGContext, aFlags);

  if (sourceSurface) {

    return MakeTuple(ImgDrawResult::SUCCESS, aSize, Move(sourceSurface));

  }

  if (mIsDrawing) {

    NS_WARNING("Refusing to make re-entrant call to VectorImage::Draw");

    return MakeTuple(ImgDrawResult::TEMPORARY_ERROR, aSize,

                     RefPtr<SourceSurface>());

  }

  // By using a null gfxContext, we ensure that we will always attempt to

  // create a surface, even if we aren't capable of caching it (e.g. due to our

  // flags, having an animation, etc). Otherwise CreateSurface will assume that

  // the caller is capable of drawing directly to its own draw target if we

  // cannot cache.

  SVGDrawingParameters params(

      nullptr, aSize, ImageRegion::Create(aSize), SamplingFilter::POINT,

      aSVGContext, mSVGDocumentWrapper->GetCurrentTime(), aFlags, 1.0);

  bool didCache;  // Was the surface put into the cache?

  bool contextPaint = aSVGContext && aSVGContext->GetContextPaint();

  AutoRestoreSVGState autoRestore(params, mSVGDocumentWrapper, mIsDrawing,

                                  contextPaint);

  RefPtr<gfxDrawable> svgDrawable = CreateSVGDrawable(params);

  RefPtr<SourceSurface> surface = CreateSurface(params, svgDrawable, didCache);

  if (!surface) {

    MOZ_ASSERT(!didCache);

    return MakeTuple(ImgDrawResult::TEMPORARY_ERROR, aSize,

                     RefPtr<SourceSurface>());

  }

  SendFrameComplete(didCache, params.flags);

  return MakeTuple(ImgDrawResult::SUCCESS, aSize, Move(surface));

}

//******************************************************************************

IntSize VectorImage::GetImageContainerSize(LayerManager* aManager,

                                           const IntSize& aSize,

                                           uint32_t aFlags) {

  if (!IsImageContainerAvailableAtSize(aManager, aSize, aFlags)) {

    return IntSize(0, 0);

  }

  return aSize;

}

NS_IMETHODIMP_(bool)

VectorImage::IsImageContainerAvailable(LayerManager* aManager,

                                       uint32_t aFlags) {

  return false;

}

//******************************************************************************

NS_IMETHODIMP_(already_AddRefed<ImageContainer>)

VectorImage::GetImageContainer(LayerManager* aManager, uint32_t aFlags) {

  return nullptr;

}

//******************************************************************************

NS_IMETHODIMP_(bool)

VectorImage::IsImageContainerAvailableAtSize(LayerManager* aManager,

                                             const IntSize& aSize,

                                             uint32_t aFlags) {

  if (mError || !mIsFullyLoaded || aSize.IsEmpty() || mHaveAnimations ||

      !gfxVars::GetUseWebRenderOrDefault()) {

    return false;

  }

  int32_t maxTextureSize = aManager->GetMaxTextureSize();

  return aSize.width <= maxTextureSize && aSize.height <= maxTextureSize;

}

//******************************************************************************

NS_IMETHODIMP_(already_AddRefed<ImageContainer>)

VectorImage::GetImageContainerAtSize(LayerManager* aManager,

                                     const IntSize& aSize,

                                     const Maybe<SVGImageContext>& aSVGContext,

                                     uint32_t aFlags) {

  Maybe<SVGImageContext> newSVGContext;

  MaybeRestrictSVGContext(newSVGContext, aSVGContext, aFlags);

  // Since we do not support high quality scaling with SVG, we mask it off so

  // that container requests with and without it map to the same container.

  // Similarly the aspect ratio flag was already handled as part of the SVG

  // context restriction above.

  uint32_t flags = aFlags & ~(FLAG_HIGH_QUALITY_SCALING |

                              FLAG_FORCE_PRESERVEASPECTRATIO_NONE);

  return GetImageContainerImpl(

      aManager, aSize, newSVGContext ? newSVGContext : aSVGContext, flags);

}

bool VectorImage::MaybeRestrictSVGContext(

    Maybe<SVGImageContext>& aNewSVGContext,

    const Maybe<SVGImageContext>& aSVGContext, uint32_t aFlags) {

  bool overridePAR =

      (aFlags & FLAG_FORCE_PRESERVEASPECTRATIO_NONE) && aSVGContext;

  bool haveContextPaint = aSVGContext && aSVGContext->GetContextPaint();

  bool blockContextPaint = false;

  if (haveContextPaint) {

    nsCOMPtr<nsIURI> imageURI = mURI->ToIURI();

    blockContextPaint = !SVGContextPaint::IsAllowedForImageFromURI(imageURI);

  }

  if (overridePAR || blockContextPaint) {

    // The key that we create for the image surface cache must match the way

    // that the image will be painted, so we need to initialize a new matching

    // SVGImageContext here in order to generate the correct key.

    aNewSVGContext = aSVGContext;  // copy

    if (overridePAR) {

      // The SVGImageContext must take account of the preserveAspectRatio

      // overide:

      MOZ_ASSERT(!aSVGContext->GetPreserveAspectRatio(),

                 "FLAG_FORCE_PRESERVEASPECTRATIO_NONE is not expected if a "

                 "preserveAspectRatio override is supplied");

      Maybe<SVGPreserveAspectRatio> aspectRatio = Some(SVGPreserveAspectRatio(

          SVG_PRESERVEASPECTRATIO_NONE, SVG_MEETORSLICE_UNKNOWN));

      aNewSVGContext->SetPreserveAspectRatio(aspectRatio);

    }

    if (blockContextPaint) {

      // The SVGImageContext must not include context paint if the image is

      // not allowed to use it:

      aNewSVGContext->ClearContextPaint();

    }

  }

  return haveContextPaint && !blockContextPaint;

}

//******************************************************************************

NS_IMETHODIMP_(ImgDrawResult)

VectorImage::Draw(gfxContext* aContext, const nsIntSize& aSize,

                  const ImageRegion& aRegion, uint32_t aWhichFrame,

                  SamplingFilter aSamplingFilter,

                  const Maybe<SVGImageContext>& aSVGContext, uint32_t aFlags,

                  float aOpacity) {

  if (aWhichFrame > FRAME_MAX_VALUE) {

    return ImgDrawResult::BAD_ARGS;

  }

  if (!aContext) {

    return ImgDrawResult::BAD_ARGS;

  }