/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=8 sts=2 et sw=2 tw=80: */ /* 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 base class which implements nsIImageLoadingContent and can be * subclassed by various content nodes that want to provide image * loading functionality (eg , , etc). */ #include "nsImageLoadingContent.h" #include "nsError.h" #include "nsIContent.h" #include "nsIDocument.h" #include "nsIScriptGlobalObject.h" #include "nsIDOMWindow.h" #include "nsServiceManagerUtils.h" #include "nsContentPolicyUtils.h" #include "nsIURI.h" #include "nsILoadGroup.h" #include "imgIContainer.h" #include "imgLoader.h" #include "imgRequestProxy.h" #include "nsThreadUtils.h" #include "nsNetUtil.h" #include "nsImageFrame.h" #include "nsIPresShell.h" #include "nsIChannel.h" #include "nsIStreamListener.h" #include "nsIFrame.h" #include "nsIDOMNode.h" #include "nsContentUtils.h" #include "nsLayoutUtils.h" #include "nsIContentPolicy.h" #include "nsSVGEffects.h" #include "gfxPrefs.h" #include "mozAutoDocUpdate.h" #include "mozilla/AsyncEventDispatcher.h" #include "mozilla/CycleCollectedJSContext.h" #include "mozilla/EventStates.h" #include "mozilla/dom/Element.h" #include "mozilla/dom/ImageTracker.h" #include "mozilla/dom/ScriptSettings.h" #include "mozilla/Preferences.h" #ifdef LoadImage // Undefine LoadImage to prevent naming conflict with Windows. #undef LoadImage #endif using namespace mozilla; using namespace mozilla::dom; #ifdef DEBUG_chb static void PrintReqURL(imgIRequest* req) { if (!req) { printf("(null req)\n"); return; } nsCOMPtr uri; req->GetURI(getter_AddRefs(uri)); if (!uri) { printf("(null uri)\n"); return; } nsAutoCString spec; uri->GetSpec(spec); printf("spec='%s'\n", spec.get()); } #endif /* DEBUG_chb */ nsImageLoadingContent::nsImageLoadingContent() : mCurrentRequestFlags(0), mPendingRequestFlags(0), mObserverList(nullptr), mImageBlockingStatus(nsIContentPolicy::ACCEPT), mLoadingEnabled(true), mIsImageStateForced(false), mLoading(false), // mBroken starts out true, since an image without a URI is broken.... mBroken(true), mUserDisabled(false), mSuppressed(false), mNewRequestsWillNeedAnimationReset(false), mStateChangerDepth(0), mCurrentRequestRegistered(false), mPendingRequestRegistered(false), mFrameCreateCalled(false) { if (!nsContentUtils::GetImgLoaderForChannel(nullptr, nullptr)) { mLoadingEnabled = false; } bool isInconsistent; mMostRecentRequestChange = TimeStamp::ProcessCreation(isInconsistent); } void nsImageLoadingContent::DestroyImageLoadingContent() { // Cancel our requests so they won't hold stale refs to us // NB: Don't ask to discard the images here. ClearCurrentRequest(NS_BINDING_ABORTED); ClearPendingRequest(NS_BINDING_ABORTED); } nsImageLoadingContent::~nsImageLoadingContent() { NS_ASSERTION(!mCurrentRequest && !mPendingRequest, "DestroyImageLoadingContent not called"); NS_ASSERTION(!mObserverList.mObserver && !mObserverList.mNext, "Observers still registered?"); } /* * imgINotificationObserver impl */ NS_IMETHODIMP nsImageLoadingContent::Notify(imgIRequest* aRequest, int32_t aType, const nsIntRect* aData) { if (aType == imgINotificationObserver::IS_ANIMATED) { return OnImageIsAnimated(aRequest); } if (aType == imgINotificationObserver::UNLOCKED_DRAW) { OnUnlockedDraw(); return NS_OK; } if (aType == imgINotificationObserver::LOAD_COMPLETE) { // We should definitely have a request here MOZ_ASSERT(aRequest, "no request?"); NS_PRECONDITION(aRequest == mCurrentRequest || aRequest == mPendingRequest, "Unknown request"); } { MOZ_RELEASE_ASSERT(js::AllowGCBarriers(CycleCollectedJSContext::Get()->Context()), "ImageObservers can be implement in JS, so they should not be called during painting. See bug 1311841"); nsAutoScriptBlocker scriptBlocker; for (ImageObserver* observer = &mObserverList, *next; observer; observer = next) { next = observer->mNext; if (observer->mObserver) { observer->mObserver->Notify(aRequest, aType, aData); } } } if (aType == imgINotificationObserver::SIZE_AVAILABLE) { // Have to check for state changes here, since we might have been in // the LOADING state before. UpdateImageState(true); } if (aType == imgINotificationObserver::LOAD_COMPLETE) { uint32_t reqStatus; aRequest->GetImageStatus(&reqStatus); /* triage STATUS_ERROR */ if (reqStatus & imgIRequest::STATUS_ERROR) { nsresult errorCode = NS_OK; aRequest->GetImageErrorCode(&errorCode); /* Handle image not loading error because source was a tracking URL. * We make a note of this image node by including it in a dedicated * array of blocked tracking nodes under its parent document. */ if (errorCode == NS_ERROR_TRACKING_URI) { nsCOMPtr thisNode = do_QueryInterface(static_cast(this)); nsIDocument *doc = GetOurOwnerDoc(); doc->AddBlockedTrackingNode(thisNode); } } nsresult status = reqStatus & imgIRequest::STATUS_ERROR ? NS_ERROR_FAILURE : NS_OK; return OnLoadComplete(aRequest, status); } if (aType == imgINotificationObserver::DECODE_COMPLETE) { nsCOMPtr container; aRequest->GetImage(getter_AddRefs(container)); if (container) { container->PropagateUseCounters(GetOurOwnerDoc()); } UpdateImageState(true); } return NS_OK; } nsresult nsImageLoadingContent::OnLoadComplete(imgIRequest* aRequest, nsresult aStatus) { uint32_t oldStatus; aRequest->GetImageStatus(&oldStatus); //XXXjdm This occurs when we have a pending request created, then another // pending request replaces it before the first one is finished. // This begs the question of what the correct behaviour is; we used // to not have to care because we ran this code in OnStopDecode which // wasn't called when the first request was cancelled. For now, I choose // to punt when the given request doesn't appear to have terminated in // an expected state. if (!(oldStatus & (imgIRequest::STATUS_ERROR | imgIRequest::STATUS_LOAD_COMPLETE))) return NS_OK; // Our state may change. Watch it. AutoStateChanger changer(this, true); // If the pending request is loaded, switch to it. if (aRequest == mPendingRequest) { MakePendingRequestCurrent(); } MOZ_ASSERT(aRequest == mCurrentRequest, "One way or another, we should be current by now"); // Fire the appropriate DOM event. if (NS_SUCCEEDED(aStatus)) { FireEvent(NS_LITERAL_STRING("load")); // Do not fire loadend event for multipart/x-mixed-replace image streams. bool isMultipart; if (NS_FAILED(aRequest->GetMultipart(&isMultipart)) || !isMultipart) { FireEvent(NS_LITERAL_STRING("loadend")); } } else { FireEvent(NS_LITERAL_STRING("error")); FireEvent(NS_LITERAL_STRING("loadend")); } nsCOMPtr thisNode = do_QueryInterface(static_cast(this)); nsSVGEffects::InvalidateDirectRenderingObservers(thisNode->AsElement()); return NS_OK; } static bool ImageIsAnimated(imgIRequest* aRequest) { if (!aRequest) { return false; } nsCOMPtr image; if (NS_SUCCEEDED(aRequest->GetImage(getter_AddRefs(image)))) { bool isAnimated = false; nsresult rv = image->GetAnimated(&isAnimated); if (NS_SUCCEEDED(rv) && isAnimated) { return true; } } return false; } void nsImageLoadingContent::OnUnlockedDraw() { // It's OK for non-animated images to wait until the next frame visibility // update to become locked. (And that's preferable, since in the case of // scrolling it keeps memory usage minimal.) For animated images, though, we // want to mark them visible right away so we can call // IncrementAnimationConsumers() on them and they'll start animating. if (!ImageIsAnimated(mCurrentRequest) && !ImageIsAnimated(mPendingRequest)) { return; } nsIFrame* frame = GetOurPrimaryFrame(); if (!frame) { return; } if (frame->GetVisibility() == Visibility::APPROXIMATELY_VISIBLE) { // This frame is already marked visible; there's nothing to do. return; } nsPresContext* presContext = frame->PresContext(); if (!presContext) { return; } nsIPresShell* presShell = presContext->PresShell(); if (!presShell) { return; } presShell->EnsureFrameInApproximatelyVisibleList(frame); } nsresult nsImageLoadingContent::OnImageIsAnimated(imgIRequest *aRequest) { bool* requestFlag = GetRegisteredFlagForRequest(aRequest); if (requestFlag) { nsLayoutUtils::RegisterImageRequest(GetFramePresContext(), aRequest, requestFlag); } return NS_OK; } /* * nsIImageLoadingContent impl */ NS_IMETHODIMP nsImageLoadingContent::GetLoadingEnabled(bool *aLoadingEnabled) { *aLoadingEnabled = mLoadingEnabled; return NS_OK; } NS_IMETHODIMP nsImageLoadingContent::SetLoadingEnabled(bool aLoadingEnabled) { if (nsContentUtils::GetImgLoaderForChannel(nullptr, nullptr)) { mLoadingEnabled = aLoadingEnabled; } return NS_OK; } NS_IMETHODIMP nsImageLoadingContent::GetImageBlockingStatus(int16_t* aStatus) { NS_PRECONDITION(aStatus, "Null out param"); *aStatus = ImageBlockingStatus(); return NS_OK; } static void ReplayImageStatus(imgIRequest* aRequest, imgINotificationObserver* aObserver) { if (!aRequest) { return; } uint32_t status = 0; nsresult rv = aRequest->GetImageStatus(&status); if (NS_FAILED(rv)) { return; } if (status & imgIRequest::STATUS_SIZE_AVAILABLE) { aObserver->Notify(aRequest, imgINotificationObserver::SIZE_AVAILABLE, nullptr); } if (status & imgIRequest::STATUS_FRAME_COMPLETE) { aObserver->Notify(aRequest, imgINotificationObserver::FRAME_COMPLETE, nullptr); } if (status & imgIRequest::STATUS_HAS_TRANSPARENCY) { aObserver->Notify(aRequest, imgINotificationObserver::HAS_TRANSPARENCY, nullptr); } if (status & imgIRequest::STATUS_IS_ANIMATED) { aObserver->Notify(aRequest, imgINotificationObserver::IS_ANIMATED, nullptr); } if (status & imgIRequest::STATUS_DECODE_COMPLETE) { aObserver->Notify(aRequest, imgINotificationObserver::DECODE_COMPLETE, nullptr); } if (status & imgIRequest::STATUS_LOAD_COMPLETE) { aObserver->Notify(aRequest, imgINotificationObserver::LOAD_COMPLETE, nullptr); } } NS_IMETHODIMP nsImageLoadingContent::AddObserver(imgINotificationObserver* aObserver) { NS_ENSURE_ARG_POINTER(aObserver); if (!mObserverList.mObserver) { // Don't touch the linking of the list! mObserverList.mObserver = aObserver; ReplayImageStatus(mCurrentRequest, aObserver); ReplayImageStatus(mPendingRequest, aObserver); return NS_OK; } // otherwise we have to create a new entry ImageObserver* observer = &mObserverList; while (observer->mNext) { observer = observer->mNext; } observer->mNext = new ImageObserver(aObserver); ReplayImageStatus(mCurrentRequest, aObserver); ReplayImageStatus(mPendingRequest, aObserver); return NS_OK; } NS_IMETHODIMP nsImageLoadingContent::RemoveObserver(imgINotificationObserver* aObserver) { NS_ENSURE_ARG_POINTER(aObserver); if (mObserverList.mObserver == aObserver) { mObserverList.mObserver = nullptr; // Don't touch the linking of the list! return NS_OK; } // otherwise have to find it and splice it out ImageObserver* observer = &mObserverList; while (observer->mNext && observer->mNext->mObserver != aObserver) { observer = observer->mNext; } // At this point, we are pointing to the list element whose mNext is // the right observer (assuming of course that mNext is not null) if (observer->mNext) { // splice it out ImageObserver* oldObserver = observer->mNext; observer->mNext = oldObserver->mNext; oldObserver->mNext = nullptr; // so we don't destroy them all delete oldObserver; } #ifdef DEBUG else { NS_WARNING("Asked to remove nonexistent observer"); } #endif return NS_OK; } already_AddRefed nsImageLoadingContent::GetRequest(int32_t aRequestType, ErrorResult& aError) { nsCOMPtr request; switch(aRequestType) { case CURRENT_REQUEST: request = mCurrentRequest; break; case PENDING_REQUEST: request = mPendingRequest; break; default: NS_ERROR("Unknown request type"); aError.Throw(NS_ERROR_UNEXPECTED); } return request.forget(); } NS_IMETHODIMP nsImageLoadingContent::GetRequest(int32_t aRequestType, imgIRequest** aRequest) { NS_ENSURE_ARG_POINTER(aRequest); ErrorResult result; *aRequest = GetRequest(aRequestType, result).take(); return result.StealNSResult(); } NS_IMETHODIMP_(bool) nsImageLoadingContent::CurrentRequestHasSize() { return HaveSize(mCurrentRequest); } NS_IMETHODIMP_(void) nsImageLoadingContent::FrameCreated(nsIFrame* aFrame) { NS_ASSERTION(aFrame, "aFrame is null"); mFrameCreateCalled = true; TrackImage(mCurrentRequest); TrackImage(mPendingRequest); // We need to make sure that our image request is registered, if it should // be registered. nsPresContext* presContext = aFrame->PresContext(); if (mCurrentRequest) { nsLayoutUtils::RegisterImageRequestIfAnimated(presContext, mCurrentRequest, &mCurrentRequestRegistered); } if (mPendingRequest) { nsLayoutUtils::RegisterImageRequestIfAnimated(presContext, mPendingRequest, &mPendingRequestRegistered); } } NS_IMETHODIMP_(void) nsImageLoadingContent::FrameDestroyed(nsIFrame* aFrame) { NS_ASSERTION(aFrame, "aFrame is null"); mFrameCreateCalled = false; // We need to make sure that our image request is deregistered. nsPresContext* presContext = GetFramePresContext(); if (mCurrentRequest) { nsLayoutUtils::DeregisterImageRequest(presContext, mCurrentRequest, &mCurrentRequestRegistered); } if (mPendingRequest) { nsLayoutUtils::DeregisterImageRequest(presContext, mPendingRequest, &mPendingRequestRegistered); } UntrackImage(mCurrentRequest); UntrackImage(mPendingRequest); nsIPresShell* presShell = presContext ? presContext->GetPresShell() : nullptr; if (presShell) { presShell->RemoveFrameFromApproximatelyVisibleList(aFrame); } } /* static */ nsContentPolicyType nsImageLoadingContent::PolicyTypeForLoad(ImageLoadType aImageLoadType) { if (aImageLoadType == eImageLoadType_Imageset) { return nsIContentPolicy::TYPE_IMAGESET; } MOZ_ASSERT(aImageLoadType == eImageLoadType_Normal, "Unknown ImageLoadType type in PolicyTypeForLoad"); return nsIContentPolicy::TYPE_INTERNAL_IMAGE; } int32_t nsImageLoadingContent::GetRequestType(imgIRequest* aRequest, ErrorResult& aError) { if (aRequest == mCurrentRequest) { return CURRENT_REQUEST; } if (aRequest == mPendingRequest) { return PENDING_REQUEST; } NS_ERROR("Unknown request"); aError.Throw(NS_ERROR_UNEXPECTED); return UNKNOWN_REQUEST; } NS_IMETHODIMP nsImageLoadingContent::GetRequestType(imgIRequest* aRequest, int32_t* aRequestType) { NS_PRECONDITION(aRequestType, "Null out param"); ErrorResult result; *aRequestType = GetRequestType(aRequest, result); return result.StealNSResult(); } already_AddRefed nsImageLoadingContent::GetCurrentURI(ErrorResult& aError) { nsCOMPtr uri; if (mCurrentRequest) { mCurrentRequest->GetURI(getter_AddRefs(uri)); } else if (mCurrentURI) { nsresult rv = NS_EnsureSafeToReturn(mCurrentURI, getter_AddRefs(uri)); if (NS_FAILED(rv)) { aError.Throw(rv); } } return uri.forget(); } NS_IMETHODIMP nsImageLoadingContent::GetCurrentURI(nsIURI** aURI) { NS_ENSURE_ARG_POINTER(aURI); ErrorResult result; *aURI = GetCurrentURI(result).take(); return result.StealNSResult(); } NS_IMETHODIMP nsImageLoadingContent::LoadImageWithChannel(nsIChannel* aChannel, nsIStreamListener** aListener) { imgLoader* loader = nsContentUtils::GetImgLoaderForChannel(aChannel, GetOurOwnerDoc()); if (!loader) { return NS_ERROR_NULL_POINTER; } nsCOMPtr doc = GetOurOwnerDoc(); if (!doc) { // Don't bother *aListener = nullptr; return NS_OK; } // XXX what should we do with content policies here, if anything? // Shouldn't that be done before the start of the load? // XXX what about shouldProcess? // Our state might change. Watch it. AutoStateChanger changer(this, true); // Do the load. RefPtr& req = PrepareNextRequest(eImageLoadType_Normal); nsresult rv = loader-> LoadImageWithChannel(aChannel, this, doc, aListener, getter_AddRefs(req)); if (NS_SUCCEEDED(rv)) { TrackImage(req); ResetAnimationIfNeeded(); return NS_OK; } MOZ_ASSERT(!req, "Shouldn't have non-null request here"); // If we don't have a current URI, we might as well store this URI so people // know what we tried (and failed) to load. if (!mCurrentRequest) aChannel->GetURI(getter_AddRefs(mCurrentURI)); FireEvent(NS_LITERAL_STRING("error")); FireEvent(NS_LITERAL_STRING("loadend")); return rv; } void nsImageLoadingContent::ForceReload(const mozilla::dom::Optional& aNotify, mozilla::ErrorResult& aError) { nsCOMPtr currentURI; GetCurrentURI(getter_AddRefs(currentURI)); if (!currentURI) { aError.Throw(NS_ERROR_NOT_AVAILABLE); return; } // defaults to true bool notify = !aNotify.WasPassed() || aNotify.Value(); // We keep this flag around along with the old URI even for failed requests // without a live request object ImageLoadType loadType = \ (mCurrentRequestFlags & REQUEST_IS_IMAGESET) ? eImageLoadType_Imageset : eImageLoadType_Normal; nsresult rv = LoadImage(currentURI, true, notify, loadType, true, nullptr, nsIRequest::VALIDATE_ALWAYS); if (NS_FAILED(rv)) { aError.Throw(rv); } } NS_IMETHODIMP nsImageLoadingContent::ForceReload(bool aNotify /* = true */, uint8_t aArgc) { mozilla::dom::Optional notify; if (aArgc >= 1) { notify.Construct() = aNotify; } ErrorResult result; ForceReload(notify, result); return result.StealNSResult(); } NS_IMETHODIMP nsImageLoadingContent::BlockOnload(imgIRequest* aRequest) { if (aRequest == mCurrentRequest) { NS_ASSERTION(!(mCurrentRequestFlags & REQUEST_BLOCKS_ONLOAD), "Double BlockOnload!?"); mCurrentRequestFlags |= REQUEST_BLOCKS_ONLOAD; } else if (aRequest == mPendingRequest) { NS_ASSERTION(!(mPendingRequestFlags & REQUEST_BLOCKS_ONLOAD), "Double BlockOnload!?"); mPendingRequestFlags |= REQUEST_BLOCKS_ONLOAD; } else { return NS_OK; } nsIDocument* doc = GetOurCurrentDoc(); if (doc) { doc->BlockOnload(); } return NS_OK; } NS_IMETHODIMP nsImageLoadingContent::UnblockOnload(imgIRequest* aRequest) { if (aRequest == mCurrentRequest) { NS_ASSERTION(mCurrentRequestFlags & REQUEST_BLOCKS_ONLOAD, "Double UnblockOnload!?"); mCurrentRequestFlags &= ~REQUEST_BLOCKS_ONLOAD; } else if (aRequest == mPendingRequest) { NS_ASSERTION(mPendingRequestFlags & REQUEST_BLOCKS_ONLOAD, "Double UnblockOnload!?"); mPendingRequestFlags &= ~REQUEST_BLOCKS_ONLOAD; } else { return NS_OK; } nsIDocument* doc = GetOurCurrentDoc(); if (doc) { doc->UnblockOnload(false); } return NS_OK; } /* * Non-interface methods */ nsresult nsImageLoadingContent::LoadImage(const nsAString& aNewURI, bool aForce, bool aNotify, ImageLoadType aImageLoadType) { // First, get a document (needed for security checks and the like) nsIDocument* doc = GetOurOwnerDoc(); if (!doc) { // No reason to bother, I think... return NS_OK; } // Pending load/error events need to be canceled in some situations. This // is not documented in the spec, but can cause site compat problems if not // done. See bug 1309461 and https://github.com/whatwg/html/issues/1872. CancelPendingEvent(); if (aNewURI.IsEmpty()) { // Cancel image requests and then fire only error event per spec. CancelImageRequests(aNotify); // Mark error event as cancelable only for src="" case, since only this // error causes site compat problem (bug 1308069) for now. FireEvent(NS_LITERAL_STRING("error"), true); return NS_OK; } // Fire loadstart event FireEvent(NS_LITERAL_STRING("loadstart")); // Parse the URI string to get image URI nsCOMPtr imageURI; nsresult rv = StringToURI(aNewURI, doc, getter_AddRefs(imageURI)); if (NS_FAILED(rv)) { // Cancel image requests and then fire error and loadend events per spec CancelImageRequests(aNotify); FireEvent(NS_LITERAL_STRING("error")); FireEvent(NS_LITERAL_STRING("loadend")); return NS_OK; } NS_TryToSetImmutable(imageURI); return LoadImage(imageURI, aForce, aNotify, aImageLoadType, false, doc); } nsresult nsImageLoadingContent::LoadImage(nsIURI* aNewURI, bool aForce, bool aNotify, ImageLoadType aImageLoadType, bool aLoadStart, nsIDocument* aDocument, nsLoadFlags aLoadFlags) { // Pending load/error events need to be canceled in some situations. This // is not documented in the spec, but can cause site compat problems if not // done. See bug 1309461 and https://github.com/whatwg/html/issues/1872. CancelPendingEvent(); // Fire loadstart event if required if (aLoadStart) { FireEvent(NS_LITERAL_STRING("loadstart")); } if (!mLoadingEnabled) { // XXX Why fire an error here? seems like the callers to SetLoadingEnabled // don't want/need it. FireEvent(NS_LITERAL_STRING("error")); FireEvent(NS_LITERAL_STRING("loadend")); return NS_OK; } NS_ASSERTION(!aDocument || aDocument == GetOurOwnerDoc(), "Bogus document passed in"); // First, get a document (needed for security checks and the like) if (!aDocument) { aDocument = GetOurOwnerDoc(); if (!aDocument) { // No reason to bother, I think... return NS_OK; } } // URI equality check. // // We skip the equality check if our current image was blocked, since in that // case we really do want to try loading again. if (!aForce && NS_CP_ACCEPTED(mImageBlockingStatus)) { nsCOMPtr currentURI; GetCurrentURI(getter_AddRefs(currentURI)); bool equal; if (currentURI && NS_SUCCEEDED(currentURI->Equals(aNewURI, &equal)) && equal) { // Nothing to do here. return NS_OK; } } // From this point on, our image state could change. Watch it. AutoStateChanger changer(this, aNotify); // Sanity check. // // We use the principal of aDocument to avoid having to QI |this| an extra // time. It should always be the same as the principal of this node. #ifdef DEBUG nsCOMPtr thisContent = do_QueryInterface(static_cast(this)); MOZ_ASSERT(thisContent && thisContent->NodePrincipal() == aDocument->NodePrincipal(), "Principal mismatch?"); #endif // Are we blocked? int16_t cpDecision = nsIContentPolicy::REJECT_REQUEST; nsContentPolicyType policyType = PolicyTypeForLoad(aImageLoadType); nsContentUtils::CanLoadImage(aNewURI, static_cast(this), aDocument, aDocument->NodePrincipal(), &cpDecision, policyType); if (!NS_CP_ACCEPTED(cpDecision)) { FireEvent(NS_LITERAL_STRING("error")); FireEvent(NS_LITERAL_STRING("loadend")); SetBlockedRequest(aNewURI, cpDecision); return NS_OK; } nsLoadFlags loadFlags = aLoadFlags; int32_t corsmode = GetCORSMode(); if (corsmode == CORS_ANONYMOUS) { loadFlags |= imgILoader::LOAD_CORS_ANONYMOUS; } else if (corsmode == CORS_USE_CREDENTIALS) { loadFlags |= imgILoader::LOAD_CORS_USE_CREDENTIALS; } // get document wide referrer policy // if referrer attributes are enabled in preferences, load img referrer attribute // if the image does not provide a referrer attribute, ignore this net::ReferrerPolicy referrerPolicy = aDocument->GetReferrerPolicy(); net::ReferrerPolicy imgReferrerPolicy = GetImageReferrerPolicy(); if (imgReferrerPolicy != net::RP_Unset) { referrerPolicy = imgReferrerPolicy; } // Not blocked. Do the load. RefPtr& req = PrepareNextRequest(aImageLoadType); nsCOMPtr content = do_QueryInterface(static_cast(this)); nsCOMPtr thisNode = do_QueryInterface(static_cast(this)); nsresult rv = nsContentUtils::LoadImage(aNewURI, thisNode, aDocument, aDocument->NodePrincipal(), aDocument->GetDocumentURI(), referrerPolicy, this, loadFlags, content->LocalName(), getter_AddRefs(req), policyType); // Tell the document to forget about the image preload, if any, for // this URI, now that we might have another imgRequestProxy for it. // That way if we get canceled later the image load won't continue. aDocument->ForgetImagePreload(aNewURI); if (NS_SUCCEEDED(rv)) { TrackImage(req); ResetAnimationIfNeeded(); // Handle cases when we just ended up with a pending request but it's // already done. In that situation we have to synchronously switch that // request to being the current request, because websites depend on that // behavior. if (req == mPendingRequest) { uint32_t pendingLoadStatus; rv = req->GetImageStatus(&pendingLoadStatus); if (NS_SUCCEEDED(rv) && (pendingLoadStatus & imgIRequest::STATUS_LOAD_COMPLETE)) { MakePendingRequestCurrent(); MOZ_ASSERT(mCurrentRequest, "How could we not have a current request here?"); nsImageFrame *f = do_QueryFrame(GetOurPrimaryFrame()); if (f) { f->NotifyNewCurrentRequest(mCurrentRequest, NS_OK); } } } } else { MOZ_ASSERT(!req, "Shouldn't have non-null request here"); // If we don't have a current URI, we might as well store this URI so people // know what we tried (and failed) to load. if (!mCurrentRequest) mCurrentURI = aNewURI; FireEvent(NS_LITERAL_STRING("error")); FireEvent(NS_LITERAL_STRING("loadend")); return NS_OK; } return NS_OK; } nsresult nsImageLoadingContent::ForceImageState(bool aForce, EventStates::InternalType aState) { mIsImageStateForced = aForce; mForcedImageState = EventStates(aState); return NS_OK; } NS_IMETHODIMP nsImageLoadingContent::GetNaturalWidth(uint32_t* aNaturalWidth) { NS_ENSURE_ARG_POINTER(aNaturalWidth); nsCOMPtr image; if (mCurrentRequest) { mCurrentRequest->GetImage(getter_AddRefs(image)); } int32_t width; if (image && NS_SUCCEEDED(image->GetWidth(&width))) { *aNaturalWidth = width; } else { *aNaturalWidth = 0; } return NS_OK; } NS_IMETHODIMP nsImageLoadingContent::GetNaturalHeight(uint32_t* aNaturalHeight) { NS_ENSURE_ARG_POINTER(aNaturalHeight); nsCOMPtr image; if (mCurrentRequest) { mCurrentRequest->GetImage(getter_AddRefs(image)); } int32_t height; if (image && NS_SUCCEEDED(image->GetHeight(&height))) { *aNaturalHeight = height; } else { *aNaturalHeight = 0; } return NS_OK; } EventStates nsImageLoadingContent::ImageState() const { if (mIsImageStateForced) { return mForcedImageState; } EventStates states; if (mBroken) { states |= NS_EVENT_STATE_BROKEN; } if (mUserDisabled) { states |= NS_EVENT_STATE_USERDISABLED; } if (mSuppressed) { states |= NS_EVENT_STATE_SUPPRESSED; } if (mLoading) { states |= NS_EVENT_STATE_LOADING; } return states; } void nsImageLoadingContent::UpdateImageState(bool aNotify) { if (mStateChangerDepth > 0) { // Ignore this call; we'll update our state when the outermost state changer // is destroyed. Need this to work around the fact that some ImageLib // stuff is actually sync and hence we can get OnStopDecode called while // we're still under LoadImage, and OnStopDecode doesn't know anything about // aNotify. // XXX - This machinery should be removed after bug 521604. return; } nsCOMPtr thisContent = do_QueryInterface(static_cast(this)); if (!thisContent) { return; } mLoading = mBroken = mUserDisabled = mSuppressed = false; // If we were blocked by server-based content policy, we claim to be // suppressed. If we were blocked by type-based content policy, we claim to // be user-disabled. Otherwise, claim to be broken. if (mImageBlockingStatus == nsIContentPolicy::REJECT_SERVER) { mSuppressed = true; } else if (mImageBlockingStatus == nsIContentPolicy::REJECT_TYPE) { mUserDisabled = true; } else if (!mCurrentRequest) { // No current request means error, since we weren't disabled or suppressed mBroken = true; } else { uint32_t currentLoadStatus; nsresult rv = mCurrentRequest->GetImageStatus(¤tLoadStatus); if (NS_FAILED(rv) || (currentLoadStatus & imgIRequest::STATUS_ERROR)) { mBroken = true; } else if (!(currentLoadStatus & imgIRequest::STATUS_SIZE_AVAILABLE)) { mLoading = true; } } NS_ASSERTION(thisContent->IsElement(), "Not an element?"); thisContent->AsElement()->UpdateState(aNotify); } void nsImageLoadingContent::CancelImageRequests(bool aNotify) { AutoStateChanger changer(this, aNotify); ClearPendingRequest(NS_BINDING_ABORTED, Some(OnNonvisible::DISCARD_IMAGES)); ClearCurrentRequest(NS_BINDING_ABORTED, Some(OnNonvisible::DISCARD_IMAGES)); } nsresult nsImageLoadingContent::UseAsPrimaryRequest(imgRequestProxy* aRequest, bool aNotify, ImageLoadType aImageLoadType) { // Our state will change. Watch it. AutoStateChanger changer(this, aNotify); // Get rid if our existing images ClearPendingRequest(NS_BINDING_ABORTED, Some(OnNonvisible::DISCARD_IMAGES)); ClearCurrentRequest(NS_BINDING_ABORTED, Some(OnNonvisible::DISCARD_IMAGES)); // Clone the request we were given. RefPtr& req = PrepareNextRequest(aImageLoadType); nsresult rv = aRequest->Clone(this, getter_AddRefs(req)); if (NS_SUCCEEDED(rv)) { TrackImage(req); } else { MOZ_ASSERT(!req, "Shouldn't have non-null request here"); return rv; } return NS_OK; } nsIDocument* nsImageLoadingContent::GetOurOwnerDoc() { nsCOMPtr thisContent = do_QueryInterface(static_cast(this)); NS_ENSURE_TRUE(thisContent, nullptr); return thisContent->OwnerDoc(); } nsIDocument* nsImageLoadingContent::GetOurCurrentDoc() { nsCOMPtr thisContent = do_QueryInterface(static_cast(this)); NS_ENSURE_TRUE(thisContent, nullptr); return thisContent->GetComposedDoc(); } nsIFrame* nsImageLoadingContent::GetOurPrimaryFrame() { nsCOMPtr thisContent = do_QueryInterface(static_cast(this)); return thisContent->GetPrimaryFrame(); } nsPresContext* nsImageLoadingContent::GetFramePresContext() { nsIFrame* frame = GetOurPrimaryFrame(); if (!frame) { return nullptr; } return frame->PresContext(); } nsresult nsImageLoadingContent::StringToURI(const nsAString& aSpec, nsIDocument* aDocument, nsIURI** aURI) { NS_PRECONDITION(aDocument, "Must have a document"); NS_PRECONDITION(aURI, "Null out param"); // (1) Get the base URI nsCOMPtr thisContent = do_QueryInterface(static_cast(this)); NS_ASSERTION(thisContent, "An image loading content must be an nsIContent"); nsCOMPtr baseURL = thisContent->GetBaseURI(); // (2) Get the charset const nsAFlatCString &charset = aDocument->GetDocumentCharacterSet(); // (3) Construct the silly thing return NS_NewURI(aURI, aSpec, charset.IsEmpty() ? nullptr : charset.get(), baseURL, nsContentUtils::GetIOService()); } nsresult nsImageLoadingContent::FireEvent(const nsAString& aEventType, bool aIsCancelable) { if (nsContentUtils::DocumentInactiveForImageLoads(GetOurOwnerDoc())) { // Don't bother to fire any events, especially error events. return NS_OK; } // We have to fire the event asynchronously so that we won't go into infinite // loops in cases when onLoad handlers reset the src and the new src is in // cache. nsCOMPtr thisNode = do_QueryInterface(static_cast(this)); RefPtr loadBlockingAsyncDispatcher = new LoadBlockingAsyncEventDispatcher(thisNode, aEventType, false, false); loadBlockingAsyncDispatcher->PostDOMEvent(); if (aIsCancelable) { mPendingEvent = loadBlockingAsyncDispatcher; } return NS_OK; } void nsImageLoadingContent::AsyncEventRunning(AsyncEventDispatcher* aEvent) { if (mPendingEvent == aEvent) { mPendingEvent = nullptr; } } void nsImageLoadingContent::CancelPendingEvent() { if (mPendingEvent) { mPendingEvent->Cancel(); mPendingEvent = nullptr; } } RefPtr& nsImageLoadingContent::PrepareNextRequest(ImageLoadType aImageLoadType) { nsImageFrame* frame = do_QueryFrame(GetOurPrimaryFrame()); if (frame) { // Detect JavaScript-based animations created by changing the |src| // attribute on a timer. TimeStamp now = TimeStamp::Now(); TimeDuration threshold = TimeDuration::FromMilliseconds( gfxPrefs::ImageInferSrcAnimationThresholdMS()); // If the length of time between request changes is less than the threshold, // then force sync decoding to eliminate flicker from the animation. frame->SetForceSyncDecoding(now - mMostRecentRequestChange < threshold); mMostRecentRequestChange = now; } // If we don't have a usable current request, get rid of any half-baked // request that might be sitting there and make this one current. if (!HaveSize(mCurrentRequest)) return PrepareCurrentRequest(aImageLoadType); // Otherwise, make it pending. return PreparePendingRequest(aImageLoadType); } void nsImageLoadingContent::SetBlockedRequest(nsIURI* aURI, int16_t aContentDecision) { // Sanity MOZ_ASSERT(!NS_CP_ACCEPTED(aContentDecision), "Blocked but not?"); // We do some slightly illogical stuff here to maintain consistency with // old behavior that people probably depend on. Even in the case where the // new image is blocked, the old one should really be canceled with the // reason "image source changed". However, apparently there's some abuse // over in nsImageFrame where the displaying of the "broken" icon for the // next image depends on the cancel reason of the previous image. ugh. // XXX(seth): So shouldn't we fix nsImageFrame?! ClearPendingRequest(NS_ERROR_IMAGE_BLOCKED, Some(OnNonvisible::DISCARD_IMAGES)); // For the blocked case, we only want to cancel the existing current request // if size is not available. bz says the web depends on this behavior. if (!HaveSize(mCurrentRequest)) { mImageBlockingStatus = aContentDecision; uint32_t keepFlags = mCurrentRequestFlags & REQUEST_IS_IMAGESET; ClearCurrentRequest(NS_ERROR_IMAGE_BLOCKED, Some(OnNonvisible::DISCARD_IMAGES)); // We still want to remember what URI we were and if it was an imageset, // despite not having an actual request. These are both cleared as part of // ClearCurrentRequest() before a new request is started. mCurrentURI = aURI; mCurrentRequestFlags = keepFlags; } } RefPtr& nsImageLoadingContent::PrepareCurrentRequest(ImageLoadType aImageLoadType) { // Blocked images go through SetBlockedRequest, which is a separate path. For // everything else, we're unblocked. mImageBlockingStatus = nsIContentPolicy::ACCEPT; // Get rid of anything that was there previously. ClearCurrentRequest(NS_ERROR_IMAGE_SRC_CHANGED, Some(OnNonvisible::DISCARD_IMAGES)); if (mNewRequestsWillNeedAnimationReset) { mCurrentRequestFlags |= REQUEST_NEEDS_ANIMATION_RESET; } if (aImageLoadType == eImageLoadType_Imageset) { mCurrentRequestFlags |= REQUEST_IS_IMAGESET; } // Return a reference. return mCurrentRequest; } RefPtr& nsImageLoadingContent::PreparePendingRequest(ImageLoadType aImageLoadType) { // Get rid of anything that was there previously. ClearPendingRequest(NS_ERROR_IMAGE_SRC_CHANGED, Some(OnNonvisible::DISCARD_IMAGES)); if (mNewRequestsWillNeedAnimationReset) { mPendingRequestFlags |= REQUEST_NEEDS_ANIMATION_RESET; } if (aImageLoadType == eImageLoadType_Imageset) { mPendingRequestFlags |= REQUEST_IS_IMAGESET; } // Return a reference. return mPendingRequest; } namespace { class ImageRequestAutoLock { public: explicit ImageRequestAutoLock(imgIRequest* aRequest) : mRequest(aRequest) { if (mRequest) { mRequest->LockImage(); } } ~ImageRequestAutoLock() { if (mRequest) { mRequest->UnlockImage(); } } private: nsCOMPtr mRequest; }; } // namespace void nsImageLoadingContent::MakePendingRequestCurrent() { MOZ_ASSERT(mPendingRequest); // Lock mCurrentRequest for the duration of this method. We do this because // PrepareCurrentRequest() might unlock mCurrentRequest. If mCurrentRequest // and mPendingRequest are both requests for the same image, unlocking // mCurrentRequest before we lock mPendingRequest can cause the lock count // to go to 0 and the image to be discarded! ImageRequestAutoLock autoLock(mCurrentRequest); ImageLoadType loadType = \ (mPendingRequestFlags & REQUEST_IS_IMAGESET) ? eImageLoadType_Imageset : eImageLoadType_Normal; PrepareCurrentRequest(loadType) = mPendingRequest; mPendingRequest = nullptr; mCurrentRequestFlags = mPendingRequestFlags; mPendingRequestFlags = 0; ResetAnimationIfNeeded(); } void nsImageLoadingContent::ClearCurrentRequest(nsresult aReason, const Maybe& aNonvisibleAction) { if (!mCurrentRequest) { // Even if we didn't have a current request, we might have been keeping // a URI and flags as a placeholder for a failed load. Clear that now. mCurrentURI = nullptr; mCurrentRequestFlags = 0; return; } MOZ_ASSERT(!mCurrentURI, "Shouldn't have both mCurrentRequest and mCurrentURI!"); // Deregister this image from the refresh driver so it no longer receives // notifications. nsLayoutUtils::DeregisterImageRequest(GetFramePresContext(), mCurrentRequest, &mCurrentRequestRegistered); // Clean up the request. UntrackImage(mCurrentRequest, aNonvisibleAction); mCurrentRequest->CancelAndForgetObserver(aReason); mCurrentRequest = nullptr; mCurrentRequestFlags = 0; } void nsImageLoadingContent::ClearPendingRequest(nsresult aReason, const Maybe& aNonvisibleAction) { if (!mPendingRequest) return; // Deregister this image from the refresh driver so it no longer receives // notifications. nsLayoutUtils::DeregisterImageRequest(GetFramePresContext(), mPendingRequest, &mPendingRequestRegistered); UntrackImage(mPendingRequest, aNonvisibleAction); mPendingRequest->CancelAndForgetObserver(aReason); mPendingRequest = nullptr; mPendingRequestFlags = 0; } bool* nsImageLoadingContent::GetRegisteredFlagForRequest(imgIRequest* aRequest) { if (aRequest == mCurrentRequest) { return &mCurrentRequestRegistered; } else if (aRequest == mPendingRequest) { return &mPendingRequestRegistered; } else { return nullptr; } } void nsImageLoadingContent::ResetAnimationIfNeeded() { if (mCurrentRequest && (mCurrentRequestFlags & REQUEST_NEEDS_ANIMATION_RESET)) { nsCOMPtr container; mCurrentRequest->GetImage(getter_AddRefs(container)); if (container) container->ResetAnimation(); mCurrentRequestFlags &= ~REQUEST_NEEDS_ANIMATION_RESET; } } bool nsImageLoadingContent::HaveSize(imgIRequest *aImage) { // Handle the null case if (!aImage) return false; // Query the image uint32_t status; nsresult rv = aImage->GetImageStatus(&status); return (NS_SUCCEEDED(rv) && (status & imgIRequest::STATUS_SIZE_AVAILABLE)); } void nsImageLoadingContent::BindToTree(nsIDocument* aDocument, nsIContent* aParent, nsIContent* aBindingParent, bool aCompileEventHandlers) { // We may be entering the document, so if our image should be tracked, // track it. if (!aDocument) return; TrackImage(mCurrentRequest); TrackImage(mPendingRequest); if (mCurrentRequestFlags & REQUEST_BLOCKS_ONLOAD) aDocument->BlockOnload(); } void nsImageLoadingContent::UnbindFromTree(bool aDeep, bool aNullParent) { // We may be leaving the document, so if our image is tracked, untrack it. nsCOMPtr doc = GetOurCurrentDoc(); if (!doc) return; UntrackImage(mCurrentRequest); UntrackImage(mPendingRequest); if (mCurrentRequestFlags & REQUEST_BLOCKS_ONLOAD) doc->UnblockOnload(false); } void nsImageLoadingContent::OnVisibilityChange(Visibility aNewVisibility, const Maybe& aNonvisibleAction) { switch (aNewVisibility) { case Visibility::APPROXIMATELY_VISIBLE: TrackImage(mCurrentRequest); TrackImage(mPendingRequest); break; case Visibility::APPROXIMATELY_NONVISIBLE: UntrackImage(mCurrentRequest, aNonvisibleAction); UntrackImage(mPendingRequest, aNonvisibleAction); break; case Visibility::UNTRACKED: MOZ_ASSERT_UNREACHABLE("Shouldn't notify for untracked visibility"); break; } } void nsImageLoadingContent::TrackImage(imgIRequest* aImage) { if (!aImage) return; MOZ_ASSERT(aImage == mCurrentRequest || aImage == mPendingRequest, "Why haven't we heard of this request?"); nsIDocument* doc = GetOurCurrentDoc(); if (!doc) { return; } // We only want to track this request if we're visible. Ordinarily we check // the visible count, but that requires a frame; in cases where // GetOurPrimaryFrame() cannot obtain a frame (e.g. ), we assume // we're visible if FrameCreated() was called. nsIFrame* frame = GetOurPrimaryFrame(); if ((frame && frame->GetVisibility() == Visibility::APPROXIMATELY_NONVISIBLE) || (!frame && !mFrameCreateCalled)) { return; } if (aImage == mCurrentRequest && !(mCurrentRequestFlags & REQUEST_IS_TRACKED)) { mCurrentRequestFlags |= REQUEST_IS_TRACKED; doc->ImageTracker()->Add(mCurrentRequest); } if (aImage == mPendingRequest && !(mPendingRequestFlags & REQUEST_IS_TRACKED)) { mPendingRequestFlags |= REQUEST_IS_TRACKED; doc->ImageTracker()->Add(mPendingRequest); } } void nsImageLoadingContent::UntrackImage(imgIRequest* aImage, const Maybe& aNonvisibleAction /* = Nothing() */) { if (!aImage) return; MOZ_ASSERT(aImage == mCurrentRequest || aImage == mPendingRequest, "Why haven't we heard of this request?"); // We may not be in the document. If we outlived our document that's fine, // because the document empties out the tracker and unlocks all locked images // on destruction. But if we were never in the document we may need to force // discarding the image here, since this is the only chance we have. nsIDocument* doc = GetOurCurrentDoc(); if (aImage == mCurrentRequest) { if (doc && (mCurrentRequestFlags & REQUEST_IS_TRACKED)) { mCurrentRequestFlags &= ~REQUEST_IS_TRACKED; doc->ImageTracker()->Remove( mCurrentRequest, aNonvisibleAction == Some(OnNonvisible::DISCARD_IMAGES) ? ImageTracker::REQUEST_DISCARD : 0); } else if (aNonvisibleAction == Some(OnNonvisible::DISCARD_IMAGES)) { // If we're not in the document we may still need to be discarded. aImage->RequestDiscard(); } } if (aImage == mPendingRequest) { if (doc && (mPendingRequestFlags & REQUEST_IS_TRACKED)) { mPendingRequestFlags &= ~REQUEST_IS_TRACKED; doc->ImageTracker()->Remove( mPendingRequest, aNonvisibleAction == Some(OnNonvisible::DISCARD_IMAGES) ? ImageTracker::REQUEST_DISCARD : 0); } else if (aNonvisibleAction == Some(OnNonvisible::DISCARD_IMAGES)) { // If we're not in the document we may still need to be discarded. aImage->RequestDiscard(); } } } void nsImageLoadingContent::CreateStaticImageClone(nsImageLoadingContent* aDest) const { aDest->mCurrentRequest = nsContentUtils::GetStaticRequest(mCurrentRequest); aDest->TrackImage(aDest->mCurrentRequest); aDest->mForcedImageState = mForcedImageState; aDest->mImageBlockingStatus = mImageBlockingStatus; aDest->mLoadingEnabled = mLoadingEnabled; aDest->mStateChangerDepth = mStateChangerDepth; aDest->mIsImageStateForced = mIsImageStateForced; aDest->mLoading = mLoading; aDest->mBroken = mBroken; aDest->mUserDisabled = mUserDisabled; aDest->mSuppressed = mSuppressed; } CORSMode nsImageLoadingContent::GetCORSMode() { return CORS_NONE; } nsImageLoadingContent::ImageObserver::ImageObserver(imgINotificationObserver* aObserver) : mObserver(aObserver) , mNext(nullptr) { MOZ_COUNT_CTOR(ImageObserver); } nsImageLoadingContent::ImageObserver::~ImageObserver() { MOZ_COUNT_DTOR(ImageObserver); NS_CONTENT_DELETE_LIST_MEMBER(ImageObserver, this, mNext); } // Only HTMLInputElement.h overrides this for tags // all other subclasses use this one, i.e. ignore referrer attributes mozilla::net::ReferrerPolicy nsImageLoadingContent::GetImageReferrerPolicy() { return mozilla::net::RP_Unset; };