mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/dom/html/ImageDocument.cpp

911 строки
26 KiB
C++
Исходник Ответственный История

/* -*- 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/ComputedStyle.h"
#include "mozilla/dom/DOMPrefs.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 "nsRect.h"
#include "nsIImageLoadingContent.h"
#include "nsGenericHTMLElement.h"
#include "nsDocShell.h"
#include "nsIDocumentInlines.h"
#include "nsDOMTokenList.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 "nsIChannel.h"
#include "nsIContentPolicy.h"
#include "nsContentPolicyUtils.h"
#include "nsPIDOMWindow.h"
#include "nsError.h"
#include "nsURILoader.h"
#include "nsIDocShell.h"
#include "nsIContentViewer.h"
#include "nsThreadUtils.h"
#include "nsIScrollableFrame.h"
#include "nsContentUtils.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.
static bool IsSiteSpecific()
{
return !mozilla::dom::DOMPrefs::ResistFingerprintingEnabled() &&
mozilla::Preferences::GetBool("browser.zoom.siteSpecific", false);
}
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);
nsCOMPtr<nsILoadInfo> loadInfo = channel->GetLoadInfo();
// query the corresponding arguments for the channel loadinfo and pass
// it on to the temporary loadinfo used for content policy checks.
nsCOMPtr<nsINode> requestingNode = domWindow->GetFrameElementInternal();
nsCOMPtr<nsIPrincipal> loadingPrincipal;
if (requestingNode) {
loadingPrincipal = requestingNode->NodePrincipal();
}
else {
nsContentUtils::GetSecurityManager()->
GetChannelResultPrincipal(channel, getter_AddRefs(loadingPrincipal));
}
nsCOMPtr<nsILoadInfo> secCheckLoadInfo =
new net::LoadInfo(loadingPrincipal,
loadInfo ? loadInfo->TriggeringPrincipal() : nullptr,
requestingNode,
nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK,
nsIContentPolicy::TYPE_INTERNAL_IMAGE);
int16_t decision = nsIContentPolicy::ACCEPT;
nsresult rv = NS_CheckContentProcessPolicy(channelURI,
secCheckLoadInfo,
mimeType,
&decision,
nsContentUtils::GetContentPolicy());
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->AddNativeObserver(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"),
CanBubble::eYes, Cancelable::eYes);
return MediaDocumentStreamListener::OnStopRequest(aRequest, aCtxt, aStatus);
}
ImageDocument::ImageDocument()
: MediaDocument()
, mVisibleWidth(0.0)
, mVisibleHeight(0.0)
, mImageWidth(0)
, mImageHeight(0)
, mResizeImageByDefault(false)
, mClickResizingEnabled(false)
, mImageIsOverflowingHorizontally(false)
, mImageIsOverflowingVertically(false)
, mImageIsResized(false)
, mShouldResize(false)
, mFirstResize(false)
, mObservingImageLoader(false)
, mOriginalZoomLevel(1.0)
#if defined(MOZ_WIDGET_ANDROID)
, mOriginalResolution(1.0)
#endif
{
}
ImageDocument::~ImageDocument()
{
}
NS_IMPL_CYCLE_COLLECTION_INHERITED(ImageDocument, MediaDocument,
mImageContent)
NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED(ImageDocument,
MediaDocument,
nsIImageDocument,
imgINotificationObserver,
nsIDOMEventListener)
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 ImageDocument_Binding::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 = IsSiteSpecific() ? 1.0 : GetZoomLevel();
#if defined(MOZ_WIDGET_ANDROID)
mOriginalResolution = GetResolution();
#endif
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->RemoveNativeObserver(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 (!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 = 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 (!InitialSetupHasBeenDone()) {
LinkStylesheet(NS_LITERAL_STRING("resource://content-accessible/ImageDocument.css"));
if (!nsContentUtils::IsChildOfSameType(this)) {
LinkStylesheet(NS_LITERAL_STRING("resource://content-accessible/TopLevelImageDocument.css"));
LinkStylesheet(NS_LITERAL_STRING("chrome://global/skin/media/TopLevelImageDocument.css"));
}
InitialSetupDone();
}
}
}
void
ImageDocument::OnPageShow(bool aPersisted,
EventTarget* aDispatchStartTarget)
{
if (aPersisted) {
mOriginalZoomLevel = IsSiteSpecific() ? 1.0 : GetZoomLevel();
#if defined(MOZ_WIDGET_ANDROID)
mOriginalResolution = GetResolution();
#endif
}
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::FromNode(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;
}
#if defined(MOZ_WIDGET_ANDROID)
if (GetResolution() != mOriginalResolution && mImageIsResized) {
// Don't resize if resolution has changed, e.g., through pinch-zooming on
// Android.
return;
}
#endif
// Keep image content alive while changing the attributes.
RefPtr<HTMLImageElement> image = HTMLImageElement::FromNode(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, 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)
{
if (restoreImage) {
RestoreImage();
FlushPendingNotifications(FlushType::Layout);
}
nsCOMPtr<nsIPresShell> shell = GetShell();
if (!shell) {
return;
}
nsIScrollableFrame* sf = shell->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),
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("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);
}
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)
{
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 NS_OK;
}
nsCOMPtr<nsIRunnable> runnable =
NewRunnableMethod("dom::ImageDocument::DefaultCheckOverflowing",
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() };
nsAutoString errorMsg;
mStringBundle->FormatStringFromName("InvalidImage", formatString, 1,
errorMsg);
mImageContent->SetAttr(kNameSpaceID_None, nsGkAtoms::alt, errorMsg, false);
}
return NS_OK;
}
NS_IMETHODIMP
ImageDocument::HandleEvent(Event* 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;
MouseEvent* event = aEvent->AsMouseEvent();
if (event) {
RefPtr<HTMLImageElement> img =
HTMLImageElement::FromNode(mImageContent);
x = event->ClientX() - img->OffsetLeft();
y = event->ClientY() - img->OffsetTop();
}
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(FlushType::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,
nsINode::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 ComputedStyle gets destroyed before we might
* call RebuildStyleData. Also, holding onto pointers to the
* presentation through style resolution is potentially dangerous.
*/
{
nsPresContext* context = GetPresContext();
if (!context) {
return NS_OK;
}
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) {
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(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;
}
}
nsAutoString status;
if (mImageIsResized) {
nsAutoString ratioStr;
ratioStr.AppendInt(NSToCoordFloor(GetRatio() * 100));
const char16_t* formatString[1] = { ratioStr.get() };
mStringBundle->FormatStringFromName("ScaledImage", formatString, 1, 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;
}
#if defined(MOZ_WIDGET_ANDROID)
float
ImageDocument::GetResolution()
{
float resolution = mOriginalResolution;
nsCOMPtr<nsIPresShell> shell = GetShell();
if (shell) {
resolution = shell->GetResolution();
}
return resolution;
}
#endif
} // 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;
}
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку