Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-24 02:35:41 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
34876c4821
gecko-dev/gfx/thebes/gfxSVGGlyphs.cpp
Tom Ritter 449237fc51 Bug 1378552 - Reduce the liklihood of inadvertently misusing NullPrincipal::Create(). r=ckerschb 
NullPrincipal::Create() (will null OA) may cause an OriginAttributes bypass.
We change Create() so OriginAttributes is no longer optional, and rename
Create() with no arguments to make it more explicit about what the caller is doing.

MozReview-Commit-ID: 7DQGlgh1tgJ
2018-03-22 13:36:20 -05:00

463 lines
14 KiB
C++
Raw Blame History

/* 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/SVGContextPaint.h"
#include "nsError.h"
#include "nsIDOMDocument.h"
#include "nsString.h"
#include "nsIDocument.h"
#include "nsICategoryManager.h"
#include "nsIDocumentLoaderFactory.h"
#include "nsIContentViewer.h"
#include "nsIStreamListener.h"
#include "nsServiceManagerUtils.h"
#include "nsIPresShell.h"
#include "nsNetUtil.h"
#include "NullPrincipal.h"
#include "nsIInputStream.h"
#include "nsStringStream.h"
#include "nsStreamUtils.h"
#include "nsIPrincipal.h"
#include "mozilla/BasePrincipal.h"
#include "mozilla/dom/Element.h"
#include "mozilla/LoadInfo.h"
#include "nsSVGUtils.h"
#include "nsHostObjectProtocolHandler.h"
#include "nsContentUtils.h"
#include "gfxFont.h"
#include "nsSMILAnimationController.h"
#include "gfxContext.h"
#include "harfbuzz/hb.h"
#include "mozilla/dom/ImageTracker.h"
#define SVG_CONTENT_TYPE NS_LITERAL_CSTRING("image/svg+xml")
#define UTF8_CHARSET NS_LITERAL_CSTRING("utf-8")
using namespace mozilla;
typedef mozilla::dom::Element Element;
/* static */ const Color SimpleTextContextPaint::sZero = Color();
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", getter_Copies(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));
if (NS_SUCCEEDED(rv)) {
rv = viewer->Open(nullptr, nullptr);
NS_ENSURE_SUCCESS(rv, rv);
}
nsCOMPtr<nsIPresShell> presShell;
rv = viewer->GetPresShell(getter_AddRefs(presShell));
NS_ENSURE_SUCCESS(rv, rv);
if (!presShell->DidInitialize()) {
rv = presShell->Initialize();
NS_ENSURE_SUCCESS(rv, rv);
}
mDocument->FlushPendingNotifications(FlushType::Layout);
if (mDocument->HasAnimationController()) {
mDocument->GetAnimationController()
->Resume(nsSMILTimeContainer::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());
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)
{
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),
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;
nsHostObjectProtocolHandler::GenerateURIString(NS_LITERAL_CSTRING(FONTTABLEURI_SCHEME),
nullptr,
mSVGGlyphsDocumentURI);
rv = NS_NewURI(getter_AddRefs(uri), mSVGGlyphsDocumentURI);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIPrincipal> principal = NullPrincipal::CreateWithoutOriginAttributes();
nsCOMPtr<nsIDOMDocument> domDoc;
rv = NS_NewDOMDocument(getter_AddRefs(domDoc),
EmptyString(), // aNamespaceURI
EmptyString(), // aQualifiedName
nullptr, // aDoctype
uri, uri, principal,
false, // aLoadedAsData
nullptr, // aEventObject
DocumentFlavorSVG);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIDocument> document(do_QueryInterface(domDoc));
if (!document) {
return NS_ERROR_FAILURE;
}
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(nsIDocument::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, nullptr /* aContext */);
if (NS_FAILED(rv)) {
channel->Cancel(rv);
}
nsresult status;
channel->GetStatus(&status);
if (NS_SUCCEEDED(rv) && NS_SUCCEEDED(status)) {
rv = listener->OnDataAvailable(channel, nullptr /* aContext */, stream, 0, aBufLen);
if (NS_FAILED(rv)) {
channel->Cancel(rv);
}
channel->GetStatus(&status);
}
rv = listener->OnStopRequest(channel, nullptr /* aContext */, 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);
}
Reference in New Issue View Git Blame Copy Permalink