Add m-esr52 at 52.6.0

1 files changed, 851 insertions, 0 deletions

diff --git a/dom/html/ImageDocument.cpp b/dom/html/ImageDocument.cpp
new file mode 100644
index 000000000..200bb5d46
--- /dev/null
+++ b/dom/html/ImageDocument.cpp
@@ -0,0 +1,851 @@
+/* -*- 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/dom/ImageDocumentBinding.h"
+#include "mozilla/dom/HTMLImageElement.h"
+#include "nsRect.h"
+#include "nsIImageLoadingContent.h"
+#include "nsGenericHTMLElement.h"
+#include "nsDocShell.h"
+#include "nsIDocumentInlines.h"
+#include "nsDOMTokenList.h"
+#include "nsIDOMHTMLImageElement.h"
+#include "nsIDOMEvent.h"
+#include "nsIDOMKeyEvent.h"
+#include "nsIDOMMouseEvent.h"
+#include "nsIDOMEventListener.h"
+#include "nsIFrame.h"
+#include "nsGkAtoms.h"
+#include "imgIRequest.h"
+#include "imgILoader.h"
+#include "imgIContainer.h"
+#include "imgINotificationObserver.h"
+#include "nsIPresShell.h"
+#include "nsPresContext.h"
+#include "nsStyleContext.h"
+#include "nsIChannel.h"
+#include "nsIContentPolicy.h"
+#include "nsContentPolicyUtils.h"
+#include "nsPIDOMWindow.h"
+#include "nsIDOMElement.h"
+#include "nsIDOMHTMLElement.h"
+#include "nsError.h"
+#include "nsURILoader.h"
+#include "nsIDocShell.h"
+#include "nsIContentViewer.h"
+#include "nsThreadUtils.h"
+#include "nsIScrollableFrame.h"
+#include "nsContentUtils.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/Preferences.h"
+#include <algorithm>
+
+#define AUTOMATIC_IMAGE_RESIZING_PREF "browser.enable_automatic_image_resizing"
+#define CLICK_IMAGE_RESIZING_PREF "browser.enable_click_image_resizing"
+//XXX A hack needed for Firefox's site specific zoom.
+#define SITE_SPECIFIC_ZOOM "browser.zoom.siteSpecific"
+
+namespace mozilla {
+namespace dom {
+ 
+class ImageListener : public MediaDocumentStreamListener
+{
+public:
+  NS_DECL_NSIREQUESTOBSERVER
+
+  explicit ImageListener(ImageDocument* aDocument);
+  virtual ~ImageListener();
+};
+
+ImageListener::ImageListener(ImageDocument* aDocument)
+  : MediaDocumentStreamListener(aDocument)
+{
+}
+
+ImageListener::~ImageListener()
+{
+}
+
+NS_IMETHODIMP
+ImageListener::OnStartRequest(nsIRequest* request, nsISupports *ctxt)
+{
+  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);
+
+  // Do a ShouldProcess check to see whether to keep loading the image.
+  nsCOMPtr<nsIURI> channelURI;
+  channel->GetURI(getter_AddRefs(channelURI));
+
+  nsAutoCString mimeType;
+  channel->GetContentType(mimeType);
+
+  nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
+  nsCOMPtr<nsIPrincipal> channelPrincipal;
+  if (secMan) {
+    secMan->GetChannelResultPrincipal(channel, getter_AddRefs(channelPrincipal));
+  }
+
+  int16_t decision = nsIContentPolicy::ACCEPT;
+  nsresult rv = NS_CheckContentProcessPolicy(nsIContentPolicy::TYPE_INTERNAL_IMAGE,
+                                             channelURI,
+                                             channelPrincipal,
+                                             domWindow->GetFrameElementInternal(),
+                                             mimeType,
+                                             nullptr,
+                                             &decision,
+                                             nsContentUtils::GetContentPolicy(),
+                                             secMan);
+
+  if (NS_FAILED(rv) || NS_CP_REJECTED(decision)) {
+    request->Cancel(NS_ERROR_CONTENT_BLOCKED);
+    return NS_OK;
+  }
+
+  if (!imgDoc->mObservingImageLoader) {
+    nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(imgDoc->mImageContent);
+    NS_ENSURE_TRUE(imageLoader, NS_ERROR_UNEXPECTED);
+
+    imageLoader->AddObserver(imgDoc);
+    imgDoc->mObservingImageLoader = true;
+    imageLoader->LoadImageWithChannel(channel, getter_AddRefs(mNextStream));
+  }
+
+  return MediaDocumentStreamListener::OnStartRequest(request, ctxt);
+}
+
+NS_IMETHODIMP
+ImageListener::OnStopRequest(nsIRequest* aRequest, nsISupports* aCtxt, nsresult aStatus)
+{
+  ImageDocument* imgDoc = static_cast<ImageDocument*>(mDocument.get());
+  nsContentUtils::DispatchChromeEvent(imgDoc, static_cast<nsIDocument*>(imgDoc),
+                                      NS_LITERAL_STRING("ImageContentLoaded"),
+                                      true, true);
+  return MediaDocumentStreamListener::OnStopRequest(aRequest, aCtxt, aStatus);
+}
+
+ImageDocument::ImageDocument()
+  : MediaDocument(),
+    mOriginalZoomLevel(1.0)
+{
+  // NOTE! nsDocument::operator new() zeroes out all members, so don't
+  // bother initializing members to 0.
+}
+
+ImageDocument::~ImageDocument()
+{
+}
+
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(ImageDocument, MediaDocument,
+                                   mImageContent)
+
+NS_IMPL_ADDREF_INHERITED(ImageDocument, MediaDocument)
+NS_IMPL_RELEASE_INHERITED(ImageDocument, MediaDocument)
+
+NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(ImageDocument)
+  NS_INTERFACE_TABLE_INHERITED(ImageDocument, nsIImageDocument,
+                               imgINotificationObserver, nsIDOMEventListener)
+NS_INTERFACE_TABLE_TAIL_INHERITING(MediaDocument)
+
+
+nsresult
+ImageDocument::Init()
+{
+  nsresult rv = MediaDocument::Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mResizeImageByDefault = Preferences::GetBool(AUTOMATIC_IMAGE_RESIZING_PREF);
+  mClickResizingEnabled = Preferences::GetBool(CLICK_IMAGE_RESIZING_PREF);
+  mShouldResize = mResizeImageByDefault;
+  mFirstResize = true;
+
+  return NS_OK;
+}
+
+JSObject*
+ImageDocument::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+  return ImageDocumentBinding::Wrap(aCx, this, aGivenProto);
+}
+
+nsresult
+ImageDocument::StartDocumentLoad(const char*         aCommand,
+                                 nsIChannel*         aChannel,
+                                 nsILoadGroup*       aLoadGroup,
+                                 nsISupports*        aContainer,
+                                 nsIStreamListener** aDocListener,
+                                 bool                aReset,
+                                 nsIContentSink*     aSink)
+{
+  nsresult rv =
+    MediaDocument::StartDocumentLoad(aCommand, aChannel, aLoadGroup, aContainer,
+                                     aDocListener, aReset, aSink);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  mOriginalZoomLevel =
+    Preferences::GetBool(SITE_SPECIFIC_ZOOM, false) ? 1.0 : GetZoomLevel();
+
+  NS_ASSERTION(aDocListener, "null aDocListener");
+  *aDocListener = new ImageListener(this);
+  NS_ADDREF(*aDocListener);
+
+  return NS_OK;
+}
+
+void
+ImageDocument::Destroy()
+{
+  if (mImageContent) {
+    // Remove our event listener from the image content.
+    nsCOMPtr<EventTarget> target = do_QueryInterface(mImageContent);
+    target->RemoveEventListener(NS_LITERAL_STRING("load"), this, false);
+    target->RemoveEventListener(NS_LITERAL_STRING("click"), this, false);
+
+    // Break reference cycle with mImageContent, if we have one
+    if (mObservingImageLoader) {
+      nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mImageContent);
+      if (imageLoader) {
+        imageLoader->RemoveObserver(this);
+      }
+    }
+
+    mImageContent = nullptr;
+  }
+
+  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(NS_LITERAL_STRING("resize"), this, false);
+    target->RemoveEventListener(NS_LITERAL_STRING("keypress"), this,
+                                false);
+  }
+
+  // Set the script global object on the superclass before doing
+  // anything that might require it....
+  MediaDocument::SetScriptGlobalObject(aScriptGlobalObject);
+
+  if (aScriptGlobalObject) {
+    if (!GetRootElement()) {
+      // Create synthetic document
+#ifdef DEBUG
+      nsresult rv =
+#endif
+        CreateSyntheticDocument();
+      NS_ASSERTION(NS_SUCCEEDED(rv), "failed to create synthetic document");
+
+      target = do_QueryInterface(mImageContent);
+      target->AddEventListener(NS_LITERAL_STRING("load"), this, false);
+      target->AddEventListener(NS_LITERAL_STRING("click"), this, false);
+    }
+
+    target = do_QueryInterface(aScriptGlobalObject);
+    target->AddEventListener(NS_LITERAL_STRING("resize"), this, false);
+    target->AddEventListener(NS_LITERAL_STRING("keypress"), this, false);
+
+    if (GetReadyStateEnum() != nsIDocument::READYSTATE_COMPLETE) {
+      LinkStylesheet(NS_LITERAL_STRING("resource://gre/res/ImageDocument.css"));
+      if (!nsContentUtils::IsChildOfSameType(this)) {
+        LinkStylesheet(NS_LITERAL_STRING("resource://gre/res/TopLevelImageDocument.css"));
+        LinkStylesheet(NS_LITERAL_STRING("chrome://global/skin/media/TopLevelImageDocument.css"));
+      }
+    }
+    BecomeInteractive();
+  }
+}
+
+void
+ImageDocument::OnPageShow(bool aPersisted,
+                          EventTarget* aDispatchStartTarget)
+{
+  if (aPersisted) {
+    mOriginalZoomLevel =
+      Preferences::GetBool(SITE_SPECIFIC_ZOOM, false) ? 1.0 : GetZoomLevel();
+  }
+  RefPtr<ImageDocument> kungFuDeathGrip(this);
+  UpdateSizeFromLayout();
+
+  MediaDocument::OnPageShow(aPersisted, aDispatchStartTarget);
+}
+
+NS_IMETHODIMP
+ImageDocument::GetImageIsOverflowing(bool* aImageIsOverflowing)
+{
+  *aImageIsOverflowing = ImageIsOverflowing();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ImageDocument::GetImageIsResized(bool* aImageIsResized)
+{
+  *aImageIsResized = ImageIsResized();
+  return NS_OK;
+}
+
+already_AddRefed<imgIRequest>
+ImageDocument::GetImageRequest(ErrorResult& aRv)
+{
+  nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mImageContent);
+  nsCOMPtr<imgIRequest> imageRequest;
+  if (imageLoader) {
+    aRv = imageLoader->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
+                                  getter_AddRefs(imageRequest));
+  }
+  return imageRequest.forget();
+}
+
+NS_IMETHODIMP
+ImageDocument::GetImageRequest(imgIRequest** aImageRequest)
+{
+  ErrorResult rv;
+  *aImageRequest = GetImageRequest(rv).take();
+  return rv.StealNSResult();
+}
+
+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 = HTMLImageElement::FromContent(mImageContent);
+    uint32_t imageHeight = img->Height();
+    nsDOMTokenList* classList = img->ClassList();
+    ErrorResult ignored;
+    if (imageHeight > mVisibleHeight) {
+      classList->Add(NS_LITERAL_STRING("overflowingVertical"), ignored);
+    } else {
+      classList->Remove(NS_LITERAL_STRING("overflowingVertical"), ignored);
+    }
+    ignored.SuppressException();
+    return;
+  }
+
+  // Keep image content alive while changing the attributes.
+  nsCOMPtr<Element> imageContent = mImageContent;
+  nsCOMPtr<nsIDOMHTMLImageElement> image = do_QueryInterface(imageContent);
+  image->SetWidth(std::max(1, NSToCoordFloor(GetRatio() * mImageWidth)));
+  image->SetHeight(std::max(1, NSToCoordFloor(GetRatio() * mImageHeight)));
+  
+  // 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, false);
+
+  if (!mImageContent) {
+    // ScrollImageTo flush destroyed our content.
+    return;
+  }
+
+  SetModeClass(eShrinkToFit);
+  
+  mImageIsResized = true;
+  
+  UpdateTitleAndCharset();
+}
+
+NS_IMETHODIMP
+ImageDocument::DOMShrinkToFit()
+{
+  ShrinkToFit();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ImageDocument::DOMRestoreImageTo(int32_t aX, int32_t aY)
+{
+  RestoreImageTo(aX, aY);
+  return NS_OK;
+}
+
+void
+ImageDocument::ScrollImageTo(int32_t aX, int32_t aY, bool restoreImage)
+{
+  float ratio = GetRatio();
+
+  if (restoreImage) {
+    RestoreImage();
+    FlushPendingNotifications(Flush_Layout);
+  }
+
+  nsCOMPtr<nsIPresShell> shell = GetShell();
+  if (!shell) {
+    return;
+  }
+
+  nsIScrollableFrame* sf = shell->GetRootScrollFrameAsScrollable();
+  if (!sf) {
+    return;
+  }
+
+  nsRect portRect = sf->GetScrollPortRect();
+  sf->ScrollTo(nsPoint(nsPresContext::CSSPixelsToAppUnits(aX/ratio) - portRect.width/2,
+                       nsPresContext::CSSPixelsToAppUnits(aY/ratio) - portRect.height/2),
+               nsIScrollableFrame::INSTANT);
+}
+
+void
+ImageDocument::RestoreImage()
+{
+  if (!mImageContent) {
+    return;
+  }
+  // Keep image content alive while changing the attributes.
+  nsCOMPtr<Element> imageContent = mImageContent;
+  imageContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::width, true);
+  imageContent->UnsetAttr(kNameSpaceID_None, nsGkAtoms::height, true);
+  
+  if (ImageIsOverflowing()) {
+    if (!mImageIsOverflowingVertically) {
+      SetModeClass(eOverflowingHorizontalOnly);
+    } else {
+      SetModeClass(eOverflowingVertical);
+    }
+  }
+  else {
+    SetModeClass(eNone);
+  }
+  
+  mImageIsResized = false;
+  
+  UpdateTitleAndCharset();
+}
+
+NS_IMETHODIMP
+ImageDocument::DOMRestoreImage()
+{
+  RestoreImage();
+  return NS_OK;
+}
+
+void
+ImageDocument::ToggleImageSize()
+{
+  mShouldResize = true;
+  if (mImageIsResized) {
+    mShouldResize = false;
+    ResetZoomLevel();
+    RestoreImage();
+  }
+  else if (ImageIsOverflowing()) {
+    ResetZoomLevel();
+    ShrinkToFit();
+  }
+}
+
+NS_IMETHODIMP
+ImageDocument::DOMToggleImageSize()
+{
+  ToggleImageSize();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+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(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);
+  }
+
+  return NS_OK;
+}
+
+void
+ImageDocument::OnHasTransparency()
+{
+  if (!mImageContent || nsContentUtils::IsChildOfSameType(this)) {
+    return;
+  }
+
+  nsDOMTokenList* classList = mImageContent->ClassList();
+  mozilla::ErrorResult rv;
+  classList->Add(NS_LITERAL_STRING("transparent"), rv);
+}
+
+void
+ImageDocument::SetModeClass(eModeClasses mode)
+{
+  nsDOMTokenList* classList = mImageContent->ClassList();
+  ErrorResult rv;
+
+  if (mode == eShrinkToFit) {
+    classList->Add(NS_LITERAL_STRING("shrinkToFit"), rv);
+  } else {
+    classList->Remove(NS_LITERAL_STRING("shrinkToFit"), rv);
+  }
+
+  if (mode == eOverflowingVertical) {
+    classList->Add(NS_LITERAL_STRING("overflowingVertical"), rv);
+  } else {
+    classList->Remove(NS_LITERAL_STRING("overflowingVertical"), rv);
+  }
+
+  if (mode == eOverflowingHorizontalOnly) {
+    classList->Add(NS_LITERAL_STRING("overflowingHorizontalOnly"), rv);
+  } else {
+    classList->Remove(NS_LITERAL_STRING("overflowingHorizontalOnly"), rv);
+  }
+
+  rv.SuppressException();
+}
+
+nsresult
+ImageDocument::OnSizeAvailable(imgIRequest* aRequest, imgIContainer* aImage)
+{
+  // 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);
+
+  nsCOMPtr<nsIRunnable> runnable =
+    NewRunnableMethod(this, &ImageDocument::DefaultCheckOverflowing);
+  nsContentUtils::AddScriptRunner(runnable);
+  UpdateTitleAndCharset();
+
+  return NS_OK;
+}
+
+nsresult
+ImageDocument::OnLoadComplete(imgIRequest* aRequest, nsresult aStatus)
+{
+  UpdateTitleAndCharset();
+
+  // mImageContent can be null if the document is already destroyed
+  if (NS_FAILED(aStatus) && mStringBundle && mImageContent) {
+    nsAutoCString src;
+    mDocumentURI->GetSpec(src);
+    NS_ConvertUTF8toUTF16 srcString(src);
+    const char16_t* formatString[] = { srcString.get() };
+    nsXPIDLString errorMsg;
+    NS_NAMED_LITERAL_STRING(str, "InvalidImage");
+    mStringBundle->FormatStringFromName(str.get(), formatString, 1,
+                                        getter_Copies(errorMsg));
+
+    mImageContent->SetAttr(kNameSpaceID_None, nsGkAtoms::alt, errorMsg, false);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ImageDocument::HandleEvent(nsIDOMEvent* aEvent)
+{
+  nsAutoString eventType;
+  aEvent->GetType(eventType);
+  if (eventType.EqualsLiteral("resize")) {
+    CheckOverflowing(false);
+  }
+  else if (eventType.EqualsLiteral("click") && mClickResizingEnabled) {
+    ResetZoomLevel();
+    mShouldResize = true;
+    if (mImageIsResized) {
+      int32_t x = 0, y = 0;
+      nsCOMPtr<nsIDOMMouseEvent> event(do_QueryInterface(aEvent));
+      if (event) {
+        event->GetClientX(&x);
+        event->GetClientY(&y);
+        int32_t left = 0, top = 0;
+        nsCOMPtr<nsIDOMHTMLElement> htmlElement =
+          do_QueryInterface(mImageContent);
+        htmlElement->GetOffsetLeft(&left);
+        htmlElement->GetOffsetTop(&top);
+        x -= left;
+        y -= top;
+      }
+      mShouldResize = false;
+      RestoreImageTo(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.
+  nsCOMPtr<Element> imageContent = mImageContent;
+  nsIFrame* contentFrame = imageContent->GetPrimaryFrame(Flush_Frames);
+  if (!contentFrame) {
+    return;
+  }
+
+  nsIntSize oldSize(mImageWidth, mImageHeight);
+  IntrinsicSize newSize = contentFrame->GetIntrinsicSize();
+
+  if (newSize.width.GetUnit() == eStyleUnit_Coord) {
+    mImageWidth = nsPresContext::AppUnitsToFloatCSSPixels(newSize.width.GetCoordValue());
+  }
+  if (newSize.height.GetUnit() == eStyleUnit_Coord) {
+    mImageHeight = nsPresContext::AppUnitsToFloatCSSPixels(newSize.height.GetCoordValue());
+  }
+
+  // Ensure that our information about overflow is up-to-date if needed.
+  if (mImageWidth != oldSize.width || mImageHeight != oldSize.height) {
+    CheckOverflowing(false);
+  }
+}
+
+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
+  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,
+                                           nsIDOMNode::ELEMENT_NODE);
+
+  mImageContent = NS_NewHTMLImageElement(nodeInfo.forget());
+  if (!mImageContent) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+  nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mImageContent);
+  NS_ENSURE_TRUE(imageLoader, NS_ERROR_UNEXPECTED);
+
+  nsAutoCString src;
+  mDocumentURI->GetSpec(src);
+
+  NS_ConvertUTF8toUTF16 srcString(src);
+  // Make sure not to start the image load from here...
+  imageLoader->SetLoadingEnabled(false);
+  mImageContent->SetAttr(kNameSpaceID_None, nsGkAtoms::src, srcString, false);
+  mImageContent->SetAttr(kNameSpaceID_None, nsGkAtoms::alt, srcString, false);
+
+  body->AppendChildTo(mImageContent, false);
+  imageLoader->SetLoadingEnabled(true);
+
+  return NS_OK;
+}
+
+nsresult
+ImageDocument::CheckOverflowing(bool changeState)
+{
+  /* Create a scope so that the style context gets destroyed before we might
+   * call RebuildStyleData.  Also, holding onto pointers to the
+   * presentation through style resolution is potentially dangerous.
+   */
+  {
+    nsIPresShell *shell = GetShell();
+    if (!shell) {
+      return NS_OK;
+    }
+
+    nsPresContext *context = shell->GetPresContext();
+    nsRect visibleArea = context->GetVisibleArea();
+
+    mVisibleWidth = nsPresContext::AppUnitsToFloatCSSPixels(visibleArea.width);
+    mVisibleHeight = nsPresContext::AppUnitsToFloatCSSPixels(visibleArea.height);
+  }
+
+  bool imageWasOverflowing = ImageIsOverflowing();
+  bool imageWasOverflowingVertically = mImageIsOverflowingVertically;
+  mImageIsOverflowingHorizontally = mImageWidth > mVisibleWidth;
+  mImageIsOverflowingVertically = mImageHeight > mVisibleHeight;
+  bool windowBecameBigEnough = imageWasOverflowing && !ImageIsOverflowing();
+  bool verticalOverflowChanged =
+    mImageIsOverflowingVertically != imageWasOverflowingVertically;
+
+  if (changeState || mShouldResize || mFirstResize ||
+      windowBecameBigEnough || verticalOverflowChanged) {
+    if (ImageIsOverflowing() && (changeState || mShouldResize)) {
+      ShrinkToFit();
+    }
+    else if (mImageIsResized || mFirstResize || windowBecameBigEnough) {
+      RestoreImage();
+    } else if (!mImageIsResized && verticalOverflowChanged) {
+      if (mImageIsOverflowingVertically) {
+        SetModeClass(eOverflowingVertical);
+      } else {
+        SetModeClass(eOverflowingHorizontalOnly);
+      }
+    }
+  }
+  mFirstResize = false;
+
+  return NS_OK;
+}
+
+void 
+ImageDocument::UpdateTitleAndCharset()
+{
+  nsAutoCString typeStr;
+  nsCOMPtr<imgIRequest> imageRequest;
+  nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mImageContent);
+  if (imageLoader) {
+    imageLoader->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
+                            getter_AddRefs(imageRequest));
+  }
+    
+  if (imageRequest) {
+    nsXPIDLCString mimeType;
+    imageRequest->GetMimeType(getter_Copies(mimeType));
+    ToUpperCase(mimeType);
+    nsXPIDLCString::const_iterator start, end;
+    mimeType.BeginReading(start);
+    mimeType.EndReading(end);
+    nsXPIDLCString::const_iterator iter = end;
+    if (FindInReadable(NS_LITERAL_CSTRING("IMAGE/"), 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;
+    }
+  }
+
+  nsXPIDLString status;
+  if (mImageIsResized) {
+    nsAutoString ratioStr;
+    ratioStr.AppendInt(NSToCoordFloor(GetRatio() * 100));
+
+    const char16_t* formatString[1] = { ratioStr.get() };
+    mStringBundle->FormatStringFromName(u"ScaledImage",
+                                        formatString, 1,
+                                        getter_Copies(status));
+  }
+
+  static const char* const formatNames[4] = 
+  {
+    "ImageTitleWithNeitherDimensionsNorFile",
+    "ImageTitleWithoutDimensions",
+    "ImageTitleWithDimensions2",
+    "ImageTitleWithDimensions2AndFile",
+  };
+
+  MediaDocument::UpdateTitleAndCharset(typeStr, mChannel, formatNames,
+                                       mImageWidth, mImageHeight, status);
+}
+
+void
+ImageDocument::ResetZoomLevel()
+{
+  nsCOMPtr<nsIDocShell> docShell(mDocumentContainer);
+  if (docShell) {
+    if (nsContentUtils::IsChildOfSameType(this)) {
+      return;
+    }
+
+    nsCOMPtr<nsIContentViewer> cv;
+    docShell->GetContentViewer(getter_AddRefs(cv));
+    if (cv) {
+      cv->SetFullZoom(mOriginalZoomLevel);
+    }
+  }
+}
+
+float
+ImageDocument::GetZoomLevel()
+{
+  float zoomLevel = mOriginalZoomLevel;
+  nsCOMPtr<nsIDocShell> docShell(mDocumentContainer);
+  if (docShell) {
+    nsCOMPtr<nsIContentViewer> cv;
+    docShell->GetContentViewer(getter_AddRefs(cv));
+    if (cv) {
+      cv->GetFullZoom(&zoomLevel);
+    }
+  }
+  return zoomLevel;
+}
+
+} // namespace dom
+} // namespace mozilla
+
+nsresult
+NS_NewImageDocument(nsIDocument** aResult)
+{
+  mozilla::dom::ImageDocument* doc = new mozilla::dom::ImageDocument();
+  NS_ADDREF(doc);
+
+  nsresult rv = doc->Init();
+  if (NS_FAILED(rv)) {
+    NS_RELEASE(doc);
+  }
+
+  *aResult = doc;
+
+  return rv;
+}