summaryrefslogtreecommitdiffstats
path: root/dom/base/nsImageLoadingContent.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /dom/base/nsImageLoadingContent.h
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/base/nsImageLoadingContent.h')
-rw-r--r--dom/base/nsImageLoadingContent.h611
1 files changed, 611 insertions, 0 deletions
diff --git a/dom/base/nsImageLoadingContent.h b/dom/base/nsImageLoadingContent.h
new file mode 100644
index 0000000000..6929f20a23
--- /dev/null
+++ b/dom/base/nsImageLoadingContent.h
@@ -0,0 +1,611 @@
+/* -*- 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 <img>, <object>, etc).
+ */
+
+#ifndef nsImageLoadingContent_h__
+#define nsImageLoadingContent_h__
+
+#include "imgINotificationObserver.h"
+#include "mozilla/CORSMode.h"
+#include "mozilla/TimeStamp.h"
+#include "nsCOMPtr.h"
+#include "nsIContentPolicy.h"
+#include "nsIImageLoadingContent.h"
+#include "nsIRequest.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/RustTypes.h"
+#include "nsAttrValue.h"
+#include "Units.h"
+
+class nsINode;
+class nsIURI;
+class nsPresContext;
+class nsIContent;
+class imgRequestProxy;
+
+namespace mozilla {
+class AsyncEventDispatcher;
+class ErrorResult;
+
+namespace dom {
+struct BindContext;
+class Document;
+class Element;
+} // namespace dom
+} // namespace mozilla
+
+#ifdef LoadImage
+// Undefine LoadImage to prevent naming conflict with Windows.
+# undef LoadImage
+#endif
+
+class nsImageLoadingContent : public nsIImageLoadingContent {
+ protected:
+ template <typename T>
+ using Maybe = mozilla::Maybe<T>;
+ using Nothing = mozilla::Nothing;
+ using OnNonvisible = mozilla::OnNonvisible;
+ using Visibility = mozilla::Visibility;
+
+ /* METHODS */
+ public:
+ nsImageLoadingContent();
+ virtual ~nsImageLoadingContent();
+
+ NS_DECL_IMGINOTIFICATIONOBSERVER
+ NS_DECL_NSIIMAGELOADINGCONTENT
+
+ // Web IDL binding methods.
+ // Note that the XPCOM SetLoadingEnabled method is OK for Web IDL bindings
+ // to use as well, since it does not throw when called via the Web IDL
+ // bindings.
+
+ bool LoadingEnabled() const { return mLoadingEnabled; }
+ void AddObserver(imgINotificationObserver* aObserver);
+ void RemoveObserver(imgINotificationObserver* aObserver);
+ already_AddRefed<imgIRequest> GetRequest(int32_t aRequestType,
+ mozilla::ErrorResult& aError);
+ int32_t GetRequestType(imgIRequest* aRequest, mozilla::ErrorResult& aError);
+ already_AddRefed<nsIURI> GetCurrentURI();
+ already_AddRefed<nsIURI> GetCurrentRequestFinalURI();
+ void ForceReload(bool aNotify, mozilla::ErrorResult& aError);
+
+ mozilla::dom::Element* FindImageMap();
+ static mozilla::dom::Element* FindImageMap(mozilla::dom::Element*);
+
+ /**
+ * Toggle whether or not to synchronously decode an image on draw.
+ */
+ void SetSyncDecodingHint(bool aHint);
+
+ /**
+ * Notify us that the document state has changed. Called by nsDocument so that
+ * we may reject any promises which require the document to be active.
+ */
+ void NotifyOwnerDocumentActivityChanged();
+
+ // Trigger text recognition for the current image request.
+ already_AddRefed<mozilla::dom::Promise> RecognizeCurrentImageText(
+ mozilla::ErrorResult&);
+
+ protected:
+ enum ImageLoadType {
+ // Most normal image loads
+ eImageLoadType_Normal,
+ // From a <img srcset> or <picture> context. Affects type given to content
+ // policy.
+ eImageLoadType_Imageset
+ };
+
+ /**
+ * LoadImage is called by subclasses when the appropriate
+ * attributes (eg 'src' for <img> tags) change. The string passed
+ * in is the new uri string; this consolidates the code for getting
+ * the charset, constructing URI objects, and any other incidentals
+ * into this superclass.
+ *
+ * @param aNewURI the URI spec to be loaded (may be a relative URI)
+ * @param aForce If true, make sure to load the URI. If false, only
+ * load if the URI is different from the currently loaded URI.
+ * @param aNotify If true, nsIDocumentObserver state change notifications
+ * will be sent as needed.
+ * @param aImageLoadType The ImageLoadType for this request
+ * @param aTriggeringPrincipal Optional parameter specifying the triggering
+ * principal to use for the image load
+ */
+ nsresult LoadImage(const nsAString& aNewURI, bool aForce, bool aNotify,
+ ImageLoadType aImageLoadType,
+ nsIPrincipal* aTriggeringPrincipal = nullptr);
+
+ /**
+ * ImageState is called by subclasses that are computing their content state.
+ * The return value will have the ElementState::BROKEN bit set as needed.
+ *
+ * Note that this state assumes that this node is "trying" to be an
+ * image (so for example complete lack of attempt to load an image will lead
+ * to ElementState::BROKEN being set). Subclasses that are not "trying" to
+ * be an image (eg an HTML <input> of type other than "image") should just
+ * not call this method when computing their intrinsic state.
+ */
+ mozilla::dom::ElementState ImageState() const;
+
+ /**
+ * LoadImage is called by subclasses when the appropriate
+ * attributes (eg 'src' for <img> tags) change. If callers have an
+ * URI object already available, they should use this method.
+ *
+ * @param aNewURI the URI to be loaded
+ * @param aForce If true, make sure to load the URI. If false, only
+ * load if the URI is different from the currently loaded URI.
+ * @param aNotify If true, nsIDocumentObserver state change notifications
+ * will be sent as needed.
+ * @param aImageLoadType The ImageLoadType for this request
+ * @param aDocument Optional parameter giving the document this node is in.
+ * This is purely a performance optimization.
+ * @param aLoadFlags Optional parameter specifying load flags to use for
+ * the image load
+ * @param aTriggeringPrincipal Optional parameter specifying the triggering
+ * principal to use for the image load
+ */
+ nsresult LoadImage(nsIURI* aNewURI, bool aForce, bool aNotify,
+ ImageLoadType aImageLoadType, nsLoadFlags aLoadFlags,
+ mozilla::dom::Document* aDocument = nullptr,
+ nsIPrincipal* aTriggeringPrincipal = nullptr);
+
+ nsresult LoadImage(nsIURI* aNewURI, bool aForce, bool aNotify,
+ ImageLoadType aImageLoadType,
+ nsIPrincipal* aTriggeringPrincipal) {
+ return LoadImage(aNewURI, aForce, aNotify, aImageLoadType, LoadFlags(),
+ nullptr, aTriggeringPrincipal);
+ }
+
+ /**
+ * helpers to get the document for this content (from the nodeinfo
+ * and such). Not named GetOwnerDoc/GetCurrentDoc to prevent ambiguous
+ * method names in subclasses
+ *
+ * @return the document we belong to
+ */
+ mozilla::dom::Document* GetOurOwnerDoc();
+ mozilla::dom::Document* GetOurCurrentDoc();
+
+ /**
+ * Helper function to get the frame associated with this content. Not named
+ * GetPrimaryFrame to prevent ambiguous method names in subclasses.
+ *
+ * @return The frame we own, or nullptr if it doesn't exist, or isn't
+ * associated with any of our requests.
+ */
+ nsIFrame* GetOurPrimaryImageFrame();
+
+ /**
+ * Helper function to get the PresContext associated with this content's
+ * frame. Not named GetPresContext to prevent ambiguous method names in
+ * subclasses.
+ *
+ * @return The nsPresContext associated with our frame, or nullptr if either
+ * the frame doesn't exist, or the frame's prescontext doesn't exist.
+ */
+ nsPresContext* GetFramePresContext();
+
+ /**
+ * CancelImageRequests is called by subclasses when they want to
+ * cancel all image requests (for example when the subclass is
+ * somehow not an image anymore).
+ */
+ void CancelImageRequests(bool aNotify);
+
+ /**
+ * Derived classes of nsImageLoadingContent MUST call Destroy from their
+ * destructor, or earlier. It does things that cannot be done in
+ * ~nsImageLoadingContent because they rely on being able to QueryInterface to
+ * other derived classes, which cannot happen once the derived class
+ * destructor has started calling the base class destructors.
+ */
+ void Destroy();
+
+ /**
+ * Returns the CORS mode that will be used for all future image loads. The
+ * default implementation returns CORS_NONE unconditionally.
+ */
+ virtual mozilla::CORSMode GetCORSMode();
+
+ // Subclasses are *required* to call BindToTree/UnbindFromTree.
+ void BindToTree(mozilla::dom::BindContext&, nsINode& aParent);
+ void UnbindFromTree(bool aNullParent);
+
+ void OnLoadComplete(imgIRequest* aRequest, nsresult aStatus);
+ void OnUnlockedDraw();
+ void OnImageIsAnimated(imgIRequest* aRequest);
+
+ // The nsContentPolicyType we would use for this ImageLoadType
+ static nsContentPolicyType PolicyTypeForLoad(ImageLoadType aImageLoadType);
+
+ void AsyncEventRunning(mozilla::AsyncEventDispatcher* aEvent);
+
+ // Get ourselves as an nsIContent*. Not const because some of the callers
+ // want a non-const nsIContent.
+ virtual nsIContent* AsContent() = 0;
+
+ /**
+ * Get width and height of the current request, using given image request if
+ * attributes are unset.
+ */
+ MOZ_CAN_RUN_SCRIPT mozilla::CSSIntSize GetWidthHeightForImage();
+
+ /**
+ * Create a promise and queue a microtask which will ensure the current
+ * request (after any pending loads are applied) has requested a full decode.
+ * The promise is fulfilled once the request has a fully decoded surface that
+ * is available for drawing, or an error condition occurrs (e.g. broken image,
+ * current request is updated, etc).
+ *
+ * https://html.spec.whatwg.org/multipage/embedded-content.html#dom-img-decode
+ */
+ already_AddRefed<mozilla::dom::Promise> QueueDecodeAsync(
+ mozilla::ErrorResult& aRv);
+
+ enum class ImageDecodingType : uint8_t {
+ Auto,
+ Async,
+ Sync,
+ };
+
+ static const nsAttrValue::EnumTable kDecodingTable[];
+ static const nsAttrValue::EnumTable* kDecodingTableDefault;
+
+ private:
+ /**
+ * Enqueue and/or fulfill a promise created by QueueDecodeAsync.
+ */
+ void DecodeAsync(RefPtr<mozilla::dom::Promise>&& aPromise,
+ uint32_t aRequestGeneration);
+
+ /**
+ * Attempt to resolve all queued promises based on the state of the current
+ * request. If the current request does not yet have all of the encoded data,
+ * or the decoding has not yet completed, it will return without changing the
+ * promise states.
+ */
+ void MaybeResolveDecodePromises();
+
+ /**
+ * Reject all queued promises with the given status.
+ */
+ void RejectDecodePromises(nsresult aStatus);
+
+ /**
+ * Age the generation counter if we have a new current request with a
+ * different URI. If the generation counter is aged, then all queued promises
+ * will also be rejected.
+ */
+ void MaybeAgeRequestGeneration(nsIURI* aNewURI);
+
+ /**
+ * Deregister as an observer for the owner document's activity notifications
+ * if we have no outstanding decode promises.
+ */
+ void MaybeDeregisterActivityObserver();
+
+ /**
+ * Struct used to manage the native image observers.
+ */
+ struct ImageObserver {
+ explicit ImageObserver(imgINotificationObserver* aObserver);
+ ~ImageObserver();
+
+ nsCOMPtr<imgINotificationObserver> mObserver;
+ ImageObserver* mNext;
+ };
+
+ /**
+ * Struct used to manage the scripted/XPCOM image observers.
+ */
+ class ScriptedImageObserver final {
+ public:
+ NS_INLINE_DECL_REFCOUNTING(ScriptedImageObserver)
+
+ ScriptedImageObserver(imgINotificationObserver* aObserver,
+ RefPtr<imgRequestProxy>&& aCurrentRequest,
+ RefPtr<imgRequestProxy>&& aPendingRequest);
+ bool CancelRequests();
+
+ nsCOMPtr<imgINotificationObserver> mObserver;
+ RefPtr<imgRequestProxy> mCurrentRequest;
+ RefPtr<imgRequestProxy> mPendingRequest;
+
+ private:
+ ~ScriptedImageObserver();
+ };
+
+ /**
+ * Struct to report state changes
+ */
+ struct AutoStateChanger {
+ AutoStateChanger(nsImageLoadingContent* aImageContent, bool aNotify)
+ : mImageContent(aImageContent), mNotify(aNotify) {
+ mImageContent->mStateChangerDepth++;
+ }
+ ~AutoStateChanger() {
+ mImageContent->mStateChangerDepth--;
+ mImageContent->UpdateImageState(mNotify);
+ }
+
+ nsImageLoadingContent* mImageContent;
+ bool mNotify;
+ };
+
+ friend struct AutoStateChanger;
+
+ /**
+ * Method to fire an event once we know what's going on with the image load.
+ *
+ * @param aEventType "load", or "error" depending on how things went
+ * @param aIsCancelable true if event is cancelable.
+ */
+ nsresult FireEvent(const nsAString& aEventType, bool aIsCancelable = false);
+
+ /**
+ * Method to cancel and null-out pending event if they exist.
+ */
+ void CancelPendingEvent();
+
+ RefPtr<mozilla::AsyncEventDispatcher> mPendingEvent;
+
+ protected:
+ /**
+ * UpdateImageState recomputes the current state of this image loading
+ * content and updates what ImageState() returns accordingly. It will also
+ * fire a ContentStatesChanged() notification as needed if aNotify is true.
+ */
+ void UpdateImageState(bool aNotify);
+
+ /**
+ * Method to create an nsIURI object from the given string (will
+ * handle getting the right charset, base, etc). You MUST pass in a
+ * non-null document to this function.
+ *
+ * @param aSpec the string spec (from an HTML attribute, eg)
+ * @param aDocument the document we belong to
+ * @return the URI we want to be loading
+ */
+ nsresult StringToURI(const nsAString& aSpec,
+ mozilla::dom::Document* aDocument, nsIURI** aURI);
+
+ /**
+ * Prepare and returns a reference to the "next request". If there's already
+ * a _usable_ current request (one with SIZE_AVAILABLE), this request is
+ * "pending" until it becomes usable. Otherwise, this becomes the current
+ * request.
+ *
+ * @param aImageLoadType The ImageLoadType for this request
+ */
+ RefPtr<imgRequestProxy>& PrepareNextRequest(ImageLoadType aImageLoadType);
+
+ /**
+ * Returns a COMPtr reference to the current/pending image requests, cleaning
+ * up and canceling anything that was there before. Note that if you just want
+ * to get rid of one of the requests, you should call
+ * Clear*Request(NS_BINDING_ABORTED) instead.
+ *
+ * @param aImageLoadType The ImageLoadType for this request
+ */
+ RefPtr<imgRequestProxy>& PrepareCurrentRequest(ImageLoadType aImageLoadType);
+ RefPtr<imgRequestProxy>& PreparePendingRequest(ImageLoadType aImageLoadType);
+
+ /**
+ * Switch our pending request to be our current request.
+ * mPendingRequest must be non-null!
+ */
+ void MakePendingRequestCurrent();
+
+ /**
+ * Cancels and nulls-out the "current" and "pending" requests if they exist.
+ *
+ * @param aNonvisibleAction An action to take if the image is no longer
+ * visible as a result; see |UntrackImage|.
+ */
+ void ClearCurrentRequest(
+ nsresult aReason,
+ const Maybe<OnNonvisible>& aNonvisibleAction = Nothing());
+ void ClearPendingRequest(
+ nsresult aReason,
+ const Maybe<OnNonvisible>& aNonvisibleAction = Nothing());
+
+ /**
+ * Reset animation of the current request if
+ * |mNewRequestsWillNeedAnimationReset| was true when the request was
+ * prepared.
+ */
+ void ResetAnimationIfNeeded();
+
+ /**
+ * Static helper method to tell us if we have the size of a request. The
+ * image may be null.
+ */
+ static bool HaveSize(imgIRequest* aImage);
+
+ /**
+ * Adds/Removes a given imgIRequest from our document's tracker.
+ *
+ * No-op if aImage is null.
+ *
+ * @param aFrame If called from FrameCreated the frame passed to FrameCreated.
+ * This is our frame, but at the time of the FrameCreated call
+ * our primary frame pointer hasn't been set yet, so this is
+ * only way to get our frame.
+ *
+ * @param aNonvisibleAction A requested action if the frame has become
+ * nonvisible. If Nothing(), no action is
+ * requested. If DISCARD_IMAGES is specified, the
+ * frame is requested to ask any images it's
+ * associated with to discard their surfaces if
+ * possible.
+ */
+ void TrackImage(imgIRequest* aImage, nsIFrame* aFrame = nullptr);
+ void UntrackImage(imgIRequest* aImage,
+ const Maybe<OnNonvisible>& aNonvisibleAction = Nothing());
+
+ nsLoadFlags LoadFlags();
+
+ /* MEMBERS */
+ RefPtr<imgRequestProxy> mCurrentRequest;
+ RefPtr<imgRequestProxy> mPendingRequest;
+ uint8_t mCurrentRequestFlags = 0;
+ uint8_t mPendingRequestFlags = 0;
+
+ enum {
+ // Set if the request needs ResetAnimation called on it.
+ REQUEST_NEEDS_ANIMATION_RESET = 1 << 0,
+ // Set if the request is currently tracked with the document.
+ REQUEST_IS_TRACKED = 1 << 1,
+ // Set if this is an imageset request, such as from <img srcset> or
+ // <picture>
+ REQUEST_IS_IMAGESET = 1 << 2,
+ };
+
+ // If the image was blocked or if there was an error loading, it's nice to
+ // still keep track of what the URI was despite not having an imgIRequest.
+ // We only maintain this in those situations (in the common case, this is
+ // always null).
+ nsCOMPtr<nsIURI> mCurrentURI;
+
+ private:
+ /**
+ * Clones the given "current" or "pending" request for each scripted observer.
+ */
+ void CloneScriptedRequests(imgRequestProxy* aRequest);
+
+ /**
+ * Cancels and nulls-out the "current" or "pending" requests if they exist
+ * for each scripted observer.
+ */
+ void ClearScriptedRequests(int32_t aRequestType, nsresult aReason);
+
+ /**
+ * Moves the "pending" request into the "current" request for each scripted
+ * observer. If there is an existing "current" request, it will cancel it
+ * first.
+ */
+ void MakePendingScriptedRequestsCurrent();
+
+ /**
+ * Depending on the configured decoding hint, and/or how recently we updated
+ * the image request, force or stop the frame from decoding the image
+ * synchronously when it is drawn.
+ * @param aPrepareNextRequest True if this is when updating the image request.
+ * @param aFrame If called from FrameCreated the frame passed to FrameCreated.
+ * This is our frame, but at the time of the FrameCreated call
+ * our primary frame pointer hasn't been set yet, so this is
+ * only way to get our frame.
+ */
+ void MaybeForceSyncDecoding(bool aPrepareNextRequest,
+ nsIFrame* aFrame = nullptr);
+
+ /**
+ * Typically we will have only one observer (our frame in the screen
+ * prescontext), so we want to only make space for one and to
+ * heap-allocate anything past that (saves memory and malloc churn
+ * in the common case). The storage is a linked list, we just
+ * happen to actually hold the first observer instead of a pointer
+ * to it.
+ */
+ ImageObserver mObserverList;
+
+ /**
+ * Typically we will have no scripted observers, as this is only used by
+ * chrome, legacy extensions, and some mochitests. An empty array reserves
+ * minimal memory.
+ */
+ nsTArray<RefPtr<ScriptedImageObserver>> mScriptedObservers;
+
+ /**
+ * Promises created by QueueDecodeAsync that are still waiting to be
+ * fulfilled by the image being fully decoded.
+ */
+ nsTArray<RefPtr<mozilla::dom::Promise>> mDecodePromises;
+
+ mozilla::TimeStamp mMostRecentRequestChange;
+
+ /**
+ * Total number of outstanding decode promises, including those stored in
+ * mDecodePromises and those embedded in runnables waiting to be enqueued.
+ * This is used to determine whether we need to register as an observer for
+ * document activity notifications.
+ */
+ size_t mOutstandingDecodePromises;
+
+ /**
+ * An incrementing counter representing the current request generation;
+ * Each time mCurrentRequest is modified with a different URI, this will
+ * be incremented. Each QueueDecodeAsync call will cache the generation
+ * of the current request so that when it is processed, it knows if it
+ * should have rejected because the request changed.
+ */
+ uint32_t mRequestGeneration;
+
+ bool mLoadingEnabled : 1;
+
+ protected:
+ /**
+ * The state we had the last time we checked whether we needed to notify the
+ * document of a state change. These are maintained by UpdateImageState.
+ */
+ bool mLoading : 1;
+
+ /**
+ * A hack to get animations to reset, see bug 594771. On requests
+ * that originate from setting .src, we mark them for needing their animation
+ * reset when they are ready. mNewRequestsWillNeedAnimationReset is set to
+ * true while preparing such requests (as a hack around needing to change an
+ * interface), and the other two booleans store which of the current
+ * and pending requests are of the sort that need their animation restarted.
+ */
+ bool mNewRequestsWillNeedAnimationReset : 1;
+
+ /**
+ * Flag to indicate whether the channel should be mark as urgent-start.
+ * It should be set in *Element and passed to nsContentUtils::LoadImage.
+ * True if we want to set nsIClassOfService::UrgentStart to the channel to
+ * get the response ASAP for better user responsiveness.
+ */
+ bool mUseUrgentStartForChannel : 1;
+
+ // Represents the image is deferred loading until this element gets visible.
+ bool mLazyLoading : 1;
+
+ private:
+ /* The number of nested AutoStateChangers currently tracking our state. */
+ uint8_t mStateChangerDepth;
+
+ // Flags to indicate whether each of the current and pending requests are
+ // registered with the refresh driver.
+ bool mCurrentRequestRegistered;
+ bool mPendingRequestRegistered;
+
+ // TODO:
+ // Bug 1353685: Should ServiceWorker call SetBlockedRequest?
+ //
+ // This member is used in SetBlockedRequest, if it's true, then this call is
+ // triggered from LoadImage.
+ // If this is false, it means this call is from other places like
+ // ServiceWorker, then we will ignore call to SetBlockedRequest for now.
+ //
+ // Also we use this variable to check if some evil code is reentering
+ // LoadImage.
+ bool mIsStartingImageLoad;
+
+ // If true, force frames to synchronously decode images on draw.
+ bool mSyncDecodingHint;
+};
+
+#endif // nsImageLoadingContent_h__