The Tor Browser: comparison image/src/ImageWrapper.cpp

--1:000000000000
+:b681874c5960
+/* -*- 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 "ImageWrapper.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/RefPtr.h"
+#include "Orientation.h"
+#include "mozilla/MemoryReporting.h"
+using mozilla::gfx::DataSourceSurface;
+using mozilla::gfx::SourceSurface;
+using mozilla::layers::LayerManager;
+using mozilla::layers::ImageContainer;
+namespace mozilla {
+namespace image {
+// Inherited methods from Image.
+nsresult
+ImageWrapper::Init(const char* aMimeType, uint32_t aFlags)
+{
+return mInnerImage->Init(aMimeType, aFlags);
+}
+already_AddRefed<imgStatusTracker>
+ImageWrapper::GetStatusTracker()
+{
+return mInnerImage->GetStatusTracker();
+}
+nsIntRect
+ImageWrapper::FrameRect(uint32_t aWhichFrame)
+{
+return mInnerImage->FrameRect(aWhichFrame);
+}
+uint32_t
+ImageWrapper::SizeOfData()
+{
+return mInnerImage->SizeOfData();
+}
+size_t
+ImageWrapper::HeapSizeOfSourceWithComputedFallback(mozilla::MallocSizeOf aMallocSizeOf) const
+{
+return mInnerImage->HeapSizeOfSourceWithComputedFallback(aMallocSizeOf);
+}
+size_t
+ImageWrapper::HeapSizeOfDecodedWithComputedFallback(mozilla::MallocSizeOf aMallocSizeOf) const
+{
+return mInnerImage->HeapSizeOfDecodedWithComputedFallback(aMallocSizeOf);
+}
+size_t
+ImageWrapper::NonHeapSizeOfDecoded() const
+{
+return mInnerImage->NonHeapSizeOfDecoded();
+}
+size_t
+ImageWrapper::OutOfProcessSizeOfDecoded() const
+{
+return mInnerImage->OutOfProcessSizeOfDecoded();
+}
+void
+ImageWrapper::IncrementAnimationConsumers()
+{
+MOZ_ASSERT(NS_IsMainThread(), "Main thread only to encourage serialization "
+"with DecrementAnimationConsumers");
+mInnerImage->IncrementAnimationConsumers();
+}
+void
+ImageWrapper::DecrementAnimationConsumers()
+{
+MOZ_ASSERT(NS_IsMainThread(), "Main thread only to encourage serialization "
+"with IncrementAnimationConsumers");
+mInnerImage->DecrementAnimationConsumers();
+}
+#ifdef DEBUG
+uint32_t
+ImageWrapper::GetAnimationConsumers()
+{
+return mInnerImage->GetAnimationConsumers();
+}
+#endif
+nsresult
+ImageWrapper::OnImageDataAvailable(nsIRequest* aRequest,
+nsISupports* aContext,
+nsIInputStream* aInStr,
+uint64_t aSourceOffset,
+uint32_t aCount)
+{
+return mInnerImage->OnImageDataAvailable(aRequest, aContext, aInStr,
+aSourceOffset, aCount);
+}
+nsresult
+ImageWrapper::OnImageDataComplete(nsIRequest* aRequest,
+nsISupports* aContext,
+nsresult aStatus,
+bool aLastPart)
+{
+return mInnerImage->OnImageDataComplete(aRequest, aContext, aStatus, aLastPart);
+}
+nsresult
+ImageWrapper::OnNewSourceData()
+{
+return mInnerImage->OnNewSourceData();
+}
+void
+ImageWrapper::SetInnerWindowID(uint64_t aInnerWindowId)
+{
+mInnerImage->SetInnerWindowID(aInnerWindowId);
+}
+uint64_t
+ImageWrapper::InnerWindowID() const
+{
+return mInnerImage->InnerWindowID();
+}
+bool
+ImageWrapper::HasError()
+{
+return mInnerImage->HasError();
+}
+void
+ImageWrapper::SetHasError()
+{
+mInnerImage->SetHasError();
+}
+ImageURL*
+ImageWrapper::GetURI()
+{
+return mInnerImage->GetURI();
+}
+// Methods inherited from XPCOM interfaces.
+NS_IMPL_ISUPPORTS(ImageWrapper, imgIContainer)
+NS_IMETHODIMP
+ImageWrapper::GetWidth(int32_t* aWidth)
+{
+return mInnerImage->GetWidth(aWidth);
+}
+NS_IMETHODIMP
+ImageWrapper::GetHeight(int32_t* aHeight)
+{
+return mInnerImage->GetHeight(aHeight);
+}
+NS_IMETHODIMP
+ImageWrapper::GetIntrinsicSize(nsSize* aSize)
+{
+return mInnerImage->GetIntrinsicSize(aSize);
+}
+NS_IMETHODIMP
+ImageWrapper::GetIntrinsicRatio(nsSize* aSize)
+{
+return mInnerImage->GetIntrinsicRatio(aSize);
+}
+NS_IMETHODIMP_(Orientation)
+ImageWrapper::GetOrientation()
+{
+return mInnerImage->GetOrientation();
+}
+NS_IMETHODIMP
+ImageWrapper::GetType(uint16_t* aType)
+{
+return mInnerImage->GetType(aType);
+}
+NS_IMETHODIMP_(uint16_t)
+ImageWrapper::GetType()
+{
+return mInnerImage->GetType();
+}
+NS_IMETHODIMP
+ImageWrapper::GetAnimated(bool* aAnimated)
+{
+return mInnerImage->GetAnimated(aAnimated);
+}
+NS_IMETHODIMP_(TemporaryRef<SourceSurface>)
+ImageWrapper::GetFrame(uint32_t aWhichFrame,
+uint32_t aFlags)
+{
+return mInnerImage->GetFrame(aWhichFrame, aFlags);
+}
+NS_IMETHODIMP_(bool)
+ImageWrapper::FrameIsOpaque(uint32_t aWhichFrame)
+{
+return mInnerImage->FrameIsOpaque(aWhichFrame);
+}
+NS_IMETHODIMP
+ImageWrapper::GetImageContainer(LayerManager* aManager, ImageContainer** _retval)
+{
+return mInnerImage->GetImageContainer(aManager, _retval);
+}
+NS_IMETHODIMP
+ImageWrapper::Draw(gfxContext* aContext,
+GraphicsFilter aFilter,
+const gfxMatrix& aUserSpaceToImageSpace,
+const gfxRect& aFill,
+const nsIntRect& aSubimage,
+const nsIntSize& aViewportSize,
+const SVGImageContext* aSVGContext,
+uint32_t aWhichFrame,
+uint32_t aFlags)
+{
+return mInnerImage->Draw(aContext, aFilter, aUserSpaceToImageSpace, aFill,
+aSubimage, aViewportSize, aSVGContext, aWhichFrame,
+aFlags);
+}
+NS_IMETHODIMP
+ImageWrapper::RequestDecode()
+{
+return mInnerImage->RequestDecode();
+}
+NS_IMETHODIMP
+ImageWrapper::StartDecoding()
+{
+return mInnerImage->StartDecoding();
+}
+bool
+ImageWrapper::IsDecoded()
+{
+return mInnerImage->IsDecoded();
+}
+NS_IMETHODIMP
+ImageWrapper::LockImage()
+{
+MOZ_ASSERT(NS_IsMainThread(),
+"Main thread to encourage serialization with UnlockImage");
+return mInnerImage->LockImage();
+}
+NS_IMETHODIMP
+ImageWrapper::UnlockImage()
+{
+MOZ_ASSERT(NS_IsMainThread(),
+"Main thread to encourage serialization with LockImage");
+return mInnerImage->UnlockImage();
+}
+NS_IMETHODIMP
+ImageWrapper::RequestDiscard()
+{
+return mInnerImage->RequestDiscard();
+}
+NS_IMETHODIMP_(void)
+ImageWrapper::RequestRefresh(const mozilla::TimeStamp& aTime)
+{
+return mInnerImage->RequestRefresh(aTime);
+}
+NS_IMETHODIMP
+ImageWrapper::GetAnimationMode(uint16_t* aAnimationMode)
+{
+return mInnerImage->GetAnimationMode(aAnimationMode);
+}
+NS_IMETHODIMP
+ImageWrapper::SetAnimationMode(uint16_t aAnimationMode)
+{
+return mInnerImage->SetAnimationMode(aAnimationMode);
+}
+NS_IMETHODIMP
+ImageWrapper::ResetAnimation()
+{
+return mInnerImage->ResetAnimation();
+}
+NS_IMETHODIMP_(float)
+ImageWrapper::GetFrameIndex(uint32_t aWhichFrame)
+{
+return mInnerImage->GetFrameIndex(aWhichFrame);
+}
+NS_IMETHODIMP_(int32_t)
+ImageWrapper::GetFirstFrameDelay()
+{
+return mInnerImage->GetFirstFrameDelay();
+}
+NS_IMETHODIMP_(void)
+ImageWrapper::SetAnimationStartTime(const mozilla::TimeStamp& aTime)
+{
+mInnerImage->SetAnimationStartTime(aTime);
+}
+} // namespace image
+} // namespace mozilla

The Tor Browser / file comparison

comparison: image/src/ImageWrapper.cpp

image/src/ImageWrapper.cpp