diff options
Diffstat (limited to 'layout/style/ImageLoader.cpp')
| -rw-r--r-- | layout/style/ImageLoader.cpp | 529 |
1 files changed, 529 insertions, 0 deletions
diff --git a/layout/style/ImageLoader.cpp b/layout/style/ImageLoader.cpp new file mode 100644 index 000000000..0a605abc9 --- /dev/null +++ b/layout/style/ImageLoader.cpp @@ -0,0 +1,529 @@ +/* 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/. */ + +/* A class that handles style system image loads (other image loads are handled + * by the nodes in the content tree). + */ + +#include "mozilla/css/ImageLoader.h" +#include "nsAutoPtr.h" +#include "nsContentUtils.h" +#include "nsLayoutUtils.h" +#include "nsError.h" +#include "nsDisplayList.h" +#include "FrameLayerBuilder.h" +#include "nsSVGEffects.h" +#include "imgIContainer.h" +#include "Image.h" + +namespace mozilla { +namespace css { + +void +ImageLoader::DropDocumentReference() +{ + // It's okay if GetPresContext returns null here (due to the presshell pointer + // on the document being null) as that means the presshell has already + // been destroyed, and it also calls ClearFrames when it is destroyed. + ClearFrames(GetPresContext()); + + for (auto it = mImages.Iter(); !it.Done(); it.Next()) { + ImageLoader::Image* image = it.Get()->GetKey(); + imgIRequest* request = image->mRequests.GetWeak(mDocument); + if (request) { + request->CancelAndForgetObserver(NS_BINDING_ABORTED); + } + image->mRequests.Remove(mDocument); + } + mImages.Clear(); + + mDocument = nullptr; +} + +void +ImageLoader::AssociateRequestToFrame(imgIRequest* aRequest, + nsIFrame* aFrame) +{ + nsCOMPtr<imgINotificationObserver> observer; + aRequest->GetNotificationObserver(getter_AddRefs(observer)); + if (!observer) { + // The request has already been canceled, so ignore it. This is ok because + // we're not going to get any more notifications from a canceled request. + return; + } + + MOZ_ASSERT(observer == this); + + FrameSet* frameSet = nullptr; + if (mRequestToFrameMap.Get(aRequest, &frameSet)) { + NS_ASSERTION(frameSet, "This should never be null!"); + } + + if (!frameSet) { + nsAutoPtr<FrameSet> newFrameSet(new FrameSet()); + + mRequestToFrameMap.Put(aRequest, newFrameSet); + frameSet = newFrameSet.forget(); + + nsPresContext* presContext = GetPresContext(); + if (presContext) { + nsLayoutUtils::RegisterImageRequestIfAnimated(presContext, + aRequest, + nullptr); + } + } + + RequestSet* requestSet = nullptr; + if (mFrameToRequestMap.Get(aFrame, &requestSet)) { + NS_ASSERTION(requestSet, "This should never be null"); + } + + if (!requestSet) { + nsAutoPtr<RequestSet> newRequestSet(new RequestSet()); + + mFrameToRequestMap.Put(aFrame, newRequestSet); + requestSet = newRequestSet.forget(); + } + + // Add these to the sets, but only if they're not already there. + uint32_t i = frameSet->IndexOfFirstElementGt(aFrame); + if (i == 0 || aFrame != frameSet->ElementAt(i-1)) { + frameSet->InsertElementAt(i, aFrame); + } + i = requestSet->IndexOfFirstElementGt(aRequest); + if (i == 0 || aRequest != requestSet->ElementAt(i-1)) { + requestSet->InsertElementAt(i, aRequest); + } +} + +void +ImageLoader::MaybeRegisterCSSImage(ImageLoader::Image* aImage) +{ + NS_ASSERTION(aImage, "This should never be null!"); + + bool found = false; + aImage->mRequests.GetWeak(mDocument, &found); + if (found) { + // This document already has a request. + return; + } + + imgRequestProxy* canonicalRequest = aImage->mRequests.GetWeak(nullptr); + if (!canonicalRequest) { + // The image was blocked or something. + return; + } + + RefPtr<imgRequestProxy> request; + + // Ignore errors here. If cloning fails for some reason we'll put a null + // entry in the hash and we won't keep trying to clone. + mInClone = true; + canonicalRequest->Clone(this, getter_AddRefs(request)); + mInClone = false; + + aImage->mRequests.Put(mDocument, request); + + AddImage(aImage); +} + +void +ImageLoader::DeregisterCSSImage(ImageLoader::Image* aImage) +{ + RemoveImage(aImage); +} + +void +ImageLoader::DisassociateRequestFromFrame(imgIRequest* aRequest, + nsIFrame* aFrame) +{ + FrameSet* frameSet = nullptr; + RequestSet* requestSet = nullptr; + +#ifdef DEBUG + { + nsCOMPtr<imgINotificationObserver> observer; + aRequest->GetNotificationObserver(getter_AddRefs(observer)); + MOZ_ASSERT(!observer || observer == this); + } +#endif + + mRequestToFrameMap.Get(aRequest, &frameSet); + mFrameToRequestMap.Get(aFrame, &requestSet); + + if (frameSet) { + frameSet->RemoveElementSorted(aFrame); + } + if (requestSet) { + requestSet->RemoveElementSorted(aRequest); + } + + if (frameSet && !frameSet->Length()) { + mRequestToFrameMap.Remove(aRequest); + + nsPresContext* presContext = GetPresContext(); + if (presContext) { + nsLayoutUtils::DeregisterImageRequest(presContext, + aRequest, + nullptr); + } + } + + if (requestSet && !requestSet->Length()) { + mFrameToRequestMap.Remove(aFrame); + } +} + +void +ImageLoader::DropRequestsForFrame(nsIFrame* aFrame) +{ + RequestSet* requestSet = nullptr; + if (!mFrameToRequestMap.Get(aFrame, &requestSet)) { + return; + } + + NS_ASSERTION(requestSet, "This should never be null"); + + RequestSet frozenRequestSet(*requestSet); + for (RequestSet::size_type i = frozenRequestSet.Length(); i != 0; --i) { + imgIRequest* request = frozenRequestSet.ElementAt(i - 1); + + DisassociateRequestFromFrame(request, aFrame); + } +} + +void +ImageLoader::SetAnimationMode(uint16_t aMode) +{ + NS_ASSERTION(aMode == imgIContainer::kNormalAnimMode || + aMode == imgIContainer::kDontAnimMode || + aMode == imgIContainer::kLoopOnceAnimMode, + "Wrong Animation Mode is being set!"); + + for (auto iter = mRequestToFrameMap.ConstIter(); !iter.Done(); iter.Next()) { + auto request = static_cast<imgIRequest*>(iter.Key()); + +#ifdef DEBUG + { + nsCOMPtr<imgIRequest> debugRequest = do_QueryInterface(request); + NS_ASSERTION(debugRequest == request, "This is bad"); + } +#endif + + nsCOMPtr<imgIContainer> container; + request->GetImage(getter_AddRefs(container)); + if (!container) { + continue; + } + + // This can fail if the image is in error, and we don't care. + container->SetAnimationMode(aMode); + } +} + +void +ImageLoader::ClearFrames(nsPresContext* aPresContext) +{ + for (auto iter = mRequestToFrameMap.ConstIter(); !iter.Done(); iter.Next()) { + auto request = static_cast<imgIRequest*>(iter.Key()); + +#ifdef DEBUG + { + nsCOMPtr<imgIRequest> debugRequest = do_QueryInterface(request); + NS_ASSERTION(debugRequest == request, "This is bad"); + } +#endif + + if (aPresContext) { + nsLayoutUtils::DeregisterImageRequest(aPresContext, + request, + nullptr); + } + } + + mRequestToFrameMap.Clear(); + mFrameToRequestMap.Clear(); +} + +void +ImageLoader::LoadImage(nsIURI* aURI, nsIPrincipal* aOriginPrincipal, + nsIURI* aReferrer, ImageLoader::Image* aImage) +{ + NS_ASSERTION(aImage->mRequests.Count() == 0, "Huh?"); + + aImage->mRequests.Put(nullptr, nullptr); + + if (!aURI) { + return; + } + + RefPtr<imgRequestProxy> request; + nsresult rv = nsContentUtils::LoadImage(aURI, mDocument, mDocument, + aOriginPrincipal, aReferrer, + mDocument->GetReferrerPolicy(), + nullptr, nsIRequest::LOAD_NORMAL, + NS_LITERAL_STRING("css"), + getter_AddRefs(request)); + + if (NS_FAILED(rv) || !request) { + return; + } + + RefPtr<imgRequestProxy> clonedRequest; + mInClone = true; + rv = request->Clone(this, getter_AddRefs(clonedRequest)); + mInClone = false; + + if (NS_FAILED(rv)) { + return; + } + + aImage->mRequests.Put(nullptr, request); + aImage->mRequests.Put(mDocument, clonedRequest); + + AddImage(aImage); +} + +void +ImageLoader::AddImage(ImageLoader::Image* aImage) +{ + NS_ASSERTION(!mImages.Contains(aImage), "Huh?"); + mImages.PutEntry(aImage); +} + +void +ImageLoader::RemoveImage(ImageLoader::Image* aImage) +{ + NS_ASSERTION(mImages.Contains(aImage), "Huh?"); + mImages.RemoveEntry(aImage); +} + +nsPresContext* +ImageLoader::GetPresContext() +{ + if (!mDocument) { + return nullptr; + } + + nsIPresShell* shell = mDocument->GetShell(); + if (!shell) { + return nullptr; + } + + return shell->GetPresContext(); +} + +void InvalidateImagesCallback(nsIFrame* aFrame, + FrameLayerBuilder::DisplayItemData* aItem) +{ + nsDisplayItem::Type type = nsDisplayItem::GetDisplayItemTypeFromKey(aItem->GetDisplayItemKey()); + uint8_t flags = nsDisplayItem::GetDisplayItemFlagsForType(type); + + if (flags & nsDisplayItem::TYPE_RENDERS_NO_IMAGES) { + return; + } + + if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) { + printf_stderr("Invalidating display item(type=%d) based on frame %p \ + because it might contain an invalidated image\n", type, aFrame); + } + aItem->Invalidate(); + aFrame->SchedulePaint(); +} + +void +ImageLoader::DoRedraw(FrameSet* aFrameSet, bool aForcePaint) +{ + NS_ASSERTION(aFrameSet, "Must have a frame set"); + NS_ASSERTION(mDocument, "Should have returned earlier!"); + + FrameSet::size_type length = aFrameSet->Length(); + for (FrameSet::size_type i = 0; i < length; i++) { + nsIFrame* frame = aFrameSet->ElementAt(i); + + if (frame->StyleVisibility()->IsVisible()) { + if (frame->IsFrameOfType(nsIFrame::eTablePart)) { + // Tables don't necessarily build border/background display items + // for the individual table part frames, so IterateRetainedDataFor + // might not find the right display item. + frame->InvalidateFrame(); + } else { + FrameLayerBuilder::IterateRetainedDataFor(frame, InvalidateImagesCallback); + + // Update ancestor rendering observers (-moz-element etc) + nsIFrame *f = frame; + while (f && !f->HasAnyStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT)) { + nsSVGEffects::InvalidateDirectRenderingObservers(f); + f = nsLayoutUtils::GetCrossDocParentFrame(f); + } + + if (aForcePaint) { + frame->SchedulePaint(); + } + } + } + } +} + +NS_IMPL_ADDREF(ImageLoader) +NS_IMPL_RELEASE(ImageLoader) + +NS_INTERFACE_MAP_BEGIN(ImageLoader) + NS_INTERFACE_MAP_ENTRY(imgINotificationObserver) + NS_INTERFACE_MAP_ENTRY(imgIOnloadBlocker) +NS_INTERFACE_MAP_END + +NS_IMETHODIMP +ImageLoader::Notify(imgIRequest* aRequest, int32_t aType, const nsIntRect* aData) +{ + if (aType == imgINotificationObserver::SIZE_AVAILABLE) { + nsCOMPtr<imgIContainer> image; + aRequest->GetImage(getter_AddRefs(image)); + return OnSizeAvailable(aRequest, image); + } + + if (aType == imgINotificationObserver::IS_ANIMATED) { + return OnImageIsAnimated(aRequest); + } + + if (aType == imgINotificationObserver::FRAME_COMPLETE) { + return OnFrameComplete(aRequest); + } + + if (aType == imgINotificationObserver::FRAME_UPDATE) { + return OnFrameUpdate(aRequest); + } + + if (aType == imgINotificationObserver::DECODE_COMPLETE) { + nsCOMPtr<imgIContainer> image; + aRequest->GetImage(getter_AddRefs(image)); + if (image && mDocument) { + image->PropagateUseCounters(mDocument); + } + } + + return NS_OK; +} + +nsresult +ImageLoader::OnSizeAvailable(imgIRequest* aRequest, imgIContainer* aImage) +{ + nsPresContext* presContext = GetPresContext(); + if (!presContext) { + return NS_OK; + } + + aImage->SetAnimationMode(presContext->ImageAnimationMode()); + + return NS_OK; +} + +nsresult +ImageLoader::OnImageIsAnimated(imgIRequest* aRequest) +{ + if (!mDocument) { + return NS_OK; + } + + FrameSet* frameSet = nullptr; + if (!mRequestToFrameMap.Get(aRequest, &frameSet)) { + return NS_OK; + } + + // Register with the refresh driver now that we are aware that + // we are animated. + nsPresContext* presContext = GetPresContext(); + if (presContext) { + nsLayoutUtils::RegisterImageRequest(presContext, + aRequest, + nullptr); + } + + return NS_OK; +} + +nsresult +ImageLoader::OnFrameComplete(imgIRequest* aRequest) +{ + if (!mDocument || mInClone) { + return NS_OK; + } + + FrameSet* frameSet = nullptr; + if (!mRequestToFrameMap.Get(aRequest, &frameSet)) { + return NS_OK; + } + + NS_ASSERTION(frameSet, "This should never be null!"); + + // Since we just finished decoding a frame, we always want to paint, in case + // we're now able to paint an image that we couldn't paint before (and hence + // that we don't have retained data for). + DoRedraw(frameSet, /* aForcePaint = */ true); + + return NS_OK; +} + +nsresult +ImageLoader::OnFrameUpdate(imgIRequest* aRequest) +{ + if (!mDocument || mInClone) { + return NS_OK; + } + + FrameSet* frameSet = nullptr; + if (!mRequestToFrameMap.Get(aRequest, &frameSet)) { + return NS_OK; + } + + NS_ASSERTION(frameSet, "This should never be null!"); + + DoRedraw(frameSet, /* aForcePaint = */ false); + + return NS_OK; +} + +NS_IMETHODIMP +ImageLoader::BlockOnload(imgIRequest* aRequest) +{ + if (!mDocument) { + return NS_OK; + } + + mDocument->BlockOnload(); + + return NS_OK; +} + +NS_IMETHODIMP +ImageLoader::UnblockOnload(imgIRequest* aRequest) +{ + if (!mDocument) { + return NS_OK; + } + + mDocument->UnblockOnload(false); + + return NS_OK; +} + +void +ImageLoader::FlushUseCounters() +{ + for (auto iter = mImages.Iter(); !iter.Done(); iter.Next()) { + nsPtrHashKey<Image>* key = iter.Get(); + ImageLoader::Image* image = key->GetKey(); + + imgIRequest* request = image->mRequests.GetWeak(mDocument); + + nsCOMPtr<imgIContainer> container; + request->GetImage(getter_AddRefs(container)); + if (container) { + static_cast<image::Image*>(container.get())->ReportUseCounters(); + } + } +} + +} // namespace css +} // namespace mozilla |