mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-19 16:25:38 +00:00
91b071ed14
gfx::Color is currently misused in many places. The DrawTargets expect the color space to be in device space, e.g. what we are actually going to draw using. Everything sitting above generally deals with sRGB, as specified in CSS. Sometimes we missed the conversion from sRGB to device space when issuing draw calls, and similarly sometimes we converted the color to device space twice. This patch splits the type in two. sRGBColor and DeviceColor now represent sRGB and device color spaces respectively. DrawTarget only accepts DeviceColor, and one can get a DeviceColor from an sRGBColor via the ToDeviceColor helper API. The reftests now pass with color management enabled for everything (e.g. CSS) instead of just tagged raster images. There will be a follow up patch to enable color management everywhere by default on all supported platforms. Differential Revision: https://phabricator.services.mozilla.com/D64771 --HG-- extra : moz-landing-system : lando
460 lines
15 KiB
C++
460 lines
15 KiB
C++
/* 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 "gfxSVGGlyphs.h"
|
|
|
|
#include "mozilla/BasePrincipal.h"
|
|
#include "mozilla/LoadInfo.h"
|
|
#include "mozilla/NullPrincipal.h"
|
|
#include "mozilla/PresShell.h"
|
|
#include "mozilla/SMILAnimationController.h"
|
|
#include "mozilla/SVGContextPaint.h"
|
|
#include "mozilla/dom/Document.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "mozilla/dom/FontTableURIProtocolHandler.h"
|
|
#include "mozilla/dom/ImageTracker.h"
|
|
#include "mozilla/dom/SVGDocument.h"
|
|
#include "nsError.h"
|
|
#include "nsString.h"
|
|
#include "nsICategoryManager.h"
|
|
#include "nsIDocumentLoaderFactory.h"
|
|
#include "nsIContentViewer.h"
|
|
#include "nsIStreamListener.h"
|
|
#include "nsServiceManagerUtils.h"
|
|
#include "nsNetUtil.h"
|
|
#include "nsIInputStream.h"
|
|
#include "nsStringStream.h"
|
|
#include "nsStreamUtils.h"
|
|
#include "nsIPrincipal.h"
|
|
#include "nsSVGUtils.h"
|
|
#include "nsContentUtils.h"
|
|
#include "gfxFont.h"
|
|
#include "gfxContext.h"
|
|
#include "harfbuzz/hb.h"
|
|
#include "zlib.h"
|
|
|
|
#define SVG_CONTENT_TYPE NS_LITERAL_CSTRING("image/svg+xml")
|
|
#define UTF8_CHARSET NS_LITERAL_CSTRING("utf-8")
|
|
|
|
using namespace mozilla;
|
|
using mozilla::dom::Document;
|
|
using mozilla::dom::Element;
|
|
|
|
/* static */
|
|
const mozilla::gfx::DeviceColor SimpleTextContextPaint::sZero;
|
|
|
|
gfxSVGGlyphs::gfxSVGGlyphs(hb_blob_t* aSVGTable, gfxFontEntry* aFontEntry)
|
|
: mSVGData(aSVGTable), mFontEntry(aFontEntry) {
|
|
unsigned int length;
|
|
const char* svgData = hb_blob_get_data(mSVGData, &length);
|
|
mHeader = reinterpret_cast<const Header*>(svgData);
|
|
mDocIndex = nullptr;
|
|
|
|
if (sizeof(Header) <= length && uint16_t(mHeader->mVersion) == 0 &&
|
|
uint64_t(mHeader->mDocIndexOffset) + 2 <= length) {
|
|
const DocIndex* docIndex =
|
|
reinterpret_cast<const DocIndex*>(svgData + mHeader->mDocIndexOffset);
|
|
// Limit the number of documents to avoid overflow
|
|
if (uint64_t(mHeader->mDocIndexOffset) + 2 +
|
|
uint16_t(docIndex->mNumEntries) * sizeof(IndexEntry) <=
|
|
length) {
|
|
mDocIndex = docIndex;
|
|
}
|
|
}
|
|
}
|
|
|
|
gfxSVGGlyphs::~gfxSVGGlyphs() { hb_blob_destroy(mSVGData); }
|
|
|
|
void gfxSVGGlyphs::DidRefresh() { mFontEntry->NotifyGlyphsChanged(); }
|
|
|
|
/*
|
|
* Comparison operator for finding a range containing a given glyph ID. Simply
|
|
* checks whether |key| is less (greater) than every element of |range|, in
|
|
* which case return |key| < |range| (|key| > |range|). Otherwise |key| is in
|
|
* |range|, in which case return equality.
|
|
* The total ordering here is guaranteed by
|
|
* (1) the index ranges being disjoint; and
|
|
* (2) the (sole) key always being a singleton, so intersection => containment
|
|
* (note that this is wrong if we have more than one intersection or two
|
|
* sets intersecting of size > 1 -- so... don't do that)
|
|
*/
|
|
/* static */
|
|
int gfxSVGGlyphs::CompareIndexEntries(const void* aKey, const void* aEntry) {
|
|
const uint32_t key = *(uint32_t*)aKey;
|
|
const IndexEntry* entry = (const IndexEntry*)aEntry;
|
|
|
|
if (key < uint16_t(entry->mStartGlyph)) {
|
|
return -1;
|
|
}
|
|
if (key > uint16_t(entry->mEndGlyph)) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
gfxSVGGlyphsDocument* gfxSVGGlyphs::FindOrCreateGlyphsDocument(
|
|
uint32_t aGlyphId) {
|
|
if (!mDocIndex) {
|
|
// Invalid table
|
|
return nullptr;
|
|
}
|
|
|
|
IndexEntry* entry = (IndexEntry*)bsearch(
|
|
&aGlyphId, mDocIndex->mEntries, uint16_t(mDocIndex->mNumEntries),
|
|
sizeof(IndexEntry), CompareIndexEntries);
|
|
if (!entry) {
|
|
return nullptr;
|
|
}
|
|
|
|
gfxSVGGlyphsDocument* result = mGlyphDocs.Get(entry->mDocOffset);
|
|
|
|
if (!result) {
|
|
unsigned int length;
|
|
const uint8_t* data = (const uint8_t*)hb_blob_get_data(mSVGData, &length);
|
|
if (entry->mDocOffset > 0 && uint64_t(mHeader->mDocIndexOffset) +
|
|
entry->mDocOffset +
|
|
entry->mDocLength <=
|
|
length) {
|
|
result = new gfxSVGGlyphsDocument(
|
|
data + mHeader->mDocIndexOffset + entry->mDocOffset,
|
|
entry->mDocLength, this);
|
|
mGlyphDocs.Put(entry->mDocOffset, result);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
nsresult gfxSVGGlyphsDocument::SetupPresentation() {
|
|
nsCOMPtr<nsICategoryManager> catMan =
|
|
do_GetService(NS_CATEGORYMANAGER_CONTRACTID);
|
|
nsCString contractId;
|
|
nsresult rv = catMan->GetCategoryEntry("Gecko-Content-Viewers",
|
|
"image/svg+xml", contractId);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsIDocumentLoaderFactory> docLoaderFactory =
|
|
do_GetService(contractId.get());
|
|
NS_ASSERTION(docLoaderFactory, "Couldn't get DocumentLoaderFactory");
|
|
|
|
nsCOMPtr<nsIContentViewer> viewer;
|
|
rv = docLoaderFactory->CreateInstanceForDocument(nullptr, mDocument, nullptr,
|
|
getter_AddRefs(viewer));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = viewer->Init(nullptr, gfx::IntRect(0, 0, 1000, 1000), nullptr);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
rv = viewer->Open(nullptr, nullptr);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
RefPtr<PresShell> presShell = viewer->GetPresShell();
|
|
if (!presShell->DidInitialize()) {
|
|
rv = presShell->Initialize();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
mDocument->FlushPendingNotifications(FlushType::Layout);
|
|
|
|
if (mDocument->HasAnimationController()) {
|
|
mDocument->GetAnimationController()->Resume(SMILTimeContainer::PAUSE_IMAGE);
|
|
}
|
|
mDocument->ImageTracker()->SetAnimatingState(true);
|
|
|
|
mViewer = viewer;
|
|
mPresShell = presShell;
|
|
mPresShell->AddPostRefreshObserver(this);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void gfxSVGGlyphsDocument::DidRefresh() { mOwner->DidRefresh(); }
|
|
|
|
/**
|
|
* Walk the DOM tree to find all glyph elements and insert them into the lookup
|
|
* table
|
|
* @param aElem The element to search from
|
|
*/
|
|
void gfxSVGGlyphsDocument::FindGlyphElements(Element* aElem) {
|
|
for (nsIContent* child = aElem->GetLastChild(); child;
|
|
child = child->GetPreviousSibling()) {
|
|
if (!child->IsElement()) {
|
|
continue;
|
|
}
|
|
FindGlyphElements(child->AsElement());
|
|
}
|
|
|
|
InsertGlyphId(aElem);
|
|
}
|
|
|
|
/**
|
|
* If there exists an SVG glyph with the specified glyph id, render it and
|
|
* return true If no such glyph exists, or in the case of an error return false
|
|
* @param aContext The thebes aContext to draw to
|
|
* @param aGlyphId The glyph id
|
|
* @return true iff rendering succeeded
|
|
*/
|
|
void gfxSVGGlyphs::RenderGlyph(gfxContext* aContext, uint32_t aGlyphId,
|
|
SVGContextPaint* aContextPaint) {
|
|
gfxContextAutoSaveRestore aContextRestorer(aContext);
|
|
|
|
Element* glyph = mGlyphIdMap.Get(aGlyphId);
|
|
MOZ_ASSERT(glyph, "No glyph element. Should check with HasSVGGlyph() first!");
|
|
|
|
AutoSetRestoreSVGContextPaint autoSetRestore(
|
|
*aContextPaint, *glyph->OwnerDoc()->AsSVGDocument());
|
|
|
|
nsSVGUtils::PaintSVGGlyph(glyph, aContext);
|
|
}
|
|
|
|
bool gfxSVGGlyphs::GetGlyphExtents(uint32_t aGlyphId,
|
|
const gfxMatrix& aSVGToAppSpace,
|
|
gfxRect* aResult) {
|
|
Element* glyph = mGlyphIdMap.Get(aGlyphId);
|
|
NS_ASSERTION(glyph,
|
|
"No glyph element. Should check with HasSVGGlyph() first!");
|
|
|
|
return nsSVGUtils::GetSVGGlyphExtents(glyph, aSVGToAppSpace, aResult);
|
|
}
|
|
|
|
Element* gfxSVGGlyphs::GetGlyphElement(uint32_t aGlyphId) {
|
|
Element* elem;
|
|
|
|
if (!mGlyphIdMap.Get(aGlyphId, &elem)) {
|
|
elem = nullptr;
|
|
if (gfxSVGGlyphsDocument* set = FindOrCreateGlyphsDocument(aGlyphId)) {
|
|
elem = set->GetGlyphElement(aGlyphId);
|
|
}
|
|
mGlyphIdMap.Put(aGlyphId, elem);
|
|
}
|
|
|
|
return elem;
|
|
}
|
|
|
|
bool gfxSVGGlyphs::HasSVGGlyph(uint32_t aGlyphId) {
|
|
return !!GetGlyphElement(aGlyphId);
|
|
}
|
|
|
|
size_t gfxSVGGlyphs::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
|
|
// We don't include the size of mSVGData here, because (depending on the
|
|
// font backend implementation) it will either wrap a block of data owned
|
|
// by the system (and potentially shared), or a table that's in our font
|
|
// table cache and therefore already counted.
|
|
size_t result = aMallocSizeOf(this) +
|
|
mGlyphDocs.ShallowSizeOfExcludingThis(aMallocSizeOf) +
|
|
mGlyphIdMap.ShallowSizeOfExcludingThis(aMallocSizeOf);
|
|
for (auto iter = mGlyphDocs.ConstIter(); !iter.Done(); iter.Next()) {
|
|
result += iter.Data()->SizeOfIncludingThis(aMallocSizeOf);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
Element* gfxSVGGlyphsDocument::GetGlyphElement(uint32_t aGlyphId) {
|
|
return mGlyphIdMap.Get(aGlyphId);
|
|
}
|
|
|
|
gfxSVGGlyphsDocument::gfxSVGGlyphsDocument(const uint8_t* aBuffer,
|
|
uint32_t aBufLen,
|
|
gfxSVGGlyphs* aSVGGlyphs)
|
|
: mOwner(aSVGGlyphs) {
|
|
if (aBufLen >= 14 && aBuffer[0] == 31 && aBuffer[1] == 139) {
|
|
// It's a gzip-compressed document; decompress it before parsing.
|
|
// The original length (modulo 2^32) is found in the last 4 bytes
|
|
// of the data, stored in little-endian format. We read it as
|
|
// individual bytes to avoid possible alignment issues.
|
|
// (Note that if the original length was >2^32, then origLen here
|
|
// will be incorrect; but then the inflate() call will not return
|
|
// Z_STREAM_END and we'll bail out safely.)
|
|
size_t origLen = (size_t(aBuffer[aBufLen - 1]) << 24) +
|
|
(size_t(aBuffer[aBufLen - 2]) << 16) +
|
|
(size_t(aBuffer[aBufLen - 3]) << 8) +
|
|
size_t(aBuffer[aBufLen - 4]);
|
|
AutoTArray<uint8_t, 4096> outBuf;
|
|
if (outBuf.SetLength(origLen, mozilla::fallible)) {
|
|
z_stream s = {0};
|
|
s.next_in = const_cast<Byte*>(aBuffer);
|
|
s.avail_in = aBufLen;
|
|
s.next_out = outBuf.Elements();
|
|
s.avail_out = outBuf.Length();
|
|
// The magic number 16 here is the zlib flag to expect gzip format,
|
|
// see http://www.zlib.net/manual.html#Advanced
|
|
if (Z_OK == inflateInit2(&s, 16 + MAX_WBITS)) {
|
|
int result = inflate(&s, Z_FINISH);
|
|
if (Z_STREAM_END == result) {
|
|
MOZ_ASSERT(size_t(s.next_out - outBuf.Elements()) == origLen);
|
|
ParseDocument(outBuf.Elements(), outBuf.Length());
|
|
} else {
|
|
NS_WARNING("Failed to decompress SVG glyphs document");
|
|
}
|
|
inflateEnd(&s);
|
|
}
|
|
} else {
|
|
NS_WARNING("Failed to allocate memory for SVG glyphs document");
|
|
}
|
|
} else {
|
|
ParseDocument(aBuffer, aBufLen);
|
|
}
|
|
|
|
if (!mDocument) {
|
|
NS_WARNING("Could not parse SVG glyphs document");
|
|
return;
|
|
}
|
|
|
|
Element* root = mDocument->GetRootElement();
|
|
if (!root) {
|
|
NS_WARNING("Could not parse SVG glyphs document");
|
|
return;
|
|
}
|
|
|
|
nsresult rv = SetupPresentation();
|
|
if (NS_FAILED(rv)) {
|
|
NS_WARNING("Couldn't setup presentation for SVG glyphs document");
|
|
return;
|
|
}
|
|
|
|
FindGlyphElements(root);
|
|
}
|
|
|
|
gfxSVGGlyphsDocument::~gfxSVGGlyphsDocument() {
|
|
if (mDocument) {
|
|
mDocument->OnPageHide(false, nullptr);
|
|
}
|
|
if (mPresShell) {
|
|
mPresShell->RemovePostRefreshObserver(this);
|
|
}
|
|
if (mViewer) {
|
|
mViewer->Close(nullptr);
|
|
mViewer->Destroy();
|
|
}
|
|
}
|
|
|
|
static nsresult CreateBufferedStream(const uint8_t* aBuffer, uint32_t aBufLen,
|
|
nsCOMPtr<nsIInputStream>& aResult) {
|
|
nsCOMPtr<nsIInputStream> stream;
|
|
nsresult rv = NS_NewByteInputStream(
|
|
getter_AddRefs(stream),
|
|
MakeSpan(reinterpret_cast<const char*>(aBuffer), aBufLen),
|
|
NS_ASSIGNMENT_DEPEND);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsIInputStream> aBufferedStream;
|
|
if (!NS_InputStreamIsBuffered(stream)) {
|
|
rv = NS_NewBufferedInputStream(getter_AddRefs(aBufferedStream),
|
|
stream.forget(), 4096);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
stream = aBufferedStream;
|
|
}
|
|
|
|
aResult = stream;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult gfxSVGGlyphsDocument::ParseDocument(const uint8_t* aBuffer,
|
|
uint32_t aBufLen) {
|
|
// Mostly pulled from nsDOMParser::ParseFromStream
|
|
|
|
nsCOMPtr<nsIInputStream> stream;
|
|
nsresult rv = CreateBufferedStream(aBuffer, aBufLen, stream);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
mozilla::dom::FontTableURIProtocolHandler::GenerateURIString(
|
|
mSVGGlyphsDocumentURI);
|
|
|
|
rv = NS_NewURI(getter_AddRefs(uri), mSVGGlyphsDocumentURI);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsIPrincipal> principal =
|
|
NullPrincipal::CreateWithoutOriginAttributes();
|
|
|
|
RefPtr<Document> document;
|
|
rv = NS_NewDOMDocument(getter_AddRefs(document),
|
|
EmptyString(), // aNamespaceURI
|
|
EmptyString(), // aQualifiedName
|
|
nullptr, // aDoctype
|
|
uri, uri, principal,
|
|
false, // aLoadedAsData
|
|
nullptr, // aEventObject
|
|
DocumentFlavorSVG);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsIChannel> channel;
|
|
rv = NS_NewInputStreamChannel(
|
|
getter_AddRefs(channel), uri,
|
|
nullptr, // aStream
|
|
principal, nsILoadInfo::SEC_FORCE_INHERIT_PRINCIPAL,
|
|
nsIContentPolicy::TYPE_OTHER, SVG_CONTENT_TYPE, UTF8_CHARSET);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Set this early because various decisions during page-load depend on it.
|
|
document->SetIsBeingUsedAsImage();
|
|
document->SetIsSVGGlyphsDocument();
|
|
document->SetReadyStateInternal(Document::READYSTATE_UNINITIALIZED);
|
|
|
|
nsCOMPtr<nsIStreamListener> listener;
|
|
rv = document->StartDocumentLoad("external-resource", channel,
|
|
nullptr, // aLoadGroup
|
|
nullptr, // aContainer
|
|
getter_AddRefs(listener), true /* aReset */);
|
|
if (NS_FAILED(rv) || !listener) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
rv = listener->OnStartRequest(channel);
|
|
if (NS_FAILED(rv)) {
|
|
channel->Cancel(rv);
|
|
}
|
|
|
|
nsresult status;
|
|
channel->GetStatus(&status);
|
|
if (NS_SUCCEEDED(rv) && NS_SUCCEEDED(status)) {
|
|
rv = listener->OnDataAvailable(channel, stream, 0, aBufLen);
|
|
if (NS_FAILED(rv)) {
|
|
channel->Cancel(rv);
|
|
}
|
|
channel->GetStatus(&status);
|
|
}
|
|
|
|
rv = listener->OnStopRequest(channel, status);
|
|
NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
|
|
|
|
document.swap(mDocument);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void gfxSVGGlyphsDocument::InsertGlyphId(Element* aGlyphElement) {
|
|
nsAutoString glyphIdStr;
|
|
static const uint32_t glyphPrefixLength = 5;
|
|
// The maximum glyph ID is 65535 so the maximum length of the numeric part
|
|
// is 5.
|
|
if (!aGlyphElement->GetAttr(kNameSpaceID_None, nsGkAtoms::id, glyphIdStr) ||
|
|
!StringBeginsWith(glyphIdStr, NS_LITERAL_STRING("glyph")) ||
|
|
glyphIdStr.Length() > glyphPrefixLength + 5) {
|
|
return;
|
|
}
|
|
|
|
uint32_t id = 0;
|
|
for (uint32_t i = glyphPrefixLength; i < glyphIdStr.Length(); ++i) {
|
|
char16_t ch = glyphIdStr.CharAt(i);
|
|
if (ch < '0' || ch > '9') {
|
|
return;
|
|
}
|
|
if (ch == '0' && i == glyphPrefixLength) {
|
|
return;
|
|
}
|
|
id = id * 10 + (ch - '0');
|
|
}
|
|
|
|
mGlyphIdMap.Put(id, aGlyphElement);
|
|
}
|
|
|
|
size_t gfxSVGGlyphsDocument::SizeOfIncludingThis(
|
|
mozilla::MallocSizeOf aMallocSizeOf) const {
|
|
return aMallocSizeOf(this) +
|
|
mGlyphIdMap.ShallowSizeOfExcludingThis(aMallocSizeOf) +
|
|
mSVGGlyphsDocumentURI.SizeOfExcludingThisIfUnshared(aMallocSizeOf);
|
|
}
|