tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

ImageWrapper.cpp (9271B)

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