summaryrefslogtreecommitdiffstats
path: root/layout/style/ImageLoader.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /layout/style/ImageLoader.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'layout/style/ImageLoader.cpp')
-rw-r--r--layout/style/ImageLoader.cpp529
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