summaryrefslogtreecommitdiffstats
path: root/dom/html/ImageDocument.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/html/ImageDocument.cpp')
-rw-r--r--dom/html/ImageDocument.cpp795
1 files changed, 795 insertions, 0 deletions
diff --git a/dom/html/ImageDocument.cpp b/dom/html/ImageDocument.cpp
new file mode 100644
index 0000000000..2e037284a6
--- /dev/null
+++ b/dom/html/ImageDocument.cpp
@@ -0,0 +1,795 @@
+/* -*- 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/. */
+
+#include "ImageDocument.h"
+#include "mozilla/AutoRestore.h"
+#include "mozilla/ComputedStyle.h"
+#include "mozilla/dom/BrowserChild.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/ImageDocumentBinding.h"
+#include "mozilla/dom/HTMLImageElement.h"
+#include "mozilla/dom/MouseEvent.h"
+#include "mozilla/LoadInfo.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/StaticPrefs_browser.h"
+#include "nsICSSDeclaration.h"
+#include "nsObjectLoadingContent.h"
+#include "nsRect.h"
+#include "nsIImageLoadingContent.h"
+#include "nsGenericHTMLElement.h"
+#include "nsDocShell.h"
+#include "DocumentInlines.h"
+#include "ImageBlocker.h"
+#include "nsDOMTokenList.h"
+#include "nsIDOMEventListener.h"
+#include "nsIFrame.h"
+#include "nsGkAtoms.h"
+#include "imgIRequest.h"
+#include "imgIContainer.h"
+#include "imgINotificationObserver.h"
+#include "nsPresContext.h"
+#include "nsIChannel.h"
+#include "nsIContentPolicy.h"
+#include "nsContentPolicyUtils.h"
+#include "nsPIDOMWindow.h"
+#include "nsError.h"
+#include "nsURILoader.h"
+#include "nsIDocShell.h"
+#include "nsIDocumentViewer.h"
+#include "nsThreadUtils.h"
+#include "nsIScrollableFrame.h"
+#include "nsContentUtils.h"
+#include "mozilla/Preferences.h"
+#include <algorithm>
+
+namespace mozilla::dom {
+
+class ImageListener : public MediaDocumentStreamListener {
+ public:
+ // NS_DECL_NSIREQUESTOBSERVER
+ // We only implement OnStartRequest; OnStopRequest is
+ // implemented by MediaDocumentStreamListener
+ NS_IMETHOD OnStartRequest(nsIRequest* aRequest) override;
+
+ explicit ImageListener(ImageDocument* aDocument);
+ virtual ~ImageListener();
+};
+
+ImageListener::ImageListener(ImageDocument* aDocument)
+ : MediaDocumentStreamListener(aDocument) {}
+
+ImageListener::~ImageListener() = default;
+
+NS_IMETHODIMP
+ImageListener::OnStartRequest(nsIRequest* request) {
+ NS_ENSURE_TRUE(mDocument, NS_ERROR_FAILURE);
+
+ ImageDocument* imgDoc = static_cast<ImageDocument*>(mDocument.get());
+ nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
+ if (!channel) {
+ return NS_ERROR_FAILURE;
+ }
+
+ nsCOMPtr<nsPIDOMWindowOuter> domWindow = imgDoc->GetWindow();
+ NS_ENSURE_TRUE(domWindow, NS_ERROR_UNEXPECTED);
+
+ // This is an image being loaded as a document, so it's not going to be
+ // detected by the ImageBlocker. However we don't want to call
+ // NS_CheckContentLoadPolicy (with an TYPE_INTERNAL_IMAGE) here, as it would
+ // e.g. make this image load be detectable by CSP.
+ nsCOMPtr<nsIURI> channelURI;
+ channel->GetURI(getter_AddRefs(channelURI));
+ if (image::ImageBlocker::ShouldBlock(channelURI)) {
+ request->Cancel(NS_ERROR_CONTENT_BLOCKED);
+ return NS_OK;
+ }
+
+ if (!imgDoc->mObservingImageLoader) {
+ NS_ENSURE_TRUE(imgDoc->mImageContent, NS_ERROR_UNEXPECTED);
+ imgDoc->mImageContent->AddNativeObserver(imgDoc);
+ imgDoc->mObservingImageLoader = true;
+ imgDoc->mImageContent->LoadImageWithChannel(channel,
+ getter_AddRefs(mNextStream));
+ }
+
+ return MediaDocumentStreamListener::OnStartRequest(request);
+}
+
+ImageDocument::ImageDocument()
+ : mVisibleWidth(0.0),
+ mVisibleHeight(0.0),
+ mImageWidth(0),
+ mImageHeight(0),
+ mImageIsResized(false),
+ mShouldResize(false),
+ mFirstResize(false),
+ mObservingImageLoader(false),
+ mTitleUpdateInProgress(false),
+ mHasCustomTitle(false),
+ mIsInObjectOrEmbed(false),
+ mOriginalZoomLevel(1.0),
+ mOriginalResolution(1.0) {}
+
+ImageDocument::~ImageDocument() = default;
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(ImageDocument, MediaDocument, mImageContent)
+
+NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED(ImageDocument, MediaDocument,
+ imgINotificationObserver,
+ nsIDOMEventListener)
+
+nsresult ImageDocument::Init(nsIPrincipal* aPrincipal,
+ nsIPrincipal* aPartitionedPrincipal) {
+ nsresult rv = MediaDocument::Init(aPrincipal, aPartitionedPrincipal);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ mShouldResize = StaticPrefs::browser_enable_automatic_image_resizing();
+ mFirstResize = true;
+
+ return NS_OK;
+}
+
+JSObject* ImageDocument::WrapNode(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return ImageDocument_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+nsresult ImageDocument::StartDocumentLoad(
+ const char* aCommand, nsIChannel* aChannel, nsILoadGroup* aLoadGroup,
+ nsISupports* aContainer, nsIStreamListener** aDocListener, bool aReset) {
+ nsresult rv = MediaDocument::StartDocumentLoad(
+ aCommand, aChannel, aLoadGroup, aContainer, aDocListener, aReset);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ mOriginalZoomLevel = IsSiteSpecific() ? 1.0 : GetZoomLevel();
+ CheckFullZoom();
+ mOriginalResolution = GetResolution();
+
+ if (BrowsingContext* context = GetBrowsingContext()) {
+ mIsInObjectOrEmbed = context->IsEmbedderTypeObjectOrEmbed();
+ }
+
+ NS_ASSERTION(aDocListener, "null aDocListener");
+ *aDocListener = new ImageListener(this);
+ NS_ADDREF(*aDocListener);
+
+ return NS_OK;
+}
+
+void ImageDocument::Destroy() {
+ if (RefPtr<HTMLImageElement> img = std::move(mImageContent)) {
+ // Remove our event listener from the image content.
+ img->RemoveEventListener(u"load"_ns, this, false);
+ img->RemoveEventListener(u"click"_ns, this, false);
+
+ // Break reference cycle with mImageContent, if we have one
+ if (mObservingImageLoader) {
+ img->RemoveNativeObserver(this);
+ }
+ }
+
+ MediaDocument::Destroy();
+}
+
+void ImageDocument::SetScriptGlobalObject(
+ nsIScriptGlobalObject* aScriptGlobalObject) {
+ // If the script global object is changing, we need to unhook our event
+ // listeners on the window.
+ nsCOMPtr<EventTarget> target;
+ if (mScriptGlobalObject && aScriptGlobalObject != mScriptGlobalObject) {
+ target = do_QueryInterface(mScriptGlobalObject);
+ target->RemoveEventListener(u"resize"_ns, this, false);
+ target->RemoveEventListener(u"keypress"_ns, this, false);
+ }
+
+ // Set the script global object on the superclass before doing
+ // anything that might require it....
+ MediaDocument::SetScriptGlobalObject(aScriptGlobalObject);
+
+ if (aScriptGlobalObject) {
+ if (!InitialSetupHasBeenDone()) {
+ MOZ_ASSERT(!GetRootElement(), "Where did the root element come from?");
+ // Create synthetic document
+#ifdef DEBUG
+ nsresult rv =
+#endif
+ CreateSyntheticDocument();
+ NS_ASSERTION(NS_SUCCEEDED(rv), "failed to create synthetic document");
+
+ target = mImageContent;
+ target->AddEventListener(u"load"_ns, this, false);
+ target->AddEventListener(u"click"_ns, this, false);
+ }
+
+ target = do_QueryInterface(aScriptGlobalObject);
+ target->AddEventListener(u"resize"_ns, this, false);
+ target->AddEventListener(u"keypress"_ns, this, false);
+
+ if (!InitialSetupHasBeenDone()) {
+ LinkStylesheet(u"resource://content-accessible/ImageDocument.css"_ns);
+ if (!nsContentUtils::IsChildOfSameType(this)) {
+ LinkStylesheet(nsLiteralString(
+ u"resource://content-accessible/TopLevelImageDocument.css"));
+ }
+ InitialSetupDone();
+ }
+ }
+}
+
+void ImageDocument::OnPageShow(bool aPersisted,
+ EventTarget* aDispatchStartTarget,
+ bool aOnlySystemGroup) {
+ if (aPersisted) {
+ mOriginalZoomLevel = IsSiteSpecific() ? 1.0 : GetZoomLevel();
+ CheckFullZoom();
+ mOriginalResolution = GetResolution();
+ }
+ RefPtr<ImageDocument> kungFuDeathGrip(this);
+ UpdateSizeFromLayout();
+
+ MediaDocument::OnPageShow(aPersisted, aDispatchStartTarget, aOnlySystemGroup);
+}
+
+void ImageDocument::ShrinkToFit() {
+ if (!mImageContent) {
+ return;
+ }
+ if (GetZoomLevel() != mOriginalZoomLevel && mImageIsResized &&
+ !nsContentUtils::IsChildOfSameType(this)) {
+ // If we're zoomed, so that we don't maintain the invariant that
+ // mImageIsResized if and only if its displayed width/height fit in
+ // mVisibleWidth/mVisibleHeight, then we may need to switch to/from the
+ // overflowingVertical class here, because our viewport size may have
+ // changed and we don't plan to adjust the image size to compensate. Since
+ // mImageIsResized it has a "height" attribute set, and we can just get the
+ // displayed image height by getting .height on the HTMLImageElement.
+ //
+ // Hold strong ref, because Height() can run script.
+ RefPtr<HTMLImageElement> img = mImageContent;
+ uint32_t imageHeight = img->Height();
+ nsDOMTokenList* classList = img->ClassList();
+ if (imageHeight > mVisibleHeight) {
+ classList->Add(u"overflowingVertical"_ns, IgnoreErrors());
+ } else {
+ classList->Remove(u"overflowingVertical"_ns, IgnoreErrors());
+ }
+ return;
+ }
+ if (GetResolution() != mOriginalResolution && mImageIsResized) {
+ // Don't resize if resolution has changed, e.g., through pinch-zooming on
+ // Android.
+ return;
+ }
+
+ // Keep image content alive while changing the attributes.
+ RefPtr<HTMLImageElement> image = mImageContent;
+
+ uint32_t newWidth = std::max(1, NSToCoordFloor(GetRatio() * mImageWidth));
+ uint32_t newHeight = std::max(1, NSToCoordFloor(GetRatio() * mImageHeight));
+ image->SetWidth(newWidth, IgnoreErrors());
+ image->SetHeight(newHeight, IgnoreErrors());
+
+ // The view might have been scrolled when zooming in, scroll back to the
+ // origin now that we're showing a shrunk-to-window version.
+ ScrollImageTo(0, 0);
+
+ if (!mImageContent) {
+ // ScrollImageTo flush destroyed our content.
+ return;
+ }
+
+ SetModeClass(eShrinkToFit);
+
+ mImageIsResized = true;
+
+ UpdateTitleAndCharset();
+}
+
+void ImageDocument::ScrollImageTo(int32_t aX, int32_t aY) {
+ RefPtr<PresShell> presShell = GetPresShell();
+ if (!presShell) {
+ return;
+ }
+
+ nsIScrollableFrame* sf = presShell->GetRootScrollFrameAsScrollable();
+ if (!sf) {
+ return;
+ }
+
+ float ratio = GetRatio();
+ // Don't try to scroll image if the document is not visible (mVisibleWidth or
+ // mVisibleHeight is zero).
+ if (ratio <= 0.0) {
+ return;
+ }
+ nsRect portRect = sf->GetScrollPortRect();
+ sf->ScrollTo(
+ nsPoint(
+ nsPresContext::CSSPixelsToAppUnits(aX / ratio) - portRect.width / 2,
+ nsPresContext::CSSPixelsToAppUnits(aY / ratio) - portRect.height / 2),
+ ScrollMode::Instant);
+}
+
+void ImageDocument::RestoreImage() {
+ if (!mImageContent) {
+ return;
+ }
+ // Keep image content alive while changing the attributes.
+ RefPtr<HTMLImageElement> imageContent = mImageContent;
+ imageContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::width, true);
+ imageContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::height, true);
+
+ if (mIsInObjectOrEmbed) {
+ SetModeClass(eIsInObjectOrEmbed);
+ } else if (ImageIsOverflowing()) {
+ if (!ImageIsOverflowingVertically()) {
+ SetModeClass(eOverflowingHorizontalOnly);
+ } else {
+ SetModeClass(eOverflowingVertical);
+ }
+ } else {
+ SetModeClass(eNone);
+ }
+
+ mImageIsResized = false;
+
+ UpdateTitleAndCharset();
+}
+
+void ImageDocument::NotifyPossibleTitleChange(bool aBoundTitleElement) {
+ if (!mHasCustomTitle && !mTitleUpdateInProgress) {
+ mHasCustomTitle = true;
+ }
+
+ Document::NotifyPossibleTitleChange(aBoundTitleElement);
+}
+
+void ImageDocument::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);
+ }
+
+ // Run this using a script runner because HAS_TRANSPARENCY notifications can
+ // come during painting and this will trigger invalidation.
+ if (aType == imgINotificationObserver::HAS_TRANSPARENCY) {
+ nsCOMPtr<nsIRunnable> runnable =
+ NewRunnableMethod("dom::ImageDocument::OnHasTransparency", this,
+ &ImageDocument::OnHasTransparency);
+ nsContentUtils::AddScriptRunner(runnable);
+ }
+
+ if (aType == imgINotificationObserver::LOAD_COMPLETE) {
+ uint32_t reqStatus;
+ aRequest->GetImageStatus(&reqStatus);
+ nsresult status =
+ reqStatus & imgIRequest::STATUS_ERROR ? NS_ERROR_FAILURE : NS_OK;
+ return OnLoadComplete(aRequest, status);
+ }
+}
+
+void ImageDocument::OnHasTransparency() {
+ if (!mImageContent || nsContentUtils::IsChildOfSameType(this)) {
+ return;
+ }
+
+ nsDOMTokenList* classList = mImageContent->ClassList();
+ classList->Add(u"transparent"_ns, IgnoreErrors());
+}
+
+void ImageDocument::SetModeClass(eModeClasses mode) {
+ nsDOMTokenList* classList = mImageContent->ClassList();
+
+ if (mode == eShrinkToFit) {
+ classList->Add(u"shrinkToFit"_ns, IgnoreErrors());
+ } else {
+ classList->Remove(u"shrinkToFit"_ns, IgnoreErrors());
+ }
+
+ if (mode == eOverflowingVertical) {
+ classList->Add(u"overflowingVertical"_ns, IgnoreErrors());
+ } else {
+ classList->Remove(u"overflowingVertical"_ns, IgnoreErrors());
+ }
+
+ if (mode == eOverflowingHorizontalOnly) {
+ classList->Add(u"overflowingHorizontalOnly"_ns, IgnoreErrors());
+ } else {
+ classList->Remove(u"overflowingHorizontalOnly"_ns, IgnoreErrors());
+ }
+
+ if (mode == eIsInObjectOrEmbed) {
+ classList->Add(u"isInObjectOrEmbed"_ns, IgnoreErrors());
+ }
+}
+
+void ImageDocument::OnSizeAvailable(imgIRequest* aRequest,
+ imgIContainer* aImage) {
+ int32_t oldWidth = mImageWidth;
+ int32_t oldHeight = mImageHeight;
+
+ // Styles have not yet been applied, so we don't know the final size. For now,
+ // default to the image's intrinsic size.
+ aImage->GetWidth(&mImageWidth);
+ aImage->GetHeight(&mImageHeight);
+
+ // Multipart images send size available for each part; ignore them if it
+ // doesn't change our size. (We may not even support changing size in
+ // multipart images in the future.)
+ if (oldWidth == mImageWidth && oldHeight == mImageHeight) {
+ return;
+ }
+
+ nsCOMPtr<nsIRunnable> runnable =
+ NewRunnableMethod("dom::ImageDocument::DefaultCheckOverflowing", this,
+ &ImageDocument::DefaultCheckOverflowing);
+ nsContentUtils::AddScriptRunner(runnable);
+ UpdateTitleAndCharset();
+}
+
+void ImageDocument::OnLoadComplete(imgIRequest* aRequest, nsresult aStatus) {
+ UpdateTitleAndCharset();
+
+ // mImageContent can be null if the document is already destroyed
+ if (NS_FAILED(aStatus) && mImageContent) {
+ nsAutoCString src;
+ mDocumentURI->GetSpec(src);
+ AutoTArray<nsString, 1> formatString;
+ CopyUTF8toUTF16(src, *formatString.AppendElement());
+ nsAutoString errorMsg;
+ FormatStringFromName("InvalidImage", formatString, errorMsg);
+
+ mImageContent->SetAttr(kNameSpaceID_None, nsGkAtoms::alt, errorMsg, false);
+ }
+
+ MaybeSendResultToEmbedder(aStatus);
+}
+
+NS_IMETHODIMP
+ImageDocument::HandleEvent(Event* aEvent) {
+ nsAutoString eventType;
+ aEvent->GetType(eventType);
+ if (eventType.EqualsLiteral("resize")) {
+ CheckOverflowing(false);
+ CheckFullZoom();
+ } else if (eventType.EqualsLiteral("click") &&
+ StaticPrefs::browser_enable_click_image_resizing() &&
+ !mIsInObjectOrEmbed) {
+ ResetZoomLevel();
+ mShouldResize = true;
+ if (mImageIsResized) {
+ int32_t x = 0, y = 0;
+ MouseEvent* event = aEvent->AsMouseEvent();
+ if (event) {
+ RefPtr<HTMLImageElement> img = mImageContent;
+ x = event->ClientX() - img->OffsetLeft();
+ y = event->ClientY() - img->OffsetTop();
+ }
+ mShouldResize = false;
+ RestoreImage();
+ FlushPendingNotifications(FlushType::Layout);
+ ScrollImageTo(x, y);
+ } else if (ImageIsOverflowing()) {
+ ShrinkToFit();
+ }
+ } else if (eventType.EqualsLiteral("load")) {
+ UpdateSizeFromLayout();
+ }
+
+ return NS_OK;
+}
+
+void ImageDocument::UpdateSizeFromLayout() {
+ // Pull an updated size from the content frame to account for any size
+ // change due to CSS properties like |image-orientation|.
+ if (!mImageContent) {
+ return;
+ }
+
+ // Need strong ref, because GetPrimaryFrame can run script.
+ RefPtr<HTMLImageElement> imageContent = mImageContent;
+ nsIFrame* contentFrame = imageContent->GetPrimaryFrame(FlushType::Frames);
+ if (!contentFrame) {
+ return;
+ }
+
+ nsIntSize oldSize(mImageWidth, mImageHeight);
+ IntrinsicSize newSize = contentFrame->GetIntrinsicSize();
+
+ if (newSize.width) {
+ mImageWidth = nsPresContext::AppUnitsToFloatCSSPixels(*newSize.width);
+ }
+ if (newSize.height) {
+ mImageHeight = nsPresContext::AppUnitsToFloatCSSPixels(*newSize.height);
+ }
+
+ // Ensure that our information about overflow is up-to-date if needed.
+ if (mImageWidth != oldSize.width || mImageHeight != oldSize.height) {
+ CheckOverflowing(false);
+ }
+}
+
+void ImageDocument::UpdateRemoteStyle(StyleImageRendering aImageRendering) {
+ if (!mImageContent) {
+ return;
+ }
+
+ // Using ScriptRunner to avoid doing DOM mutation at an unexpected time.
+ if (!nsContentUtils::IsSafeToRunScript()) {
+ return nsContentUtils::AddScriptRunner(
+ NewRunnableMethod<StyleImageRendering>(
+ "UpdateRemoteStyle", this, &ImageDocument::UpdateRemoteStyle,
+ aImageRendering));
+ }
+
+ nsCOMPtr<nsICSSDeclaration> style = mImageContent->Style();
+ switch (aImageRendering) {
+ case StyleImageRendering::Auto:
+ case StyleImageRendering::Smooth:
+ case StyleImageRendering::Optimizequality:
+ style->SetProperty("image-rendering"_ns, "auto"_ns, ""_ns,
+ IgnoreErrors());
+ break;
+ case StyleImageRendering::Optimizespeed:
+ case StyleImageRendering::Pixelated:
+ style->SetProperty("image-rendering"_ns, "pixelated"_ns, ""_ns,
+ IgnoreErrors());
+ break;
+ case StyleImageRendering::CrispEdges:
+ style->SetProperty("image-rendering"_ns, "crisp-edges"_ns, ""_ns,
+ IgnoreErrors());
+ break;
+ }
+}
+
+nsresult ImageDocument::CreateSyntheticDocument() {
+ // Synthesize an html document that refers to the image
+ nsresult rv = MediaDocument::CreateSyntheticDocument();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Add the image element
+ RefPtr<Element> body = GetBodyElement();
+ if (!body) {
+ NS_WARNING("no body on image document!");
+ return NS_ERROR_FAILURE;
+ }
+
+ RefPtr<mozilla::dom::NodeInfo> nodeInfo;
+ nodeInfo = mNodeInfoManager->GetNodeInfo(
+ nsGkAtoms::img, nullptr, kNameSpaceID_XHTML, nsINode::ELEMENT_NODE);
+
+ RefPtr<Element> image = NS_NewHTMLImageElement(nodeInfo.forget());
+ mImageContent = HTMLImageElement::FromNodeOrNull(image);
+ if (!mImageContent) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ nsAutoCString src;
+ mDocumentURI->GetSpec(src);
+
+ NS_ConvertUTF8toUTF16 srcString(src);
+ // Make sure not to start the image load from here...
+ mImageContent->SetLoadingEnabled(false);
+ mImageContent->SetAttr(kNameSpaceID_None, nsGkAtoms::src, srcString, false);
+ mImageContent->SetAttr(kNameSpaceID_None, nsGkAtoms::alt, srcString, false);
+
+ if (mIsInObjectOrEmbed) {
+ SetModeClass(eIsInObjectOrEmbed);
+ }
+
+ body->AppendChildTo(mImageContent, false, IgnoreErrors());
+ mImageContent->SetLoadingEnabled(true);
+
+ return NS_OK;
+}
+
+void ImageDocument::DefaultCheckOverflowing() {
+ CheckOverflowing(StaticPrefs::browser_enable_automatic_image_resizing());
+}
+
+nsresult ImageDocument::CheckOverflowing(bool changeState) {
+ const bool imageWasOverflowing = ImageIsOverflowing();
+ const bool imageWasOverflowingVertically = ImageIsOverflowingVertically();
+
+ {
+ nsPresContext* context = GetPresContext();
+ if (!context) {
+ return NS_OK;
+ }
+
+ nsRect visibleArea = context->GetVisibleArea();
+
+ mVisibleWidth = nsPresContext::AppUnitsToFloatCSSPixels(visibleArea.width);
+ mVisibleHeight =
+ nsPresContext::AppUnitsToFloatCSSPixels(visibleArea.height);
+ }
+
+ const bool windowBecameBigEnough =
+ imageWasOverflowing && !ImageIsOverflowing();
+ const bool verticalOverflowChanged =
+ imageWasOverflowingVertically != ImageIsOverflowingVertically();
+
+ if (changeState || mShouldResize || mFirstResize || windowBecameBigEnough ||
+ verticalOverflowChanged) {
+ if (mIsInObjectOrEmbed) {
+ SetModeClass(eIsInObjectOrEmbed);
+ } else if (ImageIsOverflowing() && (changeState || mShouldResize)) {
+ ShrinkToFit();
+ } else if (mImageIsResized || mFirstResize || windowBecameBigEnough) {
+ RestoreImage();
+ } else if (!mImageIsResized && verticalOverflowChanged) {
+ if (ImageIsOverflowingVertically()) {
+ SetModeClass(eOverflowingVertical);
+ } else {
+ SetModeClass(eOverflowingHorizontalOnly);
+ }
+ }
+ }
+ mFirstResize = false;
+ return NS_OK;
+}
+
+void ImageDocument::UpdateTitleAndCharset() {
+ if (mHasCustomTitle) {
+ return;
+ }
+
+ AutoRestore<bool> restore(mTitleUpdateInProgress);
+ mTitleUpdateInProgress = true;
+
+ nsAutoCString typeStr;
+ nsCOMPtr<imgIRequest> imageRequest;
+ if (mImageContent) {
+ mImageContent->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
+ getter_AddRefs(imageRequest));
+ }
+
+ if (imageRequest) {
+ nsCString mimeType;
+ imageRequest->GetMimeType(getter_Copies(mimeType));
+ ToUpperCase(mimeType);
+ nsCString::const_iterator start, end;
+ mimeType.BeginReading(start);
+ mimeType.EndReading(end);
+ nsCString::const_iterator iter = end;
+ if (FindInReadable("IMAGE/"_ns, start, iter) && iter != end) {
+ // strip out "X-" if any
+ if (*iter == 'X') {
+ ++iter;
+ if (iter != end && *iter == '-') {
+ ++iter;
+ if (iter == end) {
+ // looks like "IMAGE/X-" is the type?? Bail out of here.
+ mimeType.BeginReading(iter);
+ }
+ } else {
+ --iter;
+ }
+ }
+ typeStr = Substring(iter, end);
+ } else {
+ typeStr = mimeType;
+ }
+ }
+
+ nsAutoString status;
+ if (mImageIsResized) {
+ AutoTArray<nsString, 1> formatString;
+ formatString.AppendElement()->AppendInt(NSToCoordFloor(GetRatio() * 100));
+
+ FormatStringFromName("ScaledImage", formatString, status);
+ }
+
+ static const char* const formatNames[4] = {
+ "ImageTitleWithNeitherDimensionsNorFile",
+ "ImageTitleWithoutDimensions",
+ "ImageTitleWithDimensions2",
+ "ImageTitleWithDimensions2AndFile",
+ };
+
+ MediaDocument::UpdateTitleAndCharset(typeStr, mChannel, formatNames,
+ mImageWidth, mImageHeight, status);
+}
+
+bool ImageDocument::IsSiteSpecific() {
+ return !ShouldResistFingerprinting(RFPTarget::SiteSpecificZoom) &&
+ StaticPrefs::browser_zoom_siteSpecific();
+}
+
+void ImageDocument::ResetZoomLevel() {
+ if (nsContentUtils::IsChildOfSameType(this)) {
+ return;
+ }
+
+ if (RefPtr<BrowsingContext> bc = GetBrowsingContext()) {
+ // Resetting the zoom level on a discarded browsing context has no effect.
+ Unused << bc->SetFullZoom(mOriginalZoomLevel);
+ }
+}
+
+float ImageDocument::GetZoomLevel() {
+ if (BrowsingContext* bc = GetBrowsingContext()) {
+ return bc->FullZoom();
+ }
+ return mOriginalZoomLevel;
+}
+
+void ImageDocument::CheckFullZoom() {
+ nsDOMTokenList* classList =
+ mImageContent ? mImageContent->ClassList() : nullptr;
+
+ if (!classList) {
+ return;
+ }
+
+ classList->Toggle(u"fullZoomOut"_ns,
+ dom::Optional<bool>(GetZoomLevel() > mOriginalZoomLevel),
+ IgnoreErrors());
+ classList->Toggle(u"fullZoomIn"_ns,
+ dom::Optional<bool>(GetZoomLevel() < mOriginalZoomLevel),
+ IgnoreErrors());
+}
+
+float ImageDocument::GetResolution() {
+ if (PresShell* presShell = GetPresShell()) {
+ return presShell->GetResolution();
+ }
+ return mOriginalResolution;
+}
+
+void ImageDocument::MaybeSendResultToEmbedder(nsresult aResult) {
+ if (!mIsInObjectOrEmbed) {
+ return;
+ }
+
+ BrowsingContext* context = GetBrowsingContext();
+
+ if (!context) {
+ return;
+ }
+
+ if (context->GetParent() && context->GetParent()->IsInProcess()) {
+ if (Element* embedder = context->GetEmbedderElement()) {
+ if (nsCOMPtr<nsIObjectLoadingContent> objectLoadingContent =
+ do_QueryInterface(embedder)) {
+ NS_DispatchToMainThread(NS_NewRunnableFunction(
+ "nsObjectLoadingContent::SubdocumentImageLoadComplete",
+ [objectLoadingContent, aResult]() {
+ static_cast<nsObjectLoadingContent*>(objectLoadingContent.get())
+ ->SubdocumentImageLoadComplete(aResult);
+ }));
+ }
+ return;
+ }
+ }
+
+ if (BrowserChild* browserChild =
+ BrowserChild::GetFrom(context->GetDocShell())) {
+ browserChild->SendImageLoadComplete(aResult);
+ }
+}
+} // namespace mozilla::dom
+
+nsresult NS_NewImageDocument(mozilla::dom::Document** aResult,
+ nsIPrincipal* aPrincipal,
+ nsIPrincipal* aPartitionedPrincipal) {
+ auto* doc = new mozilla::dom::ImageDocument();
+ NS_ADDREF(doc);
+
+ nsresult rv = doc->Init(aPrincipal, aPartitionedPrincipal);
+ if (NS_FAILED(rv)) {
+ NS_RELEASE(doc);
+ }
+
+ *aResult = doc;
+
+ return rv;
+}