nsresult HTMLImageElement::BindToTree(nsIDocument* aDocument, nsIContent* aParent, nsIContent* aBindingParent, bool aCompileEventHandlers) { nsresult rv = nsGenericHTMLElement::BindToTree(aDocument, aParent, aBindingParent, aCompileEventHandlers); NS_ENSURE_SUCCESS(rv, rv); nsImageLoadingContent::BindToTree(aDocument, aParent, aBindingParent, aCompileEventHandlers); if (HasAttr(kNameSpaceID_None, nsGkAtoms::src)) { // FIXME: Bug 660963 it would be nice if we could just have // ClearBrokenState update our state and do it fast... ClearBrokenState(); RemoveStatesSilently(NS_EVENT_STATE_BROKEN); // If loading is temporarily disabled, don't even launch MaybeLoadImage. // Otherwise MaybeLoadImage may run later when someone has reenabled // loading. if (LoadingEnabled()) { nsContentUtils::AddScriptRunner( NS_NewRunnableMethod(this, &HTMLImageElement::MaybeLoadImage)); } } return rv; }
void nsSVGImageElement::MaybeLoadSVGImage() { if (HasAttr(kNameSpaceID_XLink, nsGkAtoms::href) && (NS_FAILED(LoadSVGImage(PR_FALSE, PR_TRUE)) || !LoadingEnabled())) { CancelImageRequests(PR_TRUE); } }
nsresult HTMLImageElement::BindToTree(nsIDocument* aDocument, nsIContent* aParent, nsIContent* aBindingParent, bool aCompileEventHandlers) { nsresult rv = nsGenericHTMLElement::BindToTree(aDocument, aParent, aBindingParent, aCompileEventHandlers); NS_ENSURE_SUCCESS(rv, rv); nsImageLoadingContent::BindToTree(aDocument, aParent, aBindingParent, aCompileEventHandlers); if (aParent) { UpdateFormOwner(); } if (HaveSrcsetOrInPicture()) { if (aDocument && !mInDocResponsiveContent) { aDocument->AddResponsiveContent(this); mInDocResponsiveContent = true; } bool forceLoadEvent = HTMLPictureElement::IsPictureEnabled() && aParent && aParent->IsHTMLElement(nsGkAtoms::picture); QueueImageLoadTask(forceLoadEvent); } else if (!InResponsiveMode() && HasAttr(kNameSpaceID_None, nsGkAtoms::src)) { // We skip loading when our attributes were set from parser land, // so trigger a aForce=false load now to check if things changed. // This isn't necessary for responsive mode, since creating the // image load task is asynchronous we don't need to take special // care to avoid doing so when being filled by the parser. // FIXME: Bug 660963 it would be nice if we could just have // ClearBrokenState update our state and do it fast... ClearBrokenState(); RemoveStatesSilently(NS_EVENT_STATE_BROKEN); // We still act synchronously for the non-responsive case (Bug // 1076583), but still need to delay if it is unsafe to run // script. // If loading is temporarily disabled, don't even launch MaybeLoadImage. // Otherwise MaybeLoadImage may run later when someone has reenabled // loading. if (LoadingEnabled()) { nsContentUtils::AddScriptRunner( NS_NewRunnableMethod(this, &HTMLImageElement::MaybeLoadImage)); } } return rv; }
void HTMLImageElement::MaybeLoadImage() { // Our base URI may have changed; claim that our URI changed, and the // nsImageLoadingContent will decide whether a new image load is warranted. // Note, check LoadingEnabled() after LoadImage call. nsAutoString uri; if (GetAttr(kNameSpaceID_None, nsGkAtoms::src, uri) && (NS_FAILED(LoadImage(uri, false, true)) || !LoadingEnabled())) { CancelImageRequests(true); } }
nsresult HTMLImageElement::BindToTree(nsIDocument* aDocument, nsIContent* aParent, nsIContent* aBindingParent, bool aCompileEventHandlers) { nsresult rv = nsGenericHTMLElement::BindToTree(aDocument, aParent, aBindingParent, aCompileEventHandlers); NS_ENSURE_SUCCESS(rv, rv); nsImageLoadingContent::BindToTree(aDocument, aParent, aBindingParent, aCompileEventHandlers); if (aParent) { UpdateFormOwner(); } bool haveSrcset = IsSrcsetEnabled() && HasAttr(kNameSpaceID_None, nsGkAtoms::srcset); if (haveSrcset || HasAttr(kNameSpaceID_None, nsGkAtoms::src)) { // FIXME: Bug 660963 it would be nice if we could just have // ClearBrokenState update our state and do it fast... ClearBrokenState(); RemoveStatesSilently(NS_EVENT_STATE_BROKEN); // We don't handle responsive changes when not bound to a tree, update them // now if necessary if (haveSrcset) { nsAutoString srcset; GetAttr(kNameSpaceID_None, nsGkAtoms::srcset, srcset); UpdateSourceSet(srcset); if (mResponsiveSelector) { nsAutoString src; GetAttr(kNameSpaceID_None, nsGkAtoms::src, src); mResponsiveSelector->SetDefaultSource(src); } } // If loading is temporarily disabled, don't even launch MaybeLoadImage. // Otherwise MaybeLoadImage may run later when someone has reenabled // loading. if (LoadingEnabled()) { nsContentUtils::AddScriptRunner( NS_NewRunnableMethod(this, &HTMLImageElement::MaybeLoadImage)); } } return rv; }
void HTMLImageElement::QueueImageLoadTask(bool aAlwaysLoad) { // If loading is temporarily disabled, we don't want to queue tasks // that may then run when loading is re-enabled. if (!LoadingEnabled() || !this->OwnerDoc()->IsCurrentActiveDocument()) { return; } nsCOMPtr<nsIRunnable> task = new ImageLoadTask(this, aAlwaysLoad); // The task checks this to determine if it was the last // queued event, and so earlier tasks are implicitly canceled. mPendingImageLoadTask = task; nsContentUtils::RunInStableState(task.forget()); }
void HTMLImageElement::MaybeLoadImage() { // Our base URI may have changed, or we may have had responsive parameters // change while not bound to the tree. Re-parse src/srcset and call LoadImage, // which is a no-op if it resolves to the same effective URI without aForce. // Note, check LoadingEnabled() after LoadImage call. LoadSelectedImage(false, true, false); if (!LoadingEnabled()) { CancelImageRequests(true); } }
void HTMLImageElement::QueueImageLoadTask() { // If loading is temporarily disabled, we don't want to queue tasks // that may then run when loading is re-enabled. if (!LoadingEnabled() || !this->OwnerDoc()->IsCurrentActiveDocument()) { return; } // The task checks this to determine if it was the last queued event, so this // implicitly cancels earlier tasks mPendingImageLoadTask = new ImageLoadTask(this); nsCOMPtr<nsIAppShell> appShell = do_GetService(kAppShellCID); if (appShell) { appShell->RunInStableState(mPendingImageLoadTask); } else { MOZ_ASSERT(false, "expect appshell for HTMLImageElement"); } }
void HTMLImageElement::QueueImageLoadTask(bool aAlwaysLoad) { // If loading is temporarily disabled, we don't want to queue tasks // that may then run when loading is re-enabled. if (!LoadingEnabled() || !this->OwnerDoc()->IsCurrentActiveDocument()) { return; } // Ensure that we don't overwrite a previous load request that requires // a complete load to occur. bool alwaysLoad = aAlwaysLoad; if (mPendingImageLoadTask) { alwaysLoad = alwaysLoad || mPendingImageLoadTask->AlwaysLoad(); } RefPtr<ImageLoadTask> task = new ImageLoadTask(this, alwaysLoad); // The task checks this to determine if it was the last // queued event, and so earlier tasks are implicitly canceled. mPendingImageLoadTask = task; nsContentUtils::RunInStableState(task.forget()); }