dom/html/ImageDocument.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "ImageDocument.h"
   8 #include "mozilla/AutoRestore.h"
   9 #include "mozilla/ComputedStyle.h"
  10 #include "mozilla/dom/BrowserChild.h"
  11 #include "mozilla/dom/Element.h"
  12 #include "mozilla/dom/Event.h"
  13 #include "mozilla/dom/ImageDocumentBinding.h"
  14 #include "mozilla/dom/HTMLImageElement.h"
  15 #include "mozilla/dom/MouseEvent.h"
  16 #include "mozilla/LoadInfo.h"
  17 #include "mozilla/PresShell.h"
  18 #include "mozilla/StaticPrefs_browser.h"
  19 #include "nsICSSDeclaration.h"
  20 #include "nsObjectLoadingContent.h"
  21 #include "nsRect.h"
  22 #include "nsIImageLoadingContent.h"
  23 #include "nsGenericHTMLElement.h"
  24 #include "nsDocShell.h"
  25 #include "DocumentInlines.h"
  26 #include "nsDOMTokenList.h"
  27 #include "nsIDOMEventListener.h"
  28 #include "nsIFrame.h"
  29 #include "nsGkAtoms.h"
  30 #include "imgIRequest.h"
  31 #include "imgIContainer.h"
  32 #include "imgINotificationObserver.h"
  33 #include "nsPresContext.h"
  34 #include "nsIChannel.h"
  35 #include "nsIContentPolicy.h"
  36 #include "nsContentPolicyUtils.h"
  37 #include "nsPIDOMWindow.h"
  38 #include "nsError.h"
  39 #include "nsURILoader.h"
  40 #include "nsIDocShell.h"
  41 #include "nsIContentViewer.h"
  42 #include "nsThreadUtils.h"
  43 #include "nsIScrollableFrame.h"
  44 #include "nsContentUtils.h"
  45 #include "mozilla/Preferences.h"
  46 #include <algorithm>
  47
  48 namespace mozilla::dom {
  49
  50 class ImageListener : public MediaDocumentStreamListener {
  51  public:
  52   // NS_DECL_NSIREQUESTOBSERVER
  53   // We only implement OnStartRequest; OnStopRequest is
  54   // implemented by MediaDocumentStreamListener
  55   NS_IMETHOD OnStartRequest(nsIRequest* aRequest) override;
  56
  57   explicit ImageListener(ImageDocument* aDocument);
  58   virtual ~ImageListener();
  59 };
  60
  61 ImageListener::ImageListener(ImageDocument* aDocument)
  62     : MediaDocumentStreamListener(aDocument) {}
  63
  64 ImageListener::~ImageListener() = default;
  65
  66 NS_IMETHODIMP
  67 ImageListener::OnStartRequest(nsIRequest* request) {
  68   NS_ENSURE_TRUE(mDocument, NS_ERROR_FAILURE);
  69
  70   ImageDocument* imgDoc = static_cast<ImageDocument*>(mDocument.get());
  71   nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
  72   if (!channel) {
  73     return NS_ERROR_FAILURE;
  74   }
  75
  76   nsCOMPtr<nsPIDOMWindowOuter> domWindow = imgDoc->GetWindow();
  77   NS_ENSURE_TRUE(domWindow, NS_ERROR_UNEXPECTED);
  78
  79   // Do a ShouldProcess check to see whether to keep loading the image.
  80   nsCOMPtr<nsIURI> channelURI;
  81   channel->GetURI(getter_AddRefs(channelURI));
  82
  83   nsAutoCString mimeType;
  84   channel->GetContentType(mimeType);
  85
  86   nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
  87   // query the corresponding arguments for the channel loadinfo and pass
  88   // it on to the temporary loadinfo used for content policy checks.
  89   nsCOMPtr<nsINode> requestingNode = domWindow->GetFrameElementInternal();
  90   nsCOMPtr<nsIPrincipal> loadingPrincipal;
  91   if (requestingNode) {
  92     loadingPrincipal = requestingNode->NodePrincipal();
  93   } else {
  94     nsContentUtils::GetSecurityManager()->GetChannelResultPrincipal(
  95         channel, getter_AddRefs(loadingPrincipal));
  96   }
  97
  98   nsCOMPtr<nsILoadInfo> secCheckLoadInfo = new net::LoadInfo(
  99       loadingPrincipal, loadInfo->TriggeringPrincipal(), requestingNode,
 100       nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK,
 101       nsIContentPolicy::TYPE_INTERNAL_IMAGE);
 102
 103   int16_t decision = nsIContentPolicy::ACCEPT;
 104   nsresult rv = NS_CheckContentProcessPolicy(
 105       channelURI, secCheckLoadInfo, mimeType, &decision,
 106       nsContentUtils::GetContentPolicy());
 107
 108   if (NS_FAILED(rv) || NS_CP_REJECTED(decision)) {
 109     request->Cancel(NS_ERROR_CONTENT_BLOCKED);
 110     return NS_OK;
 111   }
 112
 113   if (!imgDoc->mObservingImageLoader) {
 114     NS_ENSURE_TRUE(imgDoc->mImageContent, NS_ERROR_UNEXPECTED);
 115     imgDoc->mImageContent->AddNativeObserver(imgDoc);
 116     imgDoc->mObservingImageLoader = true;
 117     imgDoc->mImageContent->LoadImageWithChannel(channel,
 118                                                 getter_AddRefs(mNextStream));
 119   }
 120
 121   return MediaDocumentStreamListener::OnStartRequest(request);
 122 }
 123
 124 ImageDocument::ImageDocument()
 125     : MediaDocument(),
 126       mVisibleWidth(0.0),
 127       mVisibleHeight(0.0),
 128       mImageWidth(0),
 129       mImageHeight(0),
 130       mImageIsResized(false),
 131       mShouldResize(false),
 132       mFirstResize(false),
 133       mObservingImageLoader(false),
 134       mTitleUpdateInProgress(false),
 135       mHasCustomTitle(false),
 136       mIsInObjectOrEmbed(false),
 137       mOriginalZoomLevel(1.0),
 138       mOriginalResolution(1.0) {}
 139
 140 ImageDocument::~ImageDocument() = default;
 141
 142 NS_IMPL_CYCLE_COLLECTION_INHERITED(ImageDocument, MediaDocument, mImageContent)
 143
 144 NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED(ImageDocument, MediaDocument,
 145                                              imgINotificationObserver,
 146                                              nsIDOMEventListener)
 147
 148 nsresult ImageDocument::Init(nsIPrincipal* aPrincipal,
 149                              nsIPrincipal* aPartitionedPrincipal) {
 150   nsresult rv = MediaDocument::Init(aPrincipal, aPartitionedPrincipal);
 151   NS_ENSURE_SUCCESS(rv, rv);
 152
 153   mShouldResize = StaticPrefs::browser_enable_automatic_image_resizing();
 154   mFirstResize = true;
 155
 156   return NS_OK;
 157 }
 158
 159 JSObject* ImageDocument::WrapNode(JSContext* aCx,
 160                                   JS::Handle<JSObject*> aGivenProto) {
 161   return ImageDocument_Binding::Wrap(aCx, this, aGivenProto);
 162 }
 163
 164 nsresult ImageDocument::StartDocumentLoad(
 165     const char* aCommand, nsIChannel* aChannel, nsILoadGroup* aLoadGroup,
 166     nsISupports* aContainer, nsIStreamListener** aDocListener, bool aReset) {
 167   nsresult rv = MediaDocument::StartDocumentLoad(
 168       aCommand, aChannel, aLoadGroup, aContainer, aDocListener, aReset);
 169   if (NS_FAILED(rv)) {
 170     return rv;
 171   }
 172
 173   mOriginalZoomLevel = IsSiteSpecific() ? 1.0 : GetZoomLevel();
 174   CheckFullZoom();
 175   mOriginalResolution = GetResolution();
 176
 177   if (BrowsingContext* context = GetBrowsingContext()) {
 178     mIsInObjectOrEmbed = context->IsEmbedderTypeObjectOrEmbed();
 179   }
 180
 181   NS_ASSERTION(aDocListener, "null aDocListener");
 182   *aDocListener = new ImageListener(this);
 183   NS_ADDREF(*aDocListener);
 184
 185   return NS_OK;
 186 }
 187
 188 void ImageDocument::Destroy() {
 189   if (RefPtr<HTMLImageElement> img = std::move(mImageContent)) {
 190     // Remove our event listener from the image content.
 191     img->RemoveEventListener(u"load"_ns, this, false);
 192     img->RemoveEventListener(u"click"_ns, this, false);
 193
 194     // Break reference cycle with mImageContent, if we have one
 195     if (mObservingImageLoader) {
 196       img->RemoveNativeObserver(this);
 197     }
 198   }
 199
 200   MediaDocument::Destroy();
 201 }
 202
 203 void ImageDocument::SetScriptGlobalObject(
 204     nsIScriptGlobalObject* aScriptGlobalObject) {
 205   // If the script global object is changing, we need to unhook our event
 206   // listeners on the window.
 207   nsCOMPtr<EventTarget> target;
 208   if (mScriptGlobalObject && aScriptGlobalObject != mScriptGlobalObject) {
 209     target = do_QueryInterface(mScriptGlobalObject);
 210     target->RemoveEventListener(u"resize"_ns, this, false);
 211     target->RemoveEventListener(u"keypress"_ns, this, false);
 212   }
 213
 214   // Set the script global object on the superclass before doing
 215   // anything that might require it....
 216   MediaDocument::SetScriptGlobalObject(aScriptGlobalObject);
 217
 218   if (aScriptGlobalObject) {
 219     if (!InitialSetupHasBeenDone()) {
 220       MOZ_ASSERT(!GetRootElement(), "Where did the root element come from?");
 221       // Create synthetic document
 222 #ifdef DEBUG
 223       nsresult rv =
 224 #endif
 225           CreateSyntheticDocument();
 226       NS_ASSERTION(NS_SUCCEEDED(rv), "failed to create synthetic document");
 227
 228       target = mImageContent;
 229       target->AddEventListener(u"load"_ns, this, false);
 230       target->AddEventListener(u"click"_ns, this, false);
 231     }
 232
 233     target = do_QueryInterface(aScriptGlobalObject);
 234     target->AddEventListener(u"resize"_ns, this, false);
 235     target->AddEventListener(u"keypress"_ns, this, false);
 236
 237     if (!InitialSetupHasBeenDone()) {
 238       LinkStylesheet(u"resource://content-accessible/ImageDocument.css"_ns);
 239       if (!nsContentUtils::IsChildOfSameType(this)) {
 240         LinkStylesheet(nsLiteralString(
 241             u"resource://content-accessible/TopLevelImageDocument.css"));
 242       }
 243       InitialSetupDone();
 244     }
 245   }
 246 }
 247
 248 void ImageDocument::OnPageShow(bool aPersisted,
 249                                EventTarget* aDispatchStartTarget,
 250                                bool aOnlySystemGroup) {
 251   if (aPersisted) {
 252     mOriginalZoomLevel = IsSiteSpecific() ? 1.0 : GetZoomLevel();
 253     CheckFullZoom();
 254     mOriginalResolution = GetResolution();
 255   }
 256   RefPtr<ImageDocument> kungFuDeathGrip(this);
 257   UpdateSizeFromLayout();
 258
 259   MediaDocument::OnPageShow(aPersisted, aDispatchStartTarget, aOnlySystemGroup);
 260 }
 261
 262 void ImageDocument::ShrinkToFit() {
 263   if (!mImageContent) {
 264     return;
 265   }
 266   if (GetZoomLevel() != mOriginalZoomLevel && mImageIsResized &&
 267       !nsContentUtils::IsChildOfSameType(this)) {
 268     // If we're zoomed, so that we don't maintain the invariant that
 269     // mImageIsResized if and only if its displayed width/height fit in
 270     // mVisibleWidth/mVisibleHeight, then we may need to switch to/from the
 271     // overflowingVertical class here, because our viewport size may have
 272     // changed and we don't plan to adjust the image size to compensate.  Since
 273     // mImageIsResized it has a "height" attribute set, and we can just get the
 274     // displayed image height by getting .height on the HTMLImageElement.
 275     //
 276     // Hold strong ref, because Height() can run script.
 277     RefPtr<HTMLImageElement> img = mImageContent;
 278     uint32_t imageHeight = img->Height();
 279     nsDOMTokenList* classList = img->ClassList();
 280     if (imageHeight > mVisibleHeight) {
 281       classList->Add(u"overflowingVertical"_ns, IgnoreErrors());
 282     } else {
 283       classList->Remove(u"overflowingVertical"_ns, IgnoreErrors());
 284     }
 285     return;
 286   }
 287   if (GetResolution() != mOriginalResolution && mImageIsResized) {
 288     // Don't resize if resolution has changed, e.g., through pinch-zooming on
 289     // Android.
 290     return;
 291   }
 292
 293   // Keep image content alive while changing the attributes.
 294   RefPtr<HTMLImageElement> image = mImageContent;
 295
 296   uint32_t newWidth = std::max(1, NSToCoordFloor(GetRatio() * mImageWidth));
 297   uint32_t newHeight = std::max(1, NSToCoordFloor(GetRatio() * mImageHeight));
 298   image->SetWidth(newWidth, IgnoreErrors());
 299   image->SetHeight(newHeight, IgnoreErrors());
 300
 301   // The view might have been scrolled when zooming in, scroll back to the
 302   // origin now that we're showing a shrunk-to-window version.
 303   ScrollImageTo(0, 0);
 304
 305   if (!mImageContent) {
 306     // ScrollImageTo flush destroyed our content.
 307     return;
 308   }
 309
 310   SetModeClass(eShrinkToFit);
 311
 312   mImageIsResized = true;
 313
 314   UpdateTitleAndCharset();
 315 }
 316
 317 void ImageDocument::ScrollImageTo(int32_t aX, int32_t aY) {
 318   RefPtr<PresShell> presShell = GetPresShell();
 319   if (!presShell) {
 320     return;
 321   }
 322
 323   nsIScrollableFrame* sf = presShell->GetRootScrollFrameAsScrollable();
 324   if (!sf) {
 325     return;
 326   }
 327
 328   float ratio = GetRatio();
 329   // Don't try to scroll image if the document is not visible (mVisibleWidth or
 330   // mVisibleHeight is zero).
 331   if (ratio <= 0.0) {
 332     return;
 333   }
 334   nsRect portRect = sf->GetScrollPortRect();
 335   sf->ScrollTo(
 336       nsPoint(
 337           nsPresContext::CSSPixelsToAppUnits(aX / ratio) - portRect.width / 2,
 338           nsPresContext::CSSPixelsToAppUnits(aY / ratio) - portRect.height / 2),
 339       ScrollMode::Instant);
 340 }
 341
 342 void ImageDocument::RestoreImage() {
 343   if (!mImageContent) {
 344     return;
 345   }
 346   // Keep image content alive while changing the attributes.
 347   RefPtr<HTMLImageElement> imageContent = mImageContent;
 348   imageContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::width, true);
 349   imageContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::height, true);
 350
 351   if (mIsInObjectOrEmbed) {
 352     SetModeClass(eIsInObjectOrEmbed);
 353   } else if (ImageIsOverflowing()) {
 354     if (!ImageIsOverflowingVertically()) {
 355       SetModeClass(eOverflowingHorizontalOnly);
 356     } else {
 357       SetModeClass(eOverflowingVertical);
 358     }
 359   } else {
 360     SetModeClass(eNone);
 361   }
 362
 363   mImageIsResized = false;
 364
 365   UpdateTitleAndCharset();
 366 }
 367
 368 void ImageDocument::NotifyPossibleTitleChange(bool aBoundTitleElement) {
 369   if (!mHasCustomTitle && !mTitleUpdateInProgress) {
 370     mHasCustomTitle = true;
 371   }
 372
 373   Document::NotifyPossibleTitleChange(aBoundTitleElement);
 374 }
 375
 376 void ImageDocument::Notify(imgIRequest* aRequest, int32_t aType,
 377                            const nsIntRect* aData) {
 378   if (aType == imgINotificationObserver::SIZE_AVAILABLE) {
 379     nsCOMPtr<imgIContainer> image;
 380     aRequest->GetImage(getter_AddRefs(image));
 381     return OnSizeAvailable(aRequest, image);
 382   }
 383
 384   // Run this using a script runner because HAS_TRANSPARENCY notifications can
 385   // come during painting and this will trigger invalidation.
 386   if (aType == imgINotificationObserver::HAS_TRANSPARENCY) {
 387     nsCOMPtr<nsIRunnable> runnable =
 388         NewRunnableMethod("dom::ImageDocument::OnHasTransparency", this,
 389                           &ImageDocument::OnHasTransparency);
 390     nsContentUtils::AddScriptRunner(runnable);
 391   }
 392
 393   if (aType == imgINotificationObserver::LOAD_COMPLETE) {
 394     uint32_t reqStatus;
 395     aRequest->GetImageStatus(&reqStatus);
 396     nsresult status =
 397         reqStatus & imgIRequest::STATUS_ERROR ? NS_ERROR_FAILURE : NS_OK;
 398     return OnLoadComplete(aRequest, status);
 399   }
 400 }
 401
 402 void ImageDocument::OnHasTransparency() {
 403   if (!mImageContent || nsContentUtils::IsChildOfSameType(this)) {
 404     return;
 405   }
 406
 407   nsDOMTokenList* classList = mImageContent->ClassList();
 408   classList->Add(u"transparent"_ns, IgnoreErrors());
 409 }
 410
 411 void ImageDocument::SetModeClass(eModeClasses mode) {
 412   nsDOMTokenList* classList = mImageContent->ClassList();
 413
 414   if (mode == eShrinkToFit) {
 415     classList->Add(u"shrinkToFit"_ns, IgnoreErrors());
 416   } else {
 417     classList->Remove(u"shrinkToFit"_ns, IgnoreErrors());
 418   }
 419
 420   if (mode == eOverflowingVertical) {
 421     classList->Add(u"overflowingVertical"_ns, IgnoreErrors());
 422   } else {
 423     classList->Remove(u"overflowingVertical"_ns, IgnoreErrors());
 424   }
 425
 426   if (mode == eOverflowingHorizontalOnly) {
 427     classList->Add(u"overflowingHorizontalOnly"_ns, IgnoreErrors());
 428   } else {
 429     classList->Remove(u"overflowingHorizontalOnly"_ns, IgnoreErrors());
 430   }
 431
 432   if (mode == eIsInObjectOrEmbed) {
 433     classList->Add(u"isInObjectOrEmbed"_ns, IgnoreErrors());
 434   }
 435 }
 436
 437 void ImageDocument::OnSizeAvailable(imgIRequest* aRequest,
 438                                     imgIContainer* aImage) {
 439   int32_t oldWidth = mImageWidth;
 440   int32_t oldHeight = mImageHeight;
 441
 442   // Styles have not yet been applied, so we don't know the final size. For now,
 443   // default to the image's intrinsic size.
 444   aImage->GetWidth(&mImageWidth);
 445   aImage->GetHeight(&mImageHeight);
 446
 447   // Multipart images send size available for each part; ignore them if it
 448   // doesn't change our size. (We may not even support changing size in
 449   // multipart images in the future.)
 450   if (oldWidth == mImageWidth && oldHeight == mImageHeight) {
 451     return;
 452   }
 453
 454   nsCOMPtr<nsIRunnable> runnable =
 455       NewRunnableMethod("dom::ImageDocument::DefaultCheckOverflowing", this,
 456                         &ImageDocument::DefaultCheckOverflowing);
 457   nsContentUtils::AddScriptRunner(runnable);
 458   UpdateTitleAndCharset();
 459 }
 460
 461 void ImageDocument::OnLoadComplete(imgIRequest* aRequest, nsresult aStatus) {
 462   UpdateTitleAndCharset();
 463
 464   // mImageContent can be null if the document is already destroyed
 465   if (NS_FAILED(aStatus) && mImageContent) {
 466     nsAutoCString src;
 467     mDocumentURI->GetSpec(src);
 468     AutoTArray<nsString, 1> formatString;
 469     CopyUTF8toUTF16(src, *formatString.AppendElement());
 470     nsAutoString errorMsg;
 471     FormatStringFromName("InvalidImage", formatString, errorMsg);
 472
 473     mImageContent->SetAttr(kNameSpaceID_None, nsGkAtoms::alt, errorMsg, false);
 474   }
 475
 476   MaybeSendResultToEmbedder(aStatus);
 477 }
 478
 479 NS_IMETHODIMP
 480 ImageDocument::HandleEvent(Event* aEvent) {
 481   nsAutoString eventType;
 482   aEvent->GetType(eventType);
 483   if (eventType.EqualsLiteral("resize")) {
 484     CheckOverflowing(false);
 485     CheckFullZoom();
 486   } else if (eventType.EqualsLiteral("click") &&
 487              StaticPrefs::browser_enable_click_image_resizing() &&
 488              !mIsInObjectOrEmbed) {
 489     ResetZoomLevel();
 490     mShouldResize = true;
 491     if (mImageIsResized) {
 492       int32_t x = 0, y = 0;
 493       MouseEvent* event = aEvent->AsMouseEvent();
 494       if (event) {
 495         RefPtr<HTMLImageElement> img = mImageContent;
 496         x = event->ClientX() - img->OffsetLeft();
 497         y = event->ClientY() - img->OffsetTop();
 498       }
 499       mShouldResize = false;
 500       RestoreImage();
 501       FlushPendingNotifications(FlushType::Layout);
 502       ScrollImageTo(x, y);
 503     } else if (ImageIsOverflowing()) {
 504       ShrinkToFit();
 505     }
 506   } else if (eventType.EqualsLiteral("load")) {
 507     UpdateSizeFromLayout();
 508   }
 509
 510   return NS_OK;
 511 }
 512
 513 void ImageDocument::UpdateSizeFromLayout() {
 514   // Pull an updated size from the content frame to account for any size
 515   // change due to CSS properties like |image-orientation|.
 516   if (!mImageContent) {
 517     return;
 518   }
 519
 520   // Need strong ref, because GetPrimaryFrame can run script.
 521   RefPtr<HTMLImageElement> imageContent = mImageContent;
 522   nsIFrame* contentFrame = imageContent->GetPrimaryFrame(FlushType::Frames);
 523   if (!contentFrame) {
 524     return;
 525   }
 526
 527   nsIntSize oldSize(mImageWidth, mImageHeight);
 528   IntrinsicSize newSize = contentFrame->GetIntrinsicSize();
 529
 530   if (newSize.width) {
 531     mImageWidth = nsPresContext::AppUnitsToFloatCSSPixels(*newSize.width);
 532   }
 533   if (newSize.height) {
 534     mImageHeight = nsPresContext::AppUnitsToFloatCSSPixels(*newSize.height);
 535   }
 536
 537   // Ensure that our information about overflow is up-to-date if needed.
 538   if (mImageWidth != oldSize.width || mImageHeight != oldSize.height) {
 539     CheckOverflowing(false);
 540   }
 541 }
 542
 543 void ImageDocument::UpdateRemoteStyle(StyleImageRendering aImageRendering) {
 544   if (!mImageContent) {
 545     return;
 546   }
 547
 548   // Using ScriptRunner to avoid doing DOM mutation at an unexpected time.
 549   if (!nsContentUtils::IsSafeToRunScript()) {
 550     return nsContentUtils::AddScriptRunner(
 551         NewRunnableMethod<StyleImageRendering>(
 552             "UpdateRemoteStyle", this, &ImageDocument::UpdateRemoteStyle,
 553             aImageRendering));
 554   }
 555
 556   nsCOMPtr<nsICSSDeclaration> style = mImageContent->Style();
 557   switch (aImageRendering) {
 558     case StyleImageRendering::Auto:
 559     case StyleImageRendering::Smooth:
 560     case StyleImageRendering::Optimizequality:
 561       style->SetProperty("image-rendering"_ns, "auto"_ns, ""_ns,
 562                          IgnoreErrors());
 563       break;
 564     case StyleImageRendering::Optimizespeed:
 565     case StyleImageRendering::Pixelated:
 566       style->SetProperty("image-rendering"_ns, "pixelated"_ns, ""_ns,
 567                          IgnoreErrors());
 568       break;
 569     case StyleImageRendering::CrispEdges:
 570       style->SetProperty("image-rendering"_ns, "crisp-edges"_ns, ""_ns,
 571                          IgnoreErrors());
 572       break;
 573   }
 574 }
 575
 576 nsresult ImageDocument::CreateSyntheticDocument() {
 577   // Synthesize an html document that refers to the image
 578   nsresult rv = MediaDocument::CreateSyntheticDocument();
 579   NS_ENSURE_SUCCESS(rv, rv);
 580
 581   // Add the image element
 582   RefPtr<Element> body = GetBodyElement();
 583   if (!body) {
 584     NS_WARNING("no body on image document!");
 585     return NS_ERROR_FAILURE;
 586   }
 587
 588   RefPtr<mozilla::dom::NodeInfo> nodeInfo;
 589   nodeInfo = mNodeInfoManager->GetNodeInfo(
 590       nsGkAtoms::img, nullptr, kNameSpaceID_XHTML, nsINode::ELEMENT_NODE);
 591
 592   RefPtr<Element> image = NS_NewHTMLImageElement(nodeInfo.forget());
 593   mImageContent = HTMLImageElement::FromNodeOrNull(image);
 594   if (!mImageContent) {
 595     return NS_ERROR_OUT_OF_MEMORY;
 596   }
 597
 598   nsAutoCString src;
 599   mDocumentURI->GetSpec(src);
 600
 601   NS_ConvertUTF8toUTF16 srcString(src);
 602   // Make sure not to start the image load from here...
 603   mImageContent->SetLoadingEnabled(false);
 604   mImageContent->SetAttr(kNameSpaceID_None, nsGkAtoms::src, srcString, false);
 605   mImageContent->SetAttr(kNameSpaceID_None, nsGkAtoms::alt, srcString, false);
 606
 607   if (mIsInObjectOrEmbed) {
 608     SetModeClass(eIsInObjectOrEmbed);
 609   }
 610
 611   body->AppendChildTo(mImageContent, false, IgnoreErrors());
 612   mImageContent->SetLoadingEnabled(true);
 613
 614   return NS_OK;
 615 }
 616
 617 void ImageDocument::DefaultCheckOverflowing() {
 618   CheckOverflowing(StaticPrefs::browser_enable_automatic_image_resizing());
 619 }
 620
 621 nsresult ImageDocument::CheckOverflowing(bool changeState) {
 622   const bool imageWasOverflowing = ImageIsOverflowing();
 623   const bool imageWasOverflowingVertically = ImageIsOverflowingVertically();
 624
 625   {
 626     nsPresContext* context = GetPresContext();
 627     if (!context) {
 628       return NS_OK;
 629     }
 630
 631     nsRect visibleArea = context->GetVisibleArea();
 632
 633     mVisibleWidth = nsPresContext::AppUnitsToFloatCSSPixels(visibleArea.width);
 634     mVisibleHeight =
 635         nsPresContext::AppUnitsToFloatCSSPixels(visibleArea.height);
 636   }
 637
 638   const bool windowBecameBigEnough =
 639       imageWasOverflowing && !ImageIsOverflowing();
 640   const bool verticalOverflowChanged =
 641       imageWasOverflowingVertically != ImageIsOverflowingVertically();
 642
 643   if (changeState || mShouldResize || mFirstResize || windowBecameBigEnough ||
 644       verticalOverflowChanged) {
 645     if (mIsInObjectOrEmbed) {
 646       SetModeClass(eIsInObjectOrEmbed);
 647     } else if (ImageIsOverflowing() && (changeState || mShouldResize)) {
 648       ShrinkToFit();
 649     } else if (mImageIsResized || mFirstResize || windowBecameBigEnough) {
 650       RestoreImage();
 651     } else if (!mImageIsResized && verticalOverflowChanged) {
 652       if (ImageIsOverflowingVertically()) {
 653         SetModeClass(eOverflowingVertical);
 654       } else {
 655         SetModeClass(eOverflowingHorizontalOnly);
 656       }
 657     }
 658   }
 659   mFirstResize = false;
 660   return NS_OK;
 661 }
 662
 663 void ImageDocument::UpdateTitleAndCharset() {
 664   if (mHasCustomTitle) {
 665     return;
 666   }
 667
 668   AutoRestore<bool> restore(mTitleUpdateInProgress);
 669   mTitleUpdateInProgress = true;
 670
 671   nsAutoCString typeStr;
 672   nsCOMPtr<imgIRequest> imageRequest;
 673   if (mImageContent) {
 674     mImageContent->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
 675                               getter_AddRefs(imageRequest));
 676   }
 677
 678   if (imageRequest) {
 679     nsCString mimeType;
 680     imageRequest->GetMimeType(getter_Copies(mimeType));
 681     ToUpperCase(mimeType);
 682     nsCString::const_iterator start, end;
 683     mimeType.BeginReading(start);
 684     mimeType.EndReading(end);
 685     nsCString::const_iterator iter = end;
 686     if (FindInReadable("IMAGE/"_ns, start, iter) && iter != end) {
 687       // strip out "X-" if any
 688       if (*iter == 'X') {
 689         ++iter;
 690         if (iter != end && *iter == '-') {
 691           ++iter;
 692           if (iter == end) {
 693             // looks like "IMAGE/X-" is the type??  Bail out of here.
 694             mimeType.BeginReading(iter);
 695           }
 696         } else {
 697           --iter;
 698         }
 699       }
 700       typeStr = Substring(iter, end);
 701     } else {
 702       typeStr = mimeType;
 703     }
 704   }
 705
 706   nsAutoString status;
 707   if (mImageIsResized) {
 708     AutoTArray<nsString, 1> formatString;
 709     formatString.AppendElement()->AppendInt(NSToCoordFloor(GetRatio() * 100));
 710
 711     FormatStringFromName("ScaledImage", formatString, status);
 712   }
 713
 714   static const char* const formatNames[4] = {
 715       "ImageTitleWithNeitherDimensionsNorFile",
 716       "ImageTitleWithoutDimensions",
 717       "ImageTitleWithDimensions2",
 718       "ImageTitleWithDimensions2AndFile",
 719   };
 720
 721   MediaDocument::UpdateTitleAndCharset(typeStr, mChannel, formatNames,
 722                                        mImageWidth, mImageHeight, status);
 723 }
 724
 725 bool ImageDocument::IsSiteSpecific() {
 726   return !ShouldResistFingerprinting(RFPTarget::SiteSpecificZoom) &&
 727          StaticPrefs::browser_zoom_siteSpecific();
 728 }
 729
 730 void ImageDocument::ResetZoomLevel() {
 731   if (nsContentUtils::IsChildOfSameType(this)) {
 732     return;
 733   }
 734
 735   if (RefPtr<BrowsingContext> bc = GetBrowsingContext()) {
 736     // Resetting the zoom level on a discarded browsing context has no effect.
 737     Unused << bc->SetFullZoom(mOriginalZoomLevel);
 738   }
 739 }
 740
 741 float ImageDocument::GetZoomLevel() {
 742   if (BrowsingContext* bc = GetBrowsingContext()) {
 743     return bc->FullZoom();
 744   }
 745   return mOriginalZoomLevel;
 746 }
 747
 748 void ImageDocument::CheckFullZoom() {
 749   nsDOMTokenList* classList =
 750       mImageContent ? mImageContent->ClassList() : nullptr;
 751
 752   if (!classList) {
 753     return;
 754   }
 755
 756   classList->Toggle(u"fullZoomOut"_ns,
 757                     dom::Optional<bool>(GetZoomLevel() > mOriginalZoomLevel),
 758                     IgnoreErrors());
 759   classList->Toggle(u"fullZoomIn"_ns,
 760                     dom::Optional<bool>(GetZoomLevel() < mOriginalZoomLevel),
 761                     IgnoreErrors());
 762 }
 763
 764 float ImageDocument::GetResolution() {
 765   if (PresShell* presShell = GetPresShell()) {
 766     return presShell->GetResolution();
 767   }
 768   return mOriginalResolution;
 769 }
 770
 771 void ImageDocument::MaybeSendResultToEmbedder(nsresult aResult) {
 772   if (!mIsInObjectOrEmbed) {
 773     return;
 774   }
 775
 776   BrowsingContext* context = GetBrowsingContext();
 777
 778   if (!context) {
 779     return;
 780   }
 781
 782   if (context->GetParent() && context->GetParent()->IsInProcess()) {
 783     if (Element* embedder = context->GetEmbedderElement()) {
 784       if (nsCOMPtr<nsIObjectLoadingContent> objectLoadingContent =
 785               do_QueryInterface(embedder)) {
 786         NS_DispatchToMainThread(NS_NewRunnableFunction(
 787             "nsObjectLoadingContent::SubdocumentImageLoadComplete",
 788             [objectLoadingContent, aResult]() {
 789               static_cast<nsObjectLoadingContent*>(objectLoadingContent.get())
 790                   ->SubdocumentImageLoadComplete(aResult);
 791             }));
 792       }
 793       return;
 794     }
 795   }
 796
 797   if (BrowserChild* browserChild =
 798           BrowserChild::GetFrom(context->GetDocShell())) {
 799     browserChild->SendImageLoadComplete(aResult);
 800   }
 801 }
 802 }  // namespace mozilla::dom
 803
 804 nsresult NS_NewImageDocument(mozilla::dom::Document** aResult,
 805                              nsIPrincipal* aPrincipal,
 806                              nsIPrincipal* aPartitionedPrincipal) {
 807   auto* doc = new mozilla::dom::ImageDocument();
 808   NS_ADDREF(doc);
 809
 810   nsresult rv = doc->Init(aPrincipal, aPartitionedPrincipal);
 811   if (NS_FAILED(rv)) {
 812     NS_RELEASE(doc);
 813   }
 814
 815   *aResult = doc;
 816
 817   return rv;
 818 }