The Tor Browser: image/src/ImageWrapper.cpp@ac0c01689b40

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

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

     6 #include "ImageWrapper.h"

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

     8 #include "mozilla/RefPtr.h"

     9 #include "Orientation.h"

    11 #include "mozilla/MemoryReporting.h"

    13 using mozilla::gfx::DataSourceSurface;

    14 using mozilla::gfx::SourceSurface;

    15 using mozilla::layers::LayerManager;

    16 using mozilla::layers::ImageContainer;

    18 namespace mozilla {

    19 namespace image {

    21 // Inherited methods from Image.

    23 nsresult

    24 ImageWrapper::Init(const char* aMimeType, uint32_t aFlags)

    25 {

    26   return mInnerImage->Init(aMimeType, aFlags);

    27 }

    29 already_AddRefed<imgStatusTracker>

    30 ImageWrapper::GetStatusTracker()

    31 {

    32   return mInnerImage->GetStatusTracker();

    33 }

    35 nsIntRect

    36 ImageWrapper::FrameRect(uint32_t aWhichFrame)

    37 {

    38   return mInnerImage->FrameRect(aWhichFrame);

    39 }

    41 uint32_t

    42 ImageWrapper::SizeOfData()

    43 {

    44   return mInnerImage->SizeOfData();

    45 }

    47 size_t

    48 ImageWrapper::HeapSizeOfSourceWithComputedFallback(mozilla::MallocSizeOf aMallocSizeOf) const

    49 {

    50   return mInnerImage->HeapSizeOfSourceWithComputedFallback(aMallocSizeOf);

    51 }

    53 size_t

    54 ImageWrapper::HeapSizeOfDecodedWithComputedFallback(mozilla::MallocSizeOf aMallocSizeOf) const

    55 {

    56   return mInnerImage->HeapSizeOfDecodedWithComputedFallback(aMallocSizeOf);

    57 }

    59 size_t

    60 ImageWrapper::NonHeapSizeOfDecoded() const

    61 {

    62   return mInnerImage->NonHeapSizeOfDecoded();

    63 }

    65 size_t

    66 ImageWrapper::OutOfProcessSizeOfDecoded() const

    67 {

    68   return mInnerImage->OutOfProcessSizeOfDecoded();

    69 }

    71 void

    72 ImageWrapper::IncrementAnimationConsumers()

    73 {

    74   MOZ_ASSERT(NS_IsMainThread(), "Main thread only to encourage serialization "

    75                                 "with DecrementAnimationConsumers");

    76   mInnerImage->IncrementAnimationConsumers();

    77 }

    79 void

    80 ImageWrapper::DecrementAnimationConsumers()

    81 {

    82   MOZ_ASSERT(NS_IsMainThread(), "Main thread only to encourage serialization "

    83                                 "with IncrementAnimationConsumers");

    84   mInnerImage->DecrementAnimationConsumers();

    85 }

    87 #ifdef DEBUG

    88 uint32_t

    89 ImageWrapper::GetAnimationConsumers()

    90 {

    91   return mInnerImage->GetAnimationConsumers();

    92 }

    93 #endif

    95 nsresult

    96 ImageWrapper::OnImageDataAvailable(nsIRequest* aRequest,

    97                                    nsISupports* aContext,

    98                                    nsIInputStream* aInStr,

    99                                    uint64_t aSourceOffset,

   100                                    uint32_t aCount)

   101 {

   102   return mInnerImage->OnImageDataAvailable(aRequest, aContext, aInStr,

   103                                            aSourceOffset, aCount);

   104 }

   106 nsresult

   107 ImageWrapper::OnImageDataComplete(nsIRequest* aRequest,

   108                                   nsISupports* aContext,

   109                                   nsresult aStatus,

   110                                   bool aLastPart)

   111 {

   112   return mInnerImage->OnImageDataComplete(aRequest, aContext, aStatus, aLastPart);

   113 }

   115 nsresult

   116 ImageWrapper::OnNewSourceData()

   117 {

   118   return mInnerImage->OnNewSourceData();

   119 }

   121 void

   122 ImageWrapper::SetInnerWindowID(uint64_t aInnerWindowId)

   123 {

   124   mInnerImage->SetInnerWindowID(aInnerWindowId);

   125 }

   127 uint64_t

   128 ImageWrapper::InnerWindowID() const

   129 {

   130   return mInnerImage->InnerWindowID();

   131 }

   133 bool

   134 ImageWrapper::HasError()

   135 {

   136   return mInnerImage->HasError();

   137 }

   139 void

   140 ImageWrapper::SetHasError()

   141 {

   142   mInnerImage->SetHasError();

   143 }

   145 ImageURL*

   146 ImageWrapper::GetURI()

   147 {

   148   return mInnerImage->GetURI();

   149 }

   151 // Methods inherited from XPCOM interfaces.

   153 NS_IMPL_ISUPPORTS(ImageWrapper, imgIContainer)

   155 NS_IMETHODIMP

   156 ImageWrapper::GetWidth(int32_t* aWidth)

   157 {

   158   return mInnerImage->GetWidth(aWidth);

   159 }

   161 NS_IMETHODIMP

   162 ImageWrapper::GetHeight(int32_t* aHeight)

   163 {

   164   return mInnerImage->GetHeight(aHeight);

   165 }

   167 NS_IMETHODIMP

   168 ImageWrapper::GetIntrinsicSize(nsSize* aSize)

   169 {

   170   return mInnerImage->GetIntrinsicSize(aSize);

   171 }

   173 NS_IMETHODIMP

   174 ImageWrapper::GetIntrinsicRatio(nsSize* aSize)

   175 {

   176   return mInnerImage->GetIntrinsicRatio(aSize);

   177 }

   179 NS_IMETHODIMP_(Orientation)

   180 ImageWrapper::GetOrientation()

   181 {

   182   return mInnerImage->GetOrientation();

   183 }

   185 NS_IMETHODIMP

   186 ImageWrapper::GetType(uint16_t* aType)

   187 {

   188   return mInnerImage->GetType(aType);

   189 }

   191 NS_IMETHODIMP_(uint16_t)

   192 ImageWrapper::GetType()

   193 {

   194   return mInnerImage->GetType();

   195 }

   197 NS_IMETHODIMP

   198 ImageWrapper::GetAnimated(bool* aAnimated)

   199 {

   200   return mInnerImage->GetAnimated(aAnimated);

   201 }

   203 NS_IMETHODIMP_(TemporaryRef<SourceSurface>)

   204 ImageWrapper::GetFrame(uint32_t aWhichFrame,

   205                        uint32_t aFlags)

   206 {

   207   return mInnerImage->GetFrame(aWhichFrame, aFlags);

   208 }

   210 NS_IMETHODIMP_(bool)

   211 ImageWrapper::FrameIsOpaque(uint32_t aWhichFrame)

   212 {

   213   return mInnerImage->FrameIsOpaque(aWhichFrame);

   214 }

   216 NS_IMETHODIMP

   217 ImageWrapper::GetImageContainer(LayerManager* aManager, ImageContainer** _retval)

   218 {

   219   return mInnerImage->GetImageContainer(aManager, _retval);

   220 }

   222 NS_IMETHODIMP

   223 ImageWrapper::Draw(gfxContext* aContext,

   224                    GraphicsFilter aFilter,

   225                    const gfxMatrix& aUserSpaceToImageSpace,

   226                    const gfxRect& aFill,

   227                    const nsIntRect& aSubimage,

   228                    const nsIntSize& aViewportSize,

   229                    const SVGImageContext* aSVGContext,

   230                    uint32_t aWhichFrame,

   231                    uint32_t aFlags)

   232 {

   233   return mInnerImage->Draw(aContext, aFilter, aUserSpaceToImageSpace, aFill,

   234                            aSubimage, aViewportSize, aSVGContext, aWhichFrame,

   235                            aFlags);

   236 }

   238 NS_IMETHODIMP

   239 ImageWrapper::RequestDecode()

   240 {

   241   return mInnerImage->RequestDecode();

   242 }

   244 NS_IMETHODIMP

   245 ImageWrapper::StartDecoding()

   246 {

   247   return mInnerImage->StartDecoding();

   248 }

   250 bool

   251 ImageWrapper::IsDecoded()

   252 {

   253   return mInnerImage->IsDecoded();

   254 }

   256 NS_IMETHODIMP

   257 ImageWrapper::LockImage()

   258 {

   259   MOZ_ASSERT(NS_IsMainThread(),

   260              "Main thread to encourage serialization with UnlockImage");

   261   return mInnerImage->LockImage();

   262 }

   264 NS_IMETHODIMP

   265 ImageWrapper::UnlockImage()

   266 {

   267   MOZ_ASSERT(NS_IsMainThread(),

   268              "Main thread to encourage serialization with LockImage");

   269   return mInnerImage->UnlockImage();

   270 }

   272 NS_IMETHODIMP

   273 ImageWrapper::RequestDiscard()

   274 {

   275   return mInnerImage->RequestDiscard();

   276 }

   278 NS_IMETHODIMP_(void)

   279 ImageWrapper::RequestRefresh(const mozilla::TimeStamp& aTime)

   280 {

   281   return mInnerImage->RequestRefresh(aTime);

   282 }

   284 NS_IMETHODIMP

   285 ImageWrapper::GetAnimationMode(uint16_t* aAnimationMode)

   286 {

   287   return mInnerImage->GetAnimationMode(aAnimationMode);

   288 }

   290 NS_IMETHODIMP

   291 ImageWrapper::SetAnimationMode(uint16_t aAnimationMode)

   292 {

   293   return mInnerImage->SetAnimationMode(aAnimationMode);

   294 }

   296 NS_IMETHODIMP

   297 ImageWrapper::ResetAnimation()

   298 {

   299   return mInnerImage->ResetAnimation();

   300 }

   302 NS_IMETHODIMP_(float)

   303 ImageWrapper::GetFrameIndex(uint32_t aWhichFrame)

   304 {

   305   return mInnerImage->GetFrameIndex(aWhichFrame);

   306 }

   308 NS_IMETHODIMP_(int32_t)

   309 ImageWrapper::GetFirstFrameDelay()

   310 {

   311   return mInnerImage->GetFirstFrameDelay();

   312 }

   314 NS_IMETHODIMP_(void)

   315 ImageWrapper::SetAnimationStartTime(const mozilla::TimeStamp& aTime)

   316 {

   317   mInnerImage->SetAnimationStartTime(aTime);

   318 }

   320 } // namespace image

   321 } // namespace mozilla

The Tor Browser / file revision

image/src/ImageWrapper.cpp@ac0c01689b40

image/src/ImageWrapper.cpp