mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-08 14:03:49 +00:00
6779b66f01
They're bad, specially if they do vastly different thing in overloaded functions, like aUseSystemPrincipal and aIsPreload. :) Differential Revision: https://phabricator.services.mozilla.com/D40851 --HG-- extra : moz-landing-system : lando
391 lines
12 KiB
C++
391 lines
12 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/. */
|
|
|
|
/* implementation of interface for managing user and user-agent style sheets */
|
|
|
|
#include "nsStyleSheetService.h"
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "mozilla/PreloadedStyleSheet.h"
|
|
#include "mozilla/PresShell.h"
|
|
#include "mozilla/PresShellInlines.h"
|
|
#include "mozilla/StyleSheet.h"
|
|
#include "mozilla/StyleSheetInlines.h"
|
|
#include "mozilla/Unused.h"
|
|
#include "mozilla/css/Loader.h"
|
|
#include "mozilla/dom/ContentParent.h"
|
|
#include "mozilla/dom/Promise.h"
|
|
#include "mozilla/ipc/URIUtils.h"
|
|
#include "nsIURI.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsICategoryManager.h"
|
|
#include "nsISupportsPrimitives.h"
|
|
#include "nsISimpleEnumerator.h"
|
|
#include "nsNetUtil.h"
|
|
#include "nsIConsoleService.h"
|
|
#include "nsIObserverService.h"
|
|
#include "nsLayoutStatics.h"
|
|
#include "nsLayoutUtils.h"
|
|
|
|
using namespace mozilla;
|
|
|
|
nsStyleSheetService* nsStyleSheetService::gInstance = nullptr;
|
|
|
|
nsStyleSheetService::nsStyleSheetService() {
|
|
static_assert(0 == AGENT_SHEET && 1 == USER_SHEET && 2 == AUTHOR_SHEET,
|
|
"Convention for Style Sheet");
|
|
NS_ASSERTION(!gInstance,
|
|
"Someone is using CreateInstance instead of GetService");
|
|
if (!gInstance) {
|
|
gInstance = this;
|
|
}
|
|
nsLayoutStatics::AddRef();
|
|
}
|
|
|
|
nsStyleSheetService::~nsStyleSheetService() {
|
|
UnregisterWeakMemoryReporter(this);
|
|
|
|
if (gInstance == this) {
|
|
gInstance = nullptr;
|
|
}
|
|
nsLayoutStatics::Release();
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS(nsStyleSheetService, nsIStyleSheetService, nsIMemoryReporter)
|
|
|
|
void nsStyleSheetService::RegisterFromEnumerator(
|
|
nsICategoryManager* aManager, const char* aCategory,
|
|
nsISimpleEnumerator* aEnumerator, uint32_t aSheetType) {
|
|
if (!aEnumerator) return;
|
|
|
|
bool hasMore;
|
|
while (NS_SUCCEEDED(aEnumerator->HasMoreElements(&hasMore)) && hasMore) {
|
|
nsCOMPtr<nsISupports> element;
|
|
if (NS_FAILED(aEnumerator->GetNext(getter_AddRefs(element)))) break;
|
|
|
|
nsCOMPtr<nsISupportsCString> icStr = do_QueryInterface(element);
|
|
NS_ASSERTION(icStr, "category manager entries must be nsISupportsCStrings");
|
|
|
|
nsAutoCString name;
|
|
icStr->GetData(name);
|
|
|
|
nsCString spec;
|
|
aManager->GetCategoryEntry(nsDependentCString(aCategory), name, spec);
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
NS_NewURI(getter_AddRefs(uri), spec);
|
|
if (uri) LoadAndRegisterSheetInternal(uri, aSheetType);
|
|
}
|
|
}
|
|
|
|
static bool SheetHasURI(StyleSheet* aSheet, nsIURI* aSheetURI) {
|
|
MOZ_ASSERT(aSheetURI);
|
|
|
|
bool result;
|
|
nsIURI* uri = aSheet->GetSheetURI();
|
|
return uri && NS_SUCCEEDED(uri->Equals(aSheetURI, &result)) && result;
|
|
}
|
|
|
|
int32_t nsStyleSheetService::FindSheetByURI(uint32_t aSheetType,
|
|
nsIURI* aSheetURI) {
|
|
SheetArray& sheets = mSheets[aSheetType];
|
|
for (int32_t i = sheets.Length() - 1; i >= 0; i--) {
|
|
if (SheetHasURI(sheets[i], aSheetURI)) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
nsresult nsStyleSheetService::Init() {
|
|
// Child processes get their style sheets from the ContentParent.
|
|
if (XRE_IsContentProcess()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// Enumerate all of the style sheet URIs registered in the category
|
|
// manager and load them.
|
|
|
|
nsCOMPtr<nsICategoryManager> catMan =
|
|
do_GetService(NS_CATEGORYMANAGER_CONTRACTID);
|
|
|
|
NS_ENSURE_TRUE(catMan, NS_ERROR_OUT_OF_MEMORY);
|
|
|
|
nsCOMPtr<nsISimpleEnumerator> sheets;
|
|
catMan->EnumerateCategory("agent-style-sheets", getter_AddRefs(sheets));
|
|
RegisterFromEnumerator(catMan, "agent-style-sheets", sheets, AGENT_SHEET);
|
|
|
|
catMan->EnumerateCategory("user-style-sheets", getter_AddRefs(sheets));
|
|
RegisterFromEnumerator(catMan, "user-style-sheets", sheets, USER_SHEET);
|
|
|
|
catMan->EnumerateCategory("author-style-sheets", getter_AddRefs(sheets));
|
|
RegisterFromEnumerator(catMan, "author-style-sheets", sheets, AUTHOR_SHEET);
|
|
|
|
RegisterWeakMemoryReporter(this);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsStyleSheetService::LoadAndRegisterSheet(nsIURI* aSheetURI,
|
|
uint32_t aSheetType) {
|
|
// Warn developers if their stylesheet URL has a #ref at the end.
|
|
// Stylesheet URIs don't benefit from having a #ref suffix -- and if the
|
|
// sheet is a data URI, someone might've created this #ref by accident (and
|
|
// truncated their data-URI stylesheet) by using an unescaped # character in
|
|
// a #RRGGBB color or #foo() ID-selector in their data-URI representation.
|
|
bool hasRef;
|
|
nsresult rv = aSheetURI->GetHasRef(&hasRef);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
if (aSheetURI && hasRef) {
|
|
nsCOMPtr<nsIConsoleService> consoleService =
|
|
do_GetService(NS_CONSOLESERVICE_CONTRACTID);
|
|
NS_WARNING_ASSERTION(consoleService, "Failed to get console service!");
|
|
if (consoleService) {
|
|
const char16_t* message =
|
|
u"nsStyleSheetService::LoadAndRegisterSheet: "
|
|
u"URI contains unescaped hash character, which might be truncating "
|
|
u"the sheet, if it's a data URI.";
|
|
consoleService->LogStringMessage(message);
|
|
}
|
|
}
|
|
|
|
rv = LoadAndRegisterSheetInternal(aSheetURI, aSheetType);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
// Hold on to a copy of the registered PresShells.
|
|
nsTArray<RefPtr<PresShell>> toNotify(mPresShells);
|
|
for (PresShell* presShell : toNotify) {
|
|
StyleSheet* sheet = mSheets[aSheetType].LastElement();
|
|
presShell->NotifyStyleSheetServiceSheetAdded(sheet, aSheetType);
|
|
}
|
|
|
|
if (XRE_IsParentProcess()) {
|
|
nsTArray<dom::ContentParent*> children;
|
|
dom::ContentParent::GetAll(children);
|
|
|
|
if (children.IsEmpty()) {
|
|
return rv;
|
|
}
|
|
|
|
mozilla::ipc::URIParams uri;
|
|
SerializeURI(aSheetURI, uri);
|
|
|
|
for (uint32_t i = 0; i < children.Length(); i++) {
|
|
Unused << children[i]->SendLoadAndRegisterSheet(uri, aSheetType);
|
|
}
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult nsStyleSheetService::LoadAndRegisterSheetInternal(
|
|
nsIURI* aSheetURI, uint32_t aSheetType) {
|
|
NS_ENSURE_ARG_POINTER(aSheetURI);
|
|
|
|
css::SheetParsingMode parsingMode;
|
|
switch (aSheetType) {
|
|
case AGENT_SHEET:
|
|
parsingMode = css::eAgentSheetFeatures;
|
|
break;
|
|
|
|
case USER_SHEET:
|
|
parsingMode = css::eUserSheetFeatures;
|
|
break;
|
|
|
|
case AUTHOR_SHEET:
|
|
parsingMode = css::eAuthorSheetFeatures;
|
|
break;
|
|
|
|
default:
|
|
NS_WARNING("invalid sheet type argument");
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
RefPtr<css::Loader> loader = new css::Loader;
|
|
auto result = loader->LoadSheetSync(aSheetURI, parsingMode,
|
|
css::Loader::UseSystemPrincipal::Yes);
|
|
if (result.isErr()) {
|
|
return result.unwrapErr();
|
|
}
|
|
mSheets[aSheetType].AppendElement(result.unwrap());
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsStyleSheetService::SheetRegistered(nsIURI* sheetURI, uint32_t aSheetType,
|
|
bool* _retval) {
|
|
NS_ENSURE_ARG(aSheetType == AGENT_SHEET || aSheetType == USER_SHEET ||
|
|
aSheetType == AUTHOR_SHEET);
|
|
NS_ENSURE_ARG_POINTER(sheetURI);
|
|
MOZ_ASSERT(_retval, "Null out param");
|
|
|
|
// Check to see if we have the sheet.
|
|
*_retval = (FindSheetByURI(aSheetType, sheetURI) >= 0);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
static nsresult GetParsingMode(uint32_t aSheetType,
|
|
css::SheetParsingMode* aParsingMode) {
|
|
switch (aSheetType) {
|
|
case nsStyleSheetService::AGENT_SHEET:
|
|
*aParsingMode = css::eAgentSheetFeatures;
|
|
return NS_OK;
|
|
|
|
case nsStyleSheetService::USER_SHEET:
|
|
*aParsingMode = css::eUserSheetFeatures;
|
|
return NS_OK;
|
|
|
|
case nsStyleSheetService::AUTHOR_SHEET:
|
|
*aParsingMode = css::eAuthorSheetFeatures;
|
|
return NS_OK;
|
|
|
|
default:
|
|
NS_WARNING("invalid sheet type argument");
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsStyleSheetService::PreloadSheet(nsIURI* aSheetURI, uint32_t aSheetType,
|
|
nsIPreloadedStyleSheet** aSheet) {
|
|
MOZ_ASSERT(aSheet, "Null out param");
|
|
NS_ENSURE_ARG_POINTER(aSheetURI);
|
|
|
|
css::SheetParsingMode parsingMode;
|
|
nsresult rv = GetParsingMode(aSheetType, &parsingMode);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
auto sheet = MakeRefPtr<PreloadedStyleSheet>(aSheetURI, parsingMode);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = sheet->Preload();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
sheet.forget(aSheet);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsStyleSheetService::PreloadSheetAsync(nsIURI* aSheetURI, uint32_t aSheetType,
|
|
JSContext* aCx,
|
|
JS::MutableHandleValue aRval) {
|
|
NS_ENSURE_ARG_POINTER(aSheetURI);
|
|
|
|
css::SheetParsingMode parsingMode;
|
|
nsresult rv = GetParsingMode(aSheetType, &parsingMode);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsIGlobalObject> global = xpc::CurrentNativeGlobal(aCx);
|
|
NS_ENSURE_TRUE(global, NS_ERROR_UNEXPECTED);
|
|
|
|
ErrorResult errv;
|
|
RefPtr<dom::Promise> promise = dom::Promise::Create(global, errv);
|
|
if (errv.Failed()) {
|
|
return errv.StealNSResult();
|
|
}
|
|
|
|
auto sheet = MakeRefPtr<PreloadedStyleSheet>(aSheetURI, parsingMode);
|
|
sheet->PreloadAsync(WrapNotNull(promise));
|
|
|
|
if (!ToJSValue(aCx, promise, aRval)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsStyleSheetService::UnregisterSheet(nsIURI* aSheetURI, uint32_t aSheetType) {
|
|
NS_ENSURE_ARG(aSheetType == AGENT_SHEET || aSheetType == USER_SHEET ||
|
|
aSheetType == AUTHOR_SHEET);
|
|
NS_ENSURE_ARG_POINTER(aSheetURI);
|
|
|
|
RefPtr<StyleSheet> sheet;
|
|
int32_t foundIndex = FindSheetByURI(aSheetType, aSheetURI);
|
|
if (foundIndex >= 0) {
|
|
sheet = mSheets[aSheetType][foundIndex];
|
|
mSheets[aSheetType].RemoveElementAt(foundIndex);
|
|
}
|
|
|
|
// Hold on to a copy of the registered PresShells.
|
|
nsTArray<RefPtr<PresShell>> toNotify(mPresShells);
|
|
for (PresShell* presShell : toNotify) {
|
|
if (presShell->StyleSet()) {
|
|
if (sheet) {
|
|
presShell->NotifyStyleSheetServiceSheetRemoved(sheet, aSheetType);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (XRE_IsParentProcess()) {
|
|
nsTArray<dom::ContentParent*> children;
|
|
dom::ContentParent::GetAll(children);
|
|
|
|
if (children.IsEmpty()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
mozilla::ipc::URIParams uri;
|
|
SerializeURI(aSheetURI, uri);
|
|
|
|
for (uint32_t i = 0; i < children.Length(); i++) {
|
|
Unused << children[i]->SendUnregisterSheet(uri, aSheetType);
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// static
|
|
nsStyleSheetService* nsStyleSheetService::GetInstance() {
|
|
static bool first = true;
|
|
if (first) {
|
|
// make sure at first call that it's inited
|
|
nsCOMPtr<nsIStyleSheetService> dummy =
|
|
do_GetService(NS_STYLESHEETSERVICE_CONTRACTID);
|
|
first = false;
|
|
}
|
|
|
|
return gInstance;
|
|
}
|
|
|
|
MOZ_DEFINE_MALLOC_SIZE_OF(StyleSheetServiceMallocSizeOf)
|
|
|
|
NS_IMETHODIMP
|
|
nsStyleSheetService::CollectReports(nsIHandleReportCallback* aHandleReport,
|
|
nsISupports* aData, bool aAnonymize) {
|
|
MOZ_COLLECT_REPORT(
|
|
"explicit/layout/style-sheet-service", KIND_HEAP, UNITS_BYTES,
|
|
SizeOfIncludingThis(StyleSheetServiceMallocSizeOf),
|
|
"Memory used for style sheets held by the style sheet service.");
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
size_t nsStyleSheetService::SizeOfIncludingThis(
|
|
mozilla::MallocSizeOf aMallocSizeOf) const {
|
|
size_t n = aMallocSizeOf(this);
|
|
for (auto& sheetArray : mSheets) {
|
|
n += sheetArray.ShallowSizeOfExcludingThis(aMallocSizeOf);
|
|
for (StyleSheet* sheet : sheetArray) {
|
|
if (sheet) {
|
|
n += sheet->SizeOfIncludingThis(aMallocSizeOf);
|
|
}
|
|
}
|
|
}
|
|
return n;
|
|
}
|
|
|
|
void nsStyleSheetService::RegisterPresShell(PresShell* aPresShell) {
|
|
MOZ_ASSERT(!mPresShells.Contains(aPresShell));
|
|
mPresShells.AppendElement(aPresShell);
|
|
}
|
|
|
|
void nsStyleSheetService::UnregisterPresShell(PresShell* aPresShell) {
|
|
MOZ_ASSERT(mPresShells.Contains(aPresShell));
|
|
mPresShells.RemoveElement(aPresShell);
|
|
}
|