image/src/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 "Orientation.h"
   8
   9 #include "mozilla/MemoryReporting.h"
  10
  11 using mozilla::layers::LayerManager;
  12 using mozilla::layers::ImageContainer;
  13
  14 namespace mozilla {
  15 namespace image {
  16
  17 // Inherited methods from Image.
  18
  19 nsresult
  20 ImageWrapper::Init(const char* aMimeType, uint32_t aFlags)
  21 {
  22   return mInnerImage->Init(aMimeType, aFlags);
  23 }
  24
  25 already_AddRefed<imgStatusTracker>
  26 ImageWrapper::GetStatusTracker()
  27 {
  28   return mInnerImage->GetStatusTracker();
  29 }
  30
  31 nsIntRect
  32 ImageWrapper::FrameRect(uint32_t aWhichFrame)
  33 {
  34   return mInnerImage->FrameRect(aWhichFrame);
  35 }
  36
  37 uint32_t
  38 ImageWrapper::SizeOfData()
  39 {
  40   return mInnerImage->SizeOfData();
  41 }
  42
  43 size_t
  44 ImageWrapper::HeapSizeOfSourceWithComputedFallback(mozilla::MallocSizeOf aMallocSizeOf) const
  45 {
  46   return mInnerImage->HeapSizeOfSourceWithComputedFallback(aMallocSizeOf);
  47 }
  48
  49 size_t
  50 ImageWrapper::HeapSizeOfDecodedWithComputedFallback(mozilla::MallocSizeOf aMallocSizeOf) const
  51 {
  52   return mInnerImage->HeapSizeOfDecodedWithComputedFallback(aMallocSizeOf);
  53 }
  54
  55 size_t
  56 ImageWrapper::NonHeapSizeOfDecoded() const
  57 {
  58   return mInnerImage->NonHeapSizeOfDecoded();
  59 }
  60
  61 size_t
  62 ImageWrapper::OutOfProcessSizeOfDecoded() const
  63 {
  64   return mInnerImage->OutOfProcessSizeOfDecoded();
  65 }
  66
  67 void
  68 ImageWrapper::IncrementAnimationConsumers()
  69 {
  70   MOZ_ASSERT(NS_IsMainThread(), "Main thread only to encourage serialization "
  71                                 "with DecrementAnimationConsumers");
  72   mInnerImage->IncrementAnimationConsumers();
  73 }
  74
  75 void
  76 ImageWrapper::DecrementAnimationConsumers()
  77 {
  78   MOZ_ASSERT(NS_IsMainThread(), "Main thread only to encourage serialization "
  79                                 "with IncrementAnimationConsumers");
  80   mInnerImage->DecrementAnimationConsumers();
  81 }
  82
  83 #ifdef DEBUG
  84 uint32_t
  85 ImageWrapper::GetAnimationConsumers()
  86 {
  87   return mInnerImage->GetAnimationConsumers();
  88 }
  89 #endif
  90
  91 nsresult
  92 ImageWrapper::OnImageDataAvailable(nsIRequest* aRequest,
  93                                    nsISupports* aContext,
  94                                    nsIInputStream* aInStr,
  95                                    uint64_t aSourceOffset,
  96                                    uint32_t aCount)
  97 {
  98   return mInnerImage->OnImageDataAvailable(aRequest, aContext, aInStr,
  99                                            aSourceOffset, aCount);
 100 }
 101
 102 nsresult
 103 ImageWrapper::OnImageDataComplete(nsIRequest* aRequest,
 104                                   nsISupports* aContext,
 105                                   nsresult aStatus,
 106                                   bool aLastPart)
 107 {
 108   return mInnerImage->OnImageDataComplete(aRequest, aContext, aStatus, aLastPart);
 109 }
 110
 111 nsresult
 112 ImageWrapper::OnNewSourceData()
 113 {
 114   return mInnerImage->OnNewSourceData();
 115 }
 116
 117 void
 118 ImageWrapper::SetInnerWindowID(uint64_t aInnerWindowId)
 119 {
 120   mInnerImage->SetInnerWindowID(aInnerWindowId);
 121 }
 122
 123 uint64_t
 124 ImageWrapper::InnerWindowID() const
 125 {
 126   return mInnerImage->InnerWindowID();
 127 }
 128
 129 bool
 130 ImageWrapper::HasError()
 131 {
 132   return mInnerImage->HasError();
 133 }
 134
 135 void
 136 ImageWrapper::SetHasError()
 137 {
 138   mInnerImage->SetHasError();
 139 }
 140
 141 ImageURL*
 142 ImageWrapper::GetURI()
 143 {
 144   return mInnerImage->GetURI();
 145 }
 146
 147 // Methods inherited from XPCOM interfaces.
 148
 149 NS_IMPL_ISUPPORTS1(ImageWrapper, imgIContainer)
 150
 151 NS_IMETHODIMP
 152 ImageWrapper::GetWidth(int32_t* aWidth)
 153 {
 154   return mInnerImage->GetWidth(aWidth);
 155 }
 156
 157 NS_IMETHODIMP
 158 ImageWrapper::GetHeight(int32_t* aHeight)
 159 {
 160   return mInnerImage->GetHeight(aHeight);
 161 }
 162
 163 NS_IMETHODIMP
 164 ImageWrapper::GetIntrinsicSize(nsSize* aSize)
 165 {
 166   return mInnerImage->GetIntrinsicSize(aSize);
 167 }
 168
 169 NS_IMETHODIMP
 170 ImageWrapper::GetIntrinsicRatio(nsSize* aSize)
 171 {
 172   return mInnerImage->GetIntrinsicRatio(aSize);
 173 }
 174
 175 NS_IMETHODIMP_(Orientation)
 176 ImageWrapper::GetOrientation()
 177 {
 178   return mInnerImage->GetOrientation();
 179 }
 180
 181 NS_IMETHODIMP
 182 ImageWrapper::GetType(uint16_t* aType)
 183 {
 184   return mInnerImage->GetType(aType);
 185 }
 186
 187 NS_IMETHODIMP_(uint16_t)
 188 ImageWrapper::GetType()
 189 {
 190   return mInnerImage->GetType();
 191 }
 192
 193 NS_IMETHODIMP
 194 ImageWrapper::GetAnimated(bool* aAnimated)
 195 {
 196   return mInnerImage->GetAnimated(aAnimated);
 197 }
 198
 199 NS_IMETHODIMP
 200 ImageWrapper::GetFrame(uint32_t aWhichFrame,
 201                        uint32_t aFlags,
 202                        gfxASurface** _retval)
 203 {
 204   return mInnerImage->GetFrame(aWhichFrame, aFlags, _retval);
 205 }
 206
 207 NS_IMETHODIMP_(bool)
 208 ImageWrapper::FrameIsOpaque(uint32_t aWhichFrame)
 209 {
 210   return mInnerImage->FrameIsOpaque(aWhichFrame);
 211 }
 212
 213 NS_IMETHODIMP
 214 ImageWrapper::GetImageContainer(LayerManager* aManager, ImageContainer** _retval)
 215 {
 216   return mInnerImage->GetImageContainer(aManager, _retval);
 217 }
 218
 219 NS_IMETHODIMP
 220 ImageWrapper::Draw(gfxContext* aContext,
 221                    GraphicsFilter aFilter,
 222                    const gfxMatrix& aUserSpaceToImageSpace,
 223                    const gfxRect& aFill,
 224                    const nsIntRect& aSubimage,
 225                    const nsIntSize& aViewportSize,
 226                    const SVGImageContext* aSVGContext,
 227                    uint32_t aWhichFrame,
 228                    uint32_t aFlags)
 229 {
 230   return mInnerImage->Draw(aContext, aFilter, aUserSpaceToImageSpace, aFill,
 231                            aSubimage, aViewportSize, aSVGContext, aWhichFrame,
 232                            aFlags);
 233 }
 234
 235 NS_IMETHODIMP
 236 ImageWrapper::RequestDecode()
 237 {
 238   return mInnerImage->RequestDecode();
 239 }
 240
 241 NS_IMETHODIMP
 242 ImageWrapper::StartDecoding()
 243 {
 244   return mInnerImage->StartDecoding();
 245 }
 246
 247 bool
 248 ImageWrapper::IsDecoded()
 249 {
 250   return mInnerImage->IsDecoded();
 251 }
 252
 253 NS_IMETHODIMP
 254 ImageWrapper::LockImage()
 255 {
 256   MOZ_ASSERT(NS_IsMainThread(),
 257              "Main thread to encourage serialization with UnlockImage");
 258   return mInnerImage->LockImage();
 259 }
 260
 261 NS_IMETHODIMP
 262 ImageWrapper::UnlockImage()
 263 {
 264   MOZ_ASSERT(NS_IsMainThread(),
 265              "Main thread to encourage serialization with LockImage");
 266   return mInnerImage->UnlockImage();
 267 }
 268
 269 NS_IMETHODIMP
 270 ImageWrapper::RequestDiscard()
 271 {
 272   return mInnerImage->RequestDiscard();
 273 }
 274
 275 NS_IMETHODIMP_(void)
 276 ImageWrapper::RequestRefresh(const mozilla::TimeStamp& aTime)
 277 {
 278   return mInnerImage->RequestRefresh(aTime);
 279 }
 280
 281 NS_IMETHODIMP
 282 ImageWrapper::GetAnimationMode(uint16_t* aAnimationMode)
 283 {
 284   return mInnerImage->GetAnimationMode(aAnimationMode);
 285 }
 286
 287 NS_IMETHODIMP
 288 ImageWrapper::SetAnimationMode(uint16_t aAnimationMode)
 289 {
 290   return mInnerImage->SetAnimationMode(aAnimationMode);
 291 }
 292
 293 NS_IMETHODIMP
 294 ImageWrapper::ResetAnimation()
 295 {
 296   return mInnerImage->ResetAnimation();
 297 }
 298
 299 NS_IMETHODIMP_(float)
 300 ImageWrapper::GetFrameIndex(uint32_t aWhichFrame)
 301 {
 302   return mInnerImage->GetFrameIndex(aWhichFrame);
 303 }
 304
 305 NS_IMETHODIMP_(int32_t)
 306 ImageWrapper::GetFirstFrameDelay()
 307 {
 308   return mInnerImage->GetFirstFrameDelay();
 309 }
 310
 311 NS_IMETHODIMP_(void)
 312 ImageWrapper::SetAnimationStartTime(const mozilla::TimeStamp& aTime)
 313 {
 314   mInnerImage->SetAnimationStartTime(aTime);
 315 }
 316
 317 } // namespace image
 318 } // namespace mozilla