image/ImageWrapper.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "ImageWrapper.h"
   7 #include "mozilla/gfx/2D.h"
   8 #include "mozilla/RefPtr.h"
   9 #include "Orientation.h"
  10 #include "mozilla/image/Resolution.h"
  11
  12 #include "mozilla/MemoryReporting.h"
  13
  14 namespace mozilla {
  15
  16 using dom::Document;
  17 using gfx::IntSize;
  18 using gfx::SamplingFilter;
  19 using gfx::SourceSurface;
  20 using layers::ImageContainer;
  21 using layers::LayerManager;
  22
  23 namespace image {
  24
  25 // Inherited methods from Image.
  26
  27 already_AddRefed<ProgressTracker> ImageWrapper::GetProgressTracker() {
  28   return mInnerImage->GetProgressTracker();
  29 }
  30
  31 size_t ImageWrapper::SizeOfSourceWithComputedFallback(
  32     SizeOfState& aState) const {
  33   return mInnerImage->SizeOfSourceWithComputedFallback(aState);
  34 }
  35
  36 void ImageWrapper::CollectSizeOfSurfaces(
  37     nsTArray<SurfaceMemoryCounter>& aCounters,
  38     MallocSizeOf aMallocSizeOf) const {
  39   mInnerImage->CollectSizeOfSurfaces(aCounters, aMallocSizeOf);
  40 }
  41
  42 void ImageWrapper::IncrementAnimationConsumers() {
  43   MOZ_ASSERT(NS_IsMainThread(),
  44              "Main thread only to encourage serialization "
  45              "with DecrementAnimationConsumers");
  46   mInnerImage->IncrementAnimationConsumers();
  47 }
  48
  49 void ImageWrapper::DecrementAnimationConsumers() {
  50   MOZ_ASSERT(NS_IsMainThread(),
  51              "Main thread only to encourage serialization "
  52              "with IncrementAnimationConsumers");
  53   mInnerImage->DecrementAnimationConsumers();
  54 }
  55
  56 #ifdef DEBUG
  57 uint32_t ImageWrapper::GetAnimationConsumers() {
  58   return mInnerImage->GetAnimationConsumers();
  59 }
  60 #endif
  61
  62 nsresult ImageWrapper::OnImageDataAvailable(nsIRequest* aRequest,
  63                                             nsISupports* aContext,
  64                                             nsIInputStream* aInStr,
  65                                             uint64_t aSourceOffset,
  66                                             uint32_t aCount) {
  67   return mInnerImage->OnImageDataAvailable(aRequest, aContext, aInStr,
  68                                            aSourceOffset, aCount);
  69 }
  70
  71 nsresult ImageWrapper::OnImageDataComplete(nsIRequest* aRequest,
  72                                            nsISupports* aContext,
  73                                            nsresult aStatus, bool aLastPart) {
  74   return mInnerImage->OnImageDataComplete(aRequest, aContext, aStatus,
  75                                           aLastPart);
  76 }
  77
  78 void ImageWrapper::OnSurfaceDiscarded(const SurfaceKey& aSurfaceKey) {
  79   return mInnerImage->OnSurfaceDiscarded(aSurfaceKey);
  80 }
  81
  82 void ImageWrapper::SetInnerWindowID(uint64_t aInnerWindowId) {
  83   mInnerImage->SetInnerWindowID(aInnerWindowId);
  84 }
  85
  86 uint64_t ImageWrapper::InnerWindowID() const {
  87   return mInnerImage->InnerWindowID();
  88 }
  89
  90 bool ImageWrapper::HasError() { return mInnerImage->HasError(); }
  91
  92 void ImageWrapper::SetHasError() { mInnerImage->SetHasError(); }
  93
  94 nsIURI* ImageWrapper::GetURI() const { return mInnerImage->GetURI(); }
  95
  96 // Methods inherited from XPCOM interfaces.
  97
  98 NS_IMPL_ISUPPORTS(ImageWrapper, imgIContainer)
  99
 100 NS_IMETHODIMP
 101 ImageWrapper::GetWidth(int32_t* aWidth) {
 102   return mInnerImage->GetWidth(aWidth);
 103 }
 104
 105 NS_IMETHODIMP
 106 ImageWrapper::GetHeight(int32_t* aHeight) {
 107   return mInnerImage->GetHeight(aHeight);
 108 }
 109
 110 nsresult ImageWrapper::GetNativeSizes(nsTArray<IntSize>& aNativeSizes) const {
 111   return mInnerImage->GetNativeSizes(aNativeSizes);
 112 }
 113
 114 size_t ImageWrapper::GetNativeSizesLength() const {
 115   return mInnerImage->GetNativeSizesLength();
 116 }
 117
 118 NS_IMETHODIMP
 119 ImageWrapper::GetIntrinsicSize(nsSize* aSize) {
 120   return mInnerImage->GetIntrinsicSize(aSize);
 121 }
 122
 123 Maybe<AspectRatio> ImageWrapper::GetIntrinsicRatio() {
 124   return mInnerImage->GetIntrinsicRatio();
 125 }
 126
 127 nsresult ImageWrapper::GetHotspotX(int32_t* aX) {
 128   return Image::GetHotspotX(aX);
 129 }
 130
 131 nsresult ImageWrapper::GetHotspotY(int32_t* aY) {
 132   return Image::GetHotspotY(aY);
 133 }
 134
 135 NS_IMETHODIMP_(Orientation)
 136 ImageWrapper::GetOrientation() { return mInnerImage->GetOrientation(); }
 137
 138 NS_IMETHODIMP_(Resolution)
 139 ImageWrapper::GetResolution() { return mInnerImage->GetResolution(); }
 140
 141 NS_IMETHODIMP
 142 ImageWrapper::GetType(uint16_t* aType) { return mInnerImage->GetType(aType); }
 143
 144 NS_IMETHODIMP
 145 ImageWrapper::GetProducerId(uint32_t* aId) {
 146   return mInnerImage->GetProducerId(aId);
 147 }
 148
 149 NS_IMETHODIMP
 150 ImageWrapper::GetAnimated(bool* aAnimated) {
 151   return mInnerImage->GetAnimated(aAnimated);
 152 }
 153
 154 NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
 155 ImageWrapper::GetFrame(uint32_t aWhichFrame, uint32_t aFlags) {
 156   return mInnerImage->GetFrame(aWhichFrame, aFlags);
 157 }
 158
 159 NS_IMETHODIMP_(already_AddRefed<SourceSurface>)
 160 ImageWrapper::GetFrameAtSize(const IntSize& aSize, uint32_t aWhichFrame,
 161                              uint32_t aFlags) {
 162   return mInnerImage->GetFrameAtSize(aSize, aWhichFrame, aFlags);
 163 }
 164
 165 NS_IMETHODIMP_(bool)
 166 ImageWrapper::WillDrawOpaqueNow() { return mInnerImage->WillDrawOpaqueNow(); }
 167
 168 NS_IMETHODIMP_(bool)
 169 ImageWrapper::IsImageContainerAvailable(LayerManager* aManager,
 170                                         uint32_t aFlags) {
 171   return mInnerImage->IsImageContainerAvailable(aManager, aFlags);
 172 }
 173
 174 NS_IMETHODIMP_(already_AddRefed<ImageContainer>)
 175 ImageWrapper::GetImageContainer(WindowRenderer* aRenderer, uint32_t aFlags) {
 176   return mInnerImage->GetImageContainer(aRenderer, aFlags);
 177 }
 178
 179 NS_IMETHODIMP_(bool)
 180 ImageWrapper::IsImageContainerAvailableAtSize(LayerManager* aManager,
 181                                               const IntSize& aSize,
 182                                               uint32_t aFlags) {
 183   return mInnerImage->IsImageContainerAvailableAtSize(aManager, aSize, aFlags);
 184 }
 185
 186 NS_IMETHODIMP_(ImgDrawResult)
 187 ImageWrapper::GetImageContainerAtSize(WindowRenderer* aRenderer,
 188                                       const gfx::IntSize& aSize,
 189                                       const Maybe<SVGImageContext>& aSVGContext,
 190                                       const Maybe<ImageIntRegion>& aRegion,
 191                                       uint32_t aFlags,
 192                                       layers::ImageContainer** aOutContainer) {
 193   return mInnerImage->GetImageContainerAtSize(aRenderer, aSize, aSVGContext,
 194                                               aRegion, aFlags, aOutContainer);
 195 }
 196
 197 NS_IMETHODIMP_(ImgDrawResult)
 198 ImageWrapper::Draw(gfxContext* aContext, const nsIntSize& aSize,
 199                    const ImageRegion& aRegion, uint32_t aWhichFrame,
 200                    SamplingFilter aSamplingFilter,
 201                    const Maybe<SVGImageContext>& aSVGContext, uint32_t aFlags,
 202                    float aOpacity) {
 203   return mInnerImage->Draw(aContext, aSize, aRegion, aWhichFrame,
 204                            aSamplingFilter, aSVGContext, aFlags, aOpacity);
 205 }
 206
 207 NS_IMETHODIMP
 208 ImageWrapper::StartDecoding(uint32_t aFlags, uint32_t aWhichFrame) {
 209   return mInnerImage->StartDecoding(aFlags, aWhichFrame);
 210 }
 211
 212 bool ImageWrapper::StartDecodingWithResult(uint32_t aFlags,
 213                                            uint32_t aWhichFrame) {
 214   return mInnerImage->StartDecodingWithResult(aFlags, aWhichFrame);
 215 }
 216
 217 imgIContainer::DecodeResult ImageWrapper::RequestDecodeWithResult(
 218     uint32_t aFlags, uint32_t aWhichFrame) {
 219   return mInnerImage->RequestDecodeWithResult(aFlags, aWhichFrame);
 220 }
 221
 222 NS_IMETHODIMP
 223 ImageWrapper::RequestDecodeForSize(const nsIntSize& aSize, uint32_t aFlags,
 224                                    uint32_t aWhichFrame) {
 225   return mInnerImage->RequestDecodeForSize(aSize, aFlags, aWhichFrame);
 226 }
 227
 228 NS_IMETHODIMP
 229 ImageWrapper::LockImage() {
 230   MOZ_ASSERT(NS_IsMainThread(),
 231              "Main thread to encourage serialization with UnlockImage");
 232   return mInnerImage->LockImage();
 233 }
 234
 235 NS_IMETHODIMP
 236 ImageWrapper::UnlockImage() {
 237   MOZ_ASSERT(NS_IsMainThread(),
 238              "Main thread to encourage serialization with LockImage");
 239   return mInnerImage->UnlockImage();
 240 }
 241
 242 NS_IMETHODIMP
 243 ImageWrapper::RequestDiscard() { return mInnerImage->RequestDiscard(); }
 244
 245 NS_IMETHODIMP_(void)
 246 ImageWrapper::RequestRefresh(const TimeStamp& aTime) {
 247   return mInnerImage->RequestRefresh(aTime);
 248 }
 249
 250 NS_IMETHODIMP
 251 ImageWrapper::GetAnimationMode(uint16_t* aAnimationMode) {
 252   return mInnerImage->GetAnimationMode(aAnimationMode);
 253 }
 254
 255 NS_IMETHODIMP
 256 ImageWrapper::SetAnimationMode(uint16_t aAnimationMode) {
 257   return mInnerImage->SetAnimationMode(aAnimationMode);
 258 }
 259
 260 NS_IMETHODIMP
 261 ImageWrapper::ResetAnimation() { return mInnerImage->ResetAnimation(); }
 262
 263 NS_IMETHODIMP_(float)
 264 ImageWrapper::GetFrameIndex(uint32_t aWhichFrame) {
 265   return mInnerImage->GetFrameIndex(aWhichFrame);
 266 }
 267
 268 NS_IMETHODIMP_(int32_t)
 269 ImageWrapper::GetFirstFrameDelay() { return mInnerImage->GetFirstFrameDelay(); }
 270
 271 NS_IMETHODIMP_(void)
 272 ImageWrapper::SetAnimationStartTime(const TimeStamp& aTime) {
 273   mInnerImage->SetAnimationStartTime(aTime);
 274 }
 275
 276 void ImageWrapper::PropagateUseCounters(Document* aReferencingDocument) {
 277   mInnerImage->PropagateUseCounters(aReferencingDocument);
 278 }
 279
 280 nsIntSize ImageWrapper::OptimalImageSizeForDest(const gfxSize& aDest,
 281                                                 uint32_t aWhichFrame,
 282                                                 SamplingFilter aSamplingFilter,
 283                                                 uint32_t aFlags) {
 284   return mInnerImage->OptimalImageSizeForDest(aDest, aWhichFrame,
 285                                               aSamplingFilter, aFlags);
 286 }
 287
 288 NS_IMETHODIMP_(nsIntRect)
 289 ImageWrapper::GetImageSpaceInvalidationRect(const nsIntRect& aRect) {
 290   return mInnerImage->GetImageSpaceInvalidationRect(aRect);
 291 }
 292
 293 already_AddRefed<imgIContainer> ImageWrapper::Unwrap() {
 294   return mInnerImage->Unwrap();
 295 }
 296
 297 }  // namespace image
 298 }  // namespace mozilla