--- a/chrome/nsChromeRegistry.cpp
+++ b/chrome/nsChromeRegistry.cpp
@@ -24,24 +24,24 @@
#include "nsIDOMLocation.h"
#include "nsIDOMWindowCollection.h"
#include "nsIDOMWindow.h"
#include "nsIObserverService.h"
#include "nsIPresShell.h"
#include "nsIScriptError.h"
#include "nsIWindowMediator.h"
#include "nsIPrefService.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
nsChromeRegistry* nsChromeRegistry::gChromeRegistry;
// DO NOT use namespace mozilla; it'll break due to a naming conflict between
// mozilla::TextRange and a TextRange in OSX headers.
-using mozilla::StyleSheetHandle;
+using mozilla::StyleSheet;
using mozilla::dom::IsChromeURI;
////////////////////////////////////////////////////////////////////////////////
void
nsChromeRegistry::LogMessage(const char* aMsg, ...)
{
nsCOMPtr<nsIConsoleService> console
@@ -397,27 +397,27 @@ nsresult nsChromeRegistry::RefreshWindow
nsCOMPtr<nsIDocument> document = aWindow->GetDoc();
if (!document)
return NS_OK;
// Deal with the agent sheets first. Have to do all the style sets by hand.
nsCOMPtr<nsIPresShell> shell = document->GetShell();
if (shell) {
// Reload only the chrome URL agent style sheets.
- nsTArray<StyleSheetHandle::RefPtr> agentSheets;
+ nsTArray<RefPtr<StyleSheet>> agentSheets;
rv = shell->GetAgentStyleSheets(agentSheets);
NS_ENSURE_SUCCESS(rv, rv);
- nsTArray<StyleSheetHandle::RefPtr> newAgentSheets;
- for (StyleSheetHandle sheet : agentSheets) {
+ nsTArray<RefPtr<StyleSheet>> newAgentSheets;
+ for (StyleSheet* sheet : agentSheets) {
nsIURI* uri = sheet->GetSheetURI();
if (IsChromeURI(uri)) {
// Reload the sheet.
- StyleSheetHandle::RefPtr newSheet;
+ RefPtr<StyleSheet> newSheet;
rv = document->LoadChromeSheetSync(uri, true, &newSheet);
if (NS_FAILED(rv)) return rv;
if (newSheet) {
rv = newAgentSheets.AppendElement(newSheet) ? NS_OK : NS_ERROR_FAILURE;
if (NS_FAILED(rv)) return rv;
}
}
else { // Just use the same sheet.
@@ -428,36 +428,36 @@ nsresult nsChromeRegistry::RefreshWindow
rv = shell->SetAgentStyleSheets(newAgentSheets);
NS_ENSURE_SUCCESS(rv, rv);
}
int32_t count = document->GetNumberOfStyleSheets();
// Build an array of style sheets we need to reload.
- nsTArray<StyleSheetHandle::RefPtr> oldSheets(count);
- nsTArray<StyleSheetHandle::RefPtr> newSheets(count);
+ nsTArray<RefPtr<StyleSheet>> oldSheets(count);
+ nsTArray<RefPtr<StyleSheet>> newSheets(count);
// Iterate over the style sheets.
for (int32_t i = 0; i < count; i++) {
// Get the style sheet
- StyleSheetHandle styleSheet = document->GetStyleSheetAt(i);
+ StyleSheet* styleSheet = document->GetStyleSheetAt(i);
oldSheets.AppendElement(styleSheet);
}
// Iterate over our old sheets and kick off a sync load of the new
// sheet if and only if it's a non-inline sheet with a chrome URL.
- for (StyleSheetHandle sheet : oldSheets) {
+ for (StyleSheet* sheet : oldSheets) {
MOZ_ASSERT(sheet, "GetStyleSheetAt shouldn't return nullptr for "
"in-range sheet indexes");
nsIURI* uri = sheet->GetSheetURI();
if (!sheet->IsInline() && IsChromeURI(uri)) {
// Reload the sheet.
- StyleSheetHandle::RefPtr newSheet;
+ RefPtr<StyleSheet> newSheet;
// XXX what about chrome sheets that have a title or are disabled? This
// only works by sheer dumb luck.
document->LoadChromeSheetSync(uri, false, &newSheet);
// Even if it's null, we put in in there.
newSheets.AppendElement(newSheet);
} else {
// Just use the same sheet.
newSheets.AppendElement(sheet);
--- a/dom/base/ShadowRoot.cpp
+++ b/dom/base/ShadowRoot.cpp
@@ -12,18 +12,18 @@
#include "nsContentUtils.h"
#include "nsDOMClassInfoID.h"
#include "nsIDOMHTMLElement.h"
#include "nsIStyleSheetLinkingElement.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/HTMLContentElement.h"
#include "mozilla/dom/HTMLShadowElement.h"
#include "nsXBLPrototypeBinding.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
using namespace mozilla;
using namespace mozilla::dom;
NS_IMPL_CYCLE_COLLECTION_CLASS(ShadowRoot)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(ShadowRoot,
DocumentFragment)
@@ -127,17 +127,17 @@ ShadowRoot::StyleSheetChanged()
if (shell) {
OwnerDoc()->BeginUpdate(UPDATE_STYLE);
shell->RecordShadowStyleChange(this);
OwnerDoc()->EndUpdate(UPDATE_STYLE);
}
}
void
-ShadowRoot::InsertSheet(StyleSheetHandle aSheet,
+ShadowRoot::InsertSheet(StyleSheet* aSheet,
nsIContent* aLinkingContent)
{
nsCOMPtr<nsIStyleSheetLinkingElement>
linkingElement = do_QueryInterface(aLinkingContent);
MOZ_ASSERT(linkingElement, "The only styles in a ShadowRoot should come "
"from <style>.");
linkingElement->SetStyleSheet(aSheet); // This sets the ownerNode on the sheet
@@ -158,17 +158,17 @@ ShadowRoot::InsertSheet(StyleSheetHandle
}
if (aSheet->IsApplicable()) {
StyleSheetChanged();
}
}
void
-ShadowRoot::RemoveSheet(StyleSheetHandle aSheet)
+ShadowRoot::RemoveSheet(StyleSheet* aSheet)
{
mProtoBinding->RemoveStyleSheet(aSheet);
if (aSheet->IsApplicable()) {
StyleSheetChanged();
}
}
@@ -751,17 +751,17 @@ ShadowRootStyleSheetList::IndexedGetter(
aFound = aIndex < mShadowRoot->mProtoBinding->SheetCount();
if (!aFound) {
return nullptr;
}
// XXXheycam Return null until ServoStyleSheet implements the right
// DOM interfaces.
- StyleSheetHandle sheet = mShadowRoot->mProtoBinding->StyleSheetAt(aIndex);
+ StyleSheet* sheet = mShadowRoot->mProtoBinding->StyleSheetAt(aIndex);
if (sheet->IsServo()) {
NS_ERROR("stylo: can't return ServoStyleSheets to script yet");
return nullptr;
}
return sheet->AsGecko();
}
uint32_t
--- a/dom/base/ShadowRoot.h
+++ b/dom/base/ShadowRoot.h
@@ -4,17 +4,17 @@
* 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/. */
#ifndef mozilla_dom_shadowroot_h__
#define mozilla_dom_shadowroot_h__
#include "mozilla/dom/DocumentFragment.h"
#include "mozilla/dom/StyleSheetList.h"
-#include "mozilla/StyleSheetHandle.h"
+#include "mozilla/StyleSheet.h"
#include "nsCOMPtr.h"
#include "nsCycleCollectionParticipant.h"
#include "nsIContentInlines.h"
#include "nsTHashtable.h"
#include "nsDocument.h"
class nsIAtom;
class nsIContent;
@@ -42,18 +42,18 @@ public:
NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
ShadowRoot(nsIContent* aContent, already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,
nsXBLPrototypeBinding* aProtoBinding);
void AddToIdTable(Element* aElement, nsIAtom* aId);
void RemoveFromIdTable(Element* aElement, nsIAtom* aId);
- void InsertSheet(StyleSheetHandle aSheet, nsIContent* aLinkingContent);
- void RemoveSheet(StyleSheetHandle aSheet);
+ void InsertSheet(StyleSheet* aSheet, nsIContent* aLinkingContent);
+ void RemoveSheet(StyleSheet* aSheet);
bool ApplyAuthorStyles();
void SetApplyAuthorStyles(bool aApplyAuthorStyles);
StyleSheetList* StyleSheets();
HTMLShadowElement* GetShadowElement() { return mShadowElement; }
/**
* Sets the current shadow insertion point where the older
* ShadowRoot will be projected.
--- a/dom/base/nsContentSink.cpp
+++ b/dom/base/nsContentSink.cpp
@@ -202,17 +202,17 @@ nsContentSink::Init(nsIDocument* aDoc,
mDynamicLowerValue = sEnablePerfMode == 1;
FavorPerformanceHint(!mDynamicLowerValue, 0);
}
return NS_OK;
}
NS_IMETHODIMP
-nsContentSink::StyleSheetLoaded(StyleSheetHandle aSheet,
+nsContentSink::StyleSheetLoaded(StyleSheet* aSheet,
bool aWasAlternate,
nsresult aStatus)
{
NS_ASSERTION(!mRunsToCompletion, "How come a fragment parser observed sheets?");
if (!aWasAlternate) {
NS_ASSERTION(mPendingSheetCount > 0, "How'd that happen?");
--mPendingSheetCount;
--- a/dom/base/nsContentSink.h
+++ b/dom/base/nsContentSink.h
@@ -80,17 +80,17 @@ class nsContentSink : public nsICSSLoade
{
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsContentSink,
nsICSSLoaderObserver)
// nsITimerCallback
NS_DECL_NSITIMERCALLBACK
// nsICSSLoaderObserver
- NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheetHandle aSheet,
+ NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheet* aSheet,
bool aWasAlternate,
nsresult aStatus) override;
virtual nsresult ProcessMETATag(nsIContent* aContent);
// nsIContentSink implementation helpers
nsresult WillParseImpl(void);
nsresult WillInterruptImpl(void);
--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -245,18 +245,18 @@
#include "nsWindowMemoryReporter.h"
#include "mozilla/dom/Location.h"
#include "mozilla/dom/FontFaceSet.h"
#include "mozilla/dom/BoxObject.h"
#include "gfxPrefs.h"
#include "nsISupportsPrimitives.h"
#include "mozilla/StyleSetHandle.h"
#include "mozilla/StyleSetHandleInlines.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
#include "mozilla/DocLoadingTimelineMarker.h"
#include "nsISpeculativeConnect.h"
#include "mozilla/MediaManager.h"
#ifdef MOZ_WEBRTC
#include "IPeerConnection.h"
@@ -595,17 +595,17 @@ CSSStyleSheet*
nsDOMStyleSheetList::IndexedGetter(uint32_t aIndex, bool& aFound)
{
if (!mDocument || aIndex >= (uint32_t)mDocument->GetNumberOfStyleSheets()) {
aFound = false;
return nullptr;
}
aFound = true;
- StyleSheetHandle sheet = mDocument->GetStyleSheetAt(aIndex);
+ StyleSheet* sheet = mDocument->GetStyleSheetAt(aIndex);
NS_ASSERTION(sheet, "Must have a sheet");
// XXXheycam Return null until ServoStyleSheet implements the right DOM
// interfaces.
if (sheet->IsServo()) {
NS_ERROR("stylo: can't return a ServoStyleSheet to the DOM yet");
return nullptr;
}
@@ -614,26 +614,26 @@ nsDOMStyleSheetList::IndexedGetter(uint3
void
nsDOMStyleSheetList::NodeWillBeDestroyed(const nsINode *aNode)
{
mDocument = nullptr;
}
void
-nsDOMStyleSheetList::StyleSheetAdded(StyleSheetHandle aStyleSheet,
+nsDOMStyleSheetList::StyleSheetAdded(StyleSheet* aStyleSheet,
bool aDocumentSheet)
{
if (aDocumentSheet && -1 != mLength) {
mLength++;
}
}
void
-nsDOMStyleSheetList::StyleSheetRemoved(StyleSheetHandle aStyleSheet,
+nsDOMStyleSheetList::StyleSheetRemoved(StyleSheet* aStyleSheet,
bool aDocumentSheet)
{
if (aDocumentSheet && -1 != mLength) {
mLength--;
}
}
// nsOnloadBlocker implementation
@@ -1191,17 +1191,17 @@ nsDOMStyleSheetSetList::EnsureFresh()
if (!mDocument) {
return; // Spec says "no exceptions", and we have no style sets if we have
// no document, for sure
}
int32_t count = mDocument->GetNumberOfStyleSheets();
nsAutoString title;
for (int32_t index = 0; index < count; index++) {
- StyleSheetHandle sheet = mDocument->GetStyleSheetAt(index);
+ StyleSheet* sheet = mDocument->GetStyleSheetAt(index);
NS_ASSERTION(sheet, "Null sheet in sheet list!");
// XXXheycam ServoStyleSheets don't expose their title yet.
if (sheet->IsServo()) {
NS_ERROR("stylo: ServoStyleSets don't expose their title yet");
continue;
}
sheet->AsGecko()->GetTitle(title);
if (!title.IsEmpty() && !mNames.Contains(title) && !Add(title)) {
@@ -1492,17 +1492,17 @@ nsDocument::~nsDocument()
for (uint32_t indx = mChildren.ChildCount(); indx-- != 0; ) {
mChildren.ChildAt(indx)->UnbindFromTree();
mChildren.RemoveChildAt(indx);
}
mFirstChild = nullptr;
mCachedRootElement = nullptr;
// Let the stylesheets know we're going away
- for (StyleSheetHandle sheet : mStyleSheets) {
+ for (StyleSheet* sheet : mStyleSheets) {
sheet->SetOwningDocument(nullptr);
}
if (mAttrStyleSheet) {
mAttrStyleSheet->SetOwningDocument(nullptr);
}
// We don't own the mOnDemandBuiltInUASheets, so we don't need to reset them.
if (mListenerManager) {
@@ -2148,36 +2148,36 @@ nsDocument::ResetToURI(nsIURI *aURI, nsI
nsGlobalWindow::Cast(win)->RefreshCompartmentPrincipal();
}
}
void
nsDocument::RemoveDocStyleSheetsFromStyleSets()
{
// The stylesheets should forget us
- for (StyleSheetHandle sheet : Reversed(mStyleSheets)) {
+ for (StyleSheet* sheet : Reversed(mStyleSheets)) {
sheet->SetOwningDocument(nullptr);
if (sheet->IsApplicable()) {
nsCOMPtr<nsIPresShell> shell = GetShell();
if (shell) {
shell->StyleSet()->RemoveDocStyleSheet(sheet);
}
}
// XXX Tell observers?
}
}
void
nsDocument::RemoveStyleSheetsFromStyleSets(
- const nsTArray<StyleSheetHandle::RefPtr>& aSheets,
+ const nsTArray<RefPtr<StyleSheet>>& aSheets,
SheetType aType)
{
// The stylesheets should forget us
- for (StyleSheetHandle sheet : Reversed(aSheets)) {
+ for (StyleSheet* sheet : Reversed(aSheets)) {
sheet->SetOwningDocument(nullptr);
if (sheet->IsApplicable()) {
nsCOMPtr<nsIPresShell> shell = GetShell();
if (shell) {
shell->StyleSet()->RemoveStyleSheet(aType, sheet);
}
}
@@ -2245,50 +2245,50 @@ nsDocument::ResetStylesheetsToURI(nsIURI
nsCOMPtr<nsIPresShell> shell = GetShell();
if (shell) {
FillStyleSet(shell->StyleSet());
}
}
static void
AppendSheetsToStyleSet(StyleSetHandle aStyleSet,
- const nsTArray<StyleSheetHandle::RefPtr>& aSheets,
+ const nsTArray<RefPtr<StyleSheet>>& aSheets,
SheetType aType)
{
- for (StyleSheetHandle sheet : Reversed(aSheets)) {
+ for (StyleSheet* sheet : Reversed(aSheets)) {
aStyleSet->AppendStyleSheet(aType, sheet);
}
}
void
nsDocument::FillStyleSet(StyleSetHandle aStyleSet)
{
NS_PRECONDITION(aStyleSet, "Must have a style set");
NS_PRECONDITION(aStyleSet->SheetCount(SheetType::Doc) == 0,
"Style set already has document sheets?");
MOZ_ASSERT(!mStyleSetFilled);
- for (StyleSheetHandle sheet : Reversed(mStyleSheets)) {
+ for (StyleSheet* sheet : Reversed(mStyleSheets)) {
if (sheet->IsApplicable()) {
aStyleSet->AddDocStyleSheet(sheet, this);
}
}
if (aStyleSet->IsGecko()) {
nsStyleSheetService *sheetService = nsStyleSheetService::GetInstance();
if (sheetService) {
- for (StyleSheetHandle sheet : *sheetService->AuthorStyleSheets()) {
+ for (StyleSheet* sheet : *sheetService->AuthorStyleSheets()) {
aStyleSet->AppendStyleSheet(SheetType::Doc, sheet);
}
}
// Iterate backwards to maintain order
- for (StyleSheetHandle sheet : Reversed(mOnDemandBuiltInUASheets)) {
+ for (StyleSheet* sheet : Reversed(mOnDemandBuiltInUASheets)) {
if (sheet->IsApplicable()) {
aStyleSet->PrependStyleSheet(SheetType::Agent, sheet);
}
}
} else {
NS_WARNING("stylo: Not yet checking nsStyleSheetService for Servo-backed "
"documents. See bug 1290224");
}
@@ -3934,28 +3934,28 @@ nsDocument::RemoveChildAt(uint32_t aInde
DestroyElementMaps();
}
doRemoveChildAt(aIndex, aNotify, oldKid, mChildren);
mCachedRootElement = nullptr;
}
void
-nsDocument::EnsureOnDemandBuiltInUASheet(StyleSheetHandle aSheet)
+nsDocument::EnsureOnDemandBuiltInUASheet(StyleSheet* aSheet)
{
if (mOnDemandBuiltInUASheets.Contains(aSheet)) {
return;
}
BeginUpdate(UPDATE_STYLE);
AddOnDemandBuiltInUASheet(aSheet);
EndUpdate(UPDATE_STYLE);
}
void
-nsDocument::AddOnDemandBuiltInUASheet(StyleSheetHandle aSheet)
+nsDocument::AddOnDemandBuiltInUASheet(StyleSheet* aSheet)
{
MOZ_ASSERT(!mOnDemandBuiltInUASheets.Contains(aSheet));
// Prepend here so that we store the sheets in mOnDemandBuiltInUASheets in
// the same order that they should end up in the style set.
mOnDemandBuiltInUASheets.InsertElementAt(0, aSheet);
if (aSheet->IsApplicable()) {
@@ -3974,30 +3974,30 @@ nsDocument::AddOnDemandBuiltInUASheet(St
}
int32_t
nsDocument::GetNumberOfStyleSheets() const
{
return mStyleSheets.Length();
}
-StyleSheetHandle
+StyleSheet*
nsDocument::GetStyleSheetAt(int32_t aIndex) const
{
- return mStyleSheets.SafeElementAt(aIndex, StyleSheetHandle());
+ return mStyleSheets.SafeElementAt(aIndex, nullptr);
}
int32_t
-nsDocument::GetIndexOfStyleSheet(const StyleSheetHandle aSheet) const
+nsDocument::GetIndexOfStyleSheet(const StyleSheet* aSheet) const
{
return mStyleSheets.IndexOf(aSheet);
}
void
-nsDocument::AddStyleSheetToStyleSets(StyleSheetHandle aSheet)
+nsDocument::AddStyleSheetToStyleSets(StyleSheet* aSheet)
{
nsCOMPtr<nsIPresShell> shell = GetShell();
if (shell) {
shell->StyleSet()->AddDocStyleSheet(aSheet, this);
}
}
#define DO_STYLESHEET_NOTIFICATION(className, type, memberName, argName) \
@@ -4018,69 +4018,69 @@ nsDocument::AddStyleSheetToStyleSets(Sty
event->SetTarget(this); \
RefPtr<AsyncEventDispatcher> asyncDispatcher = \
new AsyncEventDispatcher(this, event); \
asyncDispatcher->mOnlyChromeDispatch = true; \
asyncDispatcher->PostDOMEvent(); \
} while (0);
void
-nsDocument::NotifyStyleSheetAdded(StyleSheetHandle aSheet, bool aDocumentSheet)
+nsDocument::NotifyStyleSheetAdded(StyleSheet* aSheet, bool aDocumentSheet)
{
NS_DOCUMENT_NOTIFY_OBSERVERS(StyleSheetAdded, (aSheet, aDocumentSheet));
if (StyleSheetChangeEventsEnabled()) {
DO_STYLESHEET_NOTIFICATION(StyleSheetChangeEvent,
"StyleSheetAdded",
mDocumentSheet,
aDocumentSheet);
}
}
void
-nsDocument::NotifyStyleSheetRemoved(StyleSheetHandle aSheet, bool aDocumentSheet)
+nsDocument::NotifyStyleSheetRemoved(StyleSheet* aSheet, bool aDocumentSheet)
{
NS_DOCUMENT_NOTIFY_OBSERVERS(StyleSheetRemoved, (aSheet, aDocumentSheet));
if (StyleSheetChangeEventsEnabled()) {
DO_STYLESHEET_NOTIFICATION(StyleSheetChangeEvent,
"StyleSheetRemoved",
mDocumentSheet,
aDocumentSheet);
}
}
void
-nsDocument::AddStyleSheet(StyleSheetHandle aSheet)
+nsDocument::AddStyleSheet(StyleSheet* aSheet)
{
NS_PRECONDITION(aSheet, "null arg");
mStyleSheets.AppendElement(aSheet);
aSheet->SetOwningDocument(this);
if (aSheet->IsApplicable()) {
AddStyleSheetToStyleSets(aSheet);
}
NotifyStyleSheetAdded(aSheet, true);
}
void
-nsDocument::RemoveStyleSheetFromStyleSets(StyleSheetHandle aSheet)
+nsDocument::RemoveStyleSheetFromStyleSets(StyleSheet* aSheet)
{
nsCOMPtr<nsIPresShell> shell = GetShell();
if (shell) {
shell->StyleSet()->RemoveDocStyleSheet(aSheet);
}
}
void
-nsDocument::RemoveStyleSheet(StyleSheetHandle aSheet)
+nsDocument::RemoveStyleSheet(StyleSheet* aSheet)
{
NS_PRECONDITION(aSheet, "null arg");
- StyleSheetHandle::RefPtr sheet = aSheet; // hold ref so it won't die too soon
+ RefPtr<StyleSheet> sheet = aSheet; // hold ref so it won't die too soon
if (!mStyleSheets.RemoveElement(aSheet)) {
NS_ASSERTION(mInUnlinkOrDeletion, "stylesheet not found");
return;
}
if (!mIsGoingAway) {
if (aSheet->IsApplicable()) {
@@ -4089,71 +4089,71 @@ nsDocument::RemoveStyleSheet(StyleSheetH
NotifyStyleSheetRemoved(aSheet, true);
}
aSheet->SetOwningDocument(nullptr);
}
void
-nsDocument::UpdateStyleSheets(nsTArray<StyleSheetHandle::RefPtr>& aOldSheets,
- nsTArray<StyleSheetHandle::RefPtr>& aNewSheets)
+nsDocument::UpdateStyleSheets(nsTArray<RefPtr<StyleSheet>>& aOldSheets,
+ nsTArray<RefPtr<StyleSheet>>& aNewSheets)
{
BeginUpdate(UPDATE_STYLE);
// XXX Need to set the sheet on the ownernode, if any
NS_PRECONDITION(aOldSheets.Length() == aNewSheets.Length(),
"The lists must be the same length!");
int32_t count = aOldSheets.Length();
- StyleSheetHandle::RefPtr oldSheet;
+ RefPtr<StyleSheet> oldSheet;
int32_t i;
for (i = 0; i < count; ++i) {
oldSheet = aOldSheets[i];
// First remove the old sheet.
NS_ASSERTION(oldSheet, "None of the old sheets should be null");
int32_t oldIndex = mStyleSheets.IndexOf(oldSheet);
RemoveStyleSheet(oldSheet); // This does the right notifications
// Now put the new one in its place. If it's null, just ignore it.
- StyleSheetHandle newSheet = aNewSheets[i];
+ StyleSheet* newSheet = aNewSheets[i];
if (newSheet) {
mStyleSheets.InsertElementAt(oldIndex, newSheet);
newSheet->SetOwningDocument(this);
if (newSheet->IsApplicable()) {
AddStyleSheetToStyleSets(newSheet);
}
NotifyStyleSheetAdded(newSheet, true);
}
}
EndUpdate(UPDATE_STYLE);
}
void
-nsDocument::InsertStyleSheetAt(StyleSheetHandle aSheet, int32_t aIndex)
+nsDocument::InsertStyleSheetAt(StyleSheet* aSheet, int32_t aIndex)
{
NS_PRECONDITION(aSheet, "null ptr");
mStyleSheets.InsertElementAt(aIndex, aSheet);
aSheet->SetOwningDocument(this);
if (aSheet->IsApplicable()) {
AddStyleSheetToStyleSets(aSheet);
}
NotifyStyleSheetAdded(aSheet, true);
}
void
-nsDocument::SetStyleSheetApplicableState(StyleSheetHandle aSheet,
+nsDocument::SetStyleSheetApplicableState(StyleSheet* aSheet,
bool aApplicable)
{
NS_PRECONDITION(aSheet, "null arg");
// If we're actually in the document style sheet list
if (mStyleSheets.IndexOf(aSheet) != mStyleSheets.NoIndex) {
if (aApplicable) {
AddStyleSheetToStyleSets(aSheet);
@@ -4209,17 +4209,17 @@ ConvertAdditionalSheetType(nsIDocument::
default:
MOZ_ASSERT(false, "wrong type");
// we must return something although this should never happen
return SheetType::Count;
}
}
static int32_t
-FindSheet(const nsTArray<StyleSheetHandle::RefPtr>& aSheets, nsIURI* aSheetURI)
+FindSheet(const nsTArray<RefPtr<StyleSheet>>& aSheets, nsIURI* aSheetURI)
{
for (int32_t i = aSheets.Length() - 1; i >= 0; i-- ) {
bool bEqual;
nsIURI* uri = aSheets[i]->GetSheetURI();
if (uri && NS_SUCCEEDED(uri->Equals(aSheetURI, &bEqual)) && bEqual)
return i;
}
@@ -4253,28 +4253,28 @@ nsDocument::LoadAdditionalStyleSheet(add
case nsIDocument::eAuthorSheet:
parsingMode = css::eAuthorSheetFeatures;
break;
default:
MOZ_CRASH("impossible value for aType");
}
- StyleSheetHandle::RefPtr sheet;
+ RefPtr<StyleSheet> sheet;
nsresult rv = loader->LoadSheetSync(aSheetURI, parsingMode, true, &sheet);
NS_ENSURE_SUCCESS(rv, rv);
sheet->SetOwningDocument(this);
MOZ_ASSERT(sheet->IsApplicable());
return AddAdditionalStyleSheet(aType, sheet);
}
nsresult
-nsDocument::AddAdditionalStyleSheet(additionalSheetType aType, StyleSheetHandle aSheet)
+nsDocument::AddAdditionalStyleSheet(additionalSheetType aType, StyleSheet* aSheet)
{
if (mAdditionalSheets[aType].Contains(aSheet))
return NS_ERROR_INVALID_ARG;
if (!aSheet->IsApplicable())
return NS_ERROR_INVALID_ARG;
mAdditionalSheets[aType].AppendElement(aSheet);
@@ -4293,21 +4293,21 @@ nsDocument::AddAdditionalStyleSheet(addi
return NS_OK;
}
void
nsDocument::RemoveAdditionalStyleSheet(additionalSheetType aType, nsIURI* aSheetURI)
{
MOZ_ASSERT(aSheetURI);
- nsTArray<StyleSheetHandle::RefPtr>& sheets = mAdditionalSheets[aType];
+ nsTArray<RefPtr<StyleSheet>>& sheets = mAdditionalSheets[aType];
int32_t i = FindSheet(mAdditionalSheets[aType], aSheetURI);
if (i >= 0) {
- StyleSheetHandle::RefPtr sheetRef = sheets[i];
+ RefPtr<StyleSheet> sheetRef = sheets[i];
sheets.RemoveElementAt(i);
BeginUpdate(UPDATE_STYLE);
if (!mIsGoingAway) {
MOZ_ASSERT(sheetRef->IsApplicable());
nsCOMPtr<nsIPresShell> shell = GetShell();
if (shell) {
SheetType type = ConvertAdditionalSheetType(aType);
@@ -4319,20 +4319,20 @@ nsDocument::RemoveAdditionalStyleSheet(a
// these additional sheets.
NotifyStyleSheetRemoved(sheetRef, false);
EndUpdate(UPDATE_STYLE);
sheetRef->SetOwningDocument(nullptr);
}
}
-StyleSheetHandle
+StyleSheet*
nsDocument::GetFirstAdditionalAuthorSheet()
{
- return mAdditionalSheets[eAuthorSheet].SafeElementAt(0, StyleSheetHandle());
+ return mAdditionalSheets[eAuthorSheet].SafeElementAt(0, nullptr);
}
nsIGlobalObject*
nsDocument::GetScopeObject() const
{
nsCOMPtr<nsIGlobalObject> scope(do_QueryReferent(mScopeObject));
return scope;
}
@@ -5127,46 +5127,46 @@ nsDocument::DocumentStatesChanged(EventS
// Invalidate our cached state.
mGotDocumentState &= ~aStateMask;
mDocumentState &= ~aStateMask;
NS_DOCUMENT_NOTIFY_OBSERVERS(DocumentStatesChanged, (this, aStateMask));
}
void
-nsDocument::StyleRuleChanged(StyleSheetHandle aSheet,
+nsDocument::StyleRuleChanged(StyleSheet* aSheet,
css::Rule* aStyleRule)
{
NS_DOCUMENT_NOTIFY_OBSERVERS(StyleRuleChanged, (aSheet));
if (StyleSheetChangeEventsEnabled()) {
DO_STYLESHEET_NOTIFICATION(StyleRuleChangeEvent,
"StyleRuleChanged",
mRule,
aStyleRule ? aStyleRule->GetDOMRule() : nullptr);
}
}
void
-nsDocument::StyleRuleAdded(StyleSheetHandle aSheet,
+nsDocument::StyleRuleAdded(StyleSheet* aSheet,
css::Rule* aStyleRule)
{
NS_DOCUMENT_NOTIFY_OBSERVERS(StyleRuleAdded, (aSheet));
if (StyleSheetChangeEventsEnabled()) {
DO_STYLESHEET_NOTIFICATION(StyleRuleChangeEvent,
"StyleRuleAdded",
mRule,
aStyleRule ? aStyleRule->GetDOMRule()
: nullptr);
}
}
void
-nsDocument::StyleRuleRemoved(StyleSheetHandle aSheet,
+nsDocument::StyleRuleRemoved(StyleSheet* aSheet,
css::Rule* aStyleRule)
{
NS_DOCUMENT_NOTIFY_OBSERVERS(StyleRuleRemoved, (aSheet));
if (StyleSheetChangeEventsEnabled()) {
DO_STYLESHEET_NOTIFICATION(StyleRuleChangeEvent,
"StyleRuleRemoved",
mRule,
@@ -6024,17 +6024,17 @@ void
nsIDocument::GetSelectedStyleSheetSet(nsAString& aSheetSet)
{
aSheetSet.Truncate();
// Look through our sheets, find the selected set title
int32_t count = GetNumberOfStyleSheets();
nsAutoString title;
for (int32_t index = 0; index < count; index++) {
- StyleSheetHandle sheet = GetStyleSheetAt(index);
+ StyleSheet* sheet = GetStyleSheetAt(index);
NS_ASSERTION(sheet, "Null sheet in sheet list!");
// XXXheycam Make this work with ServoStyleSheets.
if (sheet->IsServo()) {
NS_ERROR("stylo: can't handle alternate ServoStyleSheets yet");
continue;
}
@@ -6144,17 +6144,17 @@ nsDocument::EnableStyleSheetsForSet(cons
void
nsDocument::EnableStyleSheetsForSetInternal(const nsAString& aSheetSet,
bool aUpdateCSSLoader)
{
BeginUpdate(UPDATE_STYLE);
int32_t count = GetNumberOfStyleSheets();
nsAutoString title;
for (int32_t index = 0; index < count; index++) {
- StyleSheetHandle sheet = GetStyleSheetAt(index);
+ StyleSheet* sheet = GetStyleSheetAt(index);
NS_ASSERTION(sheet, "Null sheet in sheet list!");
// XXXheycam Make this work with ServoStyleSheets.
if (sheet->IsServo()) {
NS_ERROR("stylo: can't handle alternate ServoStyleSheets yet");
continue;
}
@@ -9423,17 +9423,17 @@ namespace {
/**
* Stub for LoadSheet(), since all we want is to get the sheet into
* the CSSLoader's style cache
*/
class StubCSSLoaderObserver final : public nsICSSLoaderObserver {
~StubCSSLoaderObserver() {}
public:
NS_IMETHOD
- StyleSheetLoaded(StyleSheetHandle, bool, nsresult) override
+ StyleSheetLoaded(StyleSheet*, bool, nsresult) override
{
return NS_OK;
}
NS_DECL_ISUPPORTS
};
NS_IMPL_ISUPPORTS(StubCSSLoaderObserver, nsICSSLoaderObserver)
} // namespace
@@ -9452,17 +9452,17 @@ nsDocument::PreloadStyle(nsIURI* uri, co
NS_LossyConvertUTF16toASCII(charset),
obs,
Element::StringToCORSMode(aCrossOriginAttr),
aReferrerPolicy, aIntegrity);
}
nsresult
nsDocument::LoadChromeSheetSync(nsIURI* uri, bool isAgentSheet,
- mozilla::StyleSheetHandle::RefPtr* aSheet)
+ RefPtr<mozilla::StyleSheet>* aSheet)
{
css::SheetParsingMode mode =
isAgentSheet ? css::eAgentSheetFeatures
: css::eAuthorSheetFeatures;
return CSSLoader()->LoadSheetSync(uri, mode, isAgentSheet, aSheet);
}
class nsDelayedEventDispatcher : public Runnable
@@ -9788,17 +9788,17 @@ nsIDocument::CreateStaticClone(nsIDocShe
} else {
clonedDoc->mOriginalDocument = this;
}
clonedDoc->mOriginalDocument->mStaticCloneCount++;
int32_t sheetsCount = GetNumberOfStyleSheets();
for (int32_t i = 0; i < sheetsCount; ++i) {
- StyleSheetHandle::RefPtr sheet = GetStyleSheetAt(i);
+ RefPtr<StyleSheet> sheet = GetStyleSheetAt(i);
if (sheet) {
if (sheet->IsApplicable()) {
// XXXheycam Need to make ServoStyleSheet cloning work.
if (sheet->IsGecko()) {
RefPtr<CSSStyleSheet> clonedSheet =
sheet->AsGecko()->Clone(nullptr, nullptr, clonedDoc, nullptr);
NS_WARNING_ASSERTION(clonedSheet,
"Cloning a stylesheet didn't work!");
@@ -9808,17 +9808,17 @@ nsIDocument::CreateStaticClone(nsIDocShe
} else {
NS_ERROR("stylo: ServoStyleSheet doesn't support cloning");
}
}
}
}
// Iterate backwards to maintain order
- for (StyleSheetHandle sheet : Reversed(thisAsDoc->mOnDemandBuiltInUASheets)) {
+ for (StyleSheet* sheet : Reversed(thisAsDoc->mOnDemandBuiltInUASheets)) {
if (sheet) {
if (sheet->IsApplicable()) {
// XXXheycam Need to make ServoStyleSheet cloning work.
if (sheet->IsGecko()) {
RefPtr<CSSStyleSheet> clonedSheet =
sheet->AsGecko()->Clone(nullptr, nullptr, clonedDoc, nullptr);
NS_WARNING_ASSERTION(clonedSheet,
"Cloning a stylesheet didn't work!");
@@ -12000,17 +12000,17 @@ nsDocument::OnAppThemeChanged()
{
// Bail out if there is no theme support set up properly.
auto themeOrigin = Preferences::GetString("b2g.theme.origin");
if (!themeOrigin || !Preferences::GetBool("dom.mozApps.themable")) {
return;
}
for (int32_t i = 0; i < GetNumberOfStyleSheets(); i++) {
- StyleSheetHandle::RefPtr sheet = GetStyleSheetAt(i);
+ RefPtr<StyleSheet> sheet = GetStyleSheetAt(i);
if (!sheet) {
continue;
}
nsINode* owningNode = sheet->GetOwnerNode();
if (!owningNode) {
continue;
}
@@ -12155,22 +12155,22 @@ nsIDocument::DocAddSizeOfExcludingThis(n
void
nsIDocument::DocAddSizeOfIncludingThis(nsWindowSizes* aWindowSizes) const
{
aWindowSizes->mDOMOtherSize += aWindowSizes->mMallocSizeOf(this);
DocAddSizeOfExcludingThis(aWindowSizes);
}
static size_t
-SizeOfOwnedSheetArrayExcludingThis(const nsTArray<StyleSheetHandle::RefPtr>& aSheets,
+SizeOfOwnedSheetArrayExcludingThis(const nsTArray<RefPtr<StyleSheet>>& aSheets,
MallocSizeOf aMallocSizeOf)
{
size_t n = 0;
n += aSheets.ShallowSizeOfExcludingThis(aMallocSizeOf);
- for (StyleSheetHandle sheet : aSheets) {
+ for (StyleSheet* sheet : aSheets) {
if (!sheet->GetOwningDocument()) {
// Avoid over-reporting shared sheets.
continue;
}
n += sheet->SizeOfIncludingThis(aMallocSizeOf);
}
return n;
}
--- a/dom/base/nsDocument.h
+++ b/dom/base/nsDocument.h
@@ -616,47 +616,47 @@ public:
nsTArray<RefPtr<mozilla::dom::Animation>>& aAnimations) override;
virtual nsresult SetSubDocumentFor(Element* aContent,
nsIDocument* aSubDoc) override;
virtual nsIDocument* GetSubDocumentFor(nsIContent* aContent) const override;
virtual Element* FindContentForSubDocument(nsIDocument *aDocument) const override;
virtual Element* GetRootElementInternal() const override;
- virtual void EnsureOnDemandBuiltInUASheet(mozilla::StyleSheetHandle aSheet) override;
+ virtual void EnsureOnDemandBuiltInUASheet(mozilla::StyleSheet* aSheet) override;
/**
* Get the (document) style sheets owned by this document.
* These are ordered, highest priority last
*/
virtual int32_t GetNumberOfStyleSheets() const override;
- virtual mozilla::StyleSheetHandle GetStyleSheetAt(int32_t aIndex) const override;
+ virtual mozilla::StyleSheet* GetStyleSheetAt(int32_t aIndex) const override;
virtual int32_t GetIndexOfStyleSheet(
- const mozilla::StyleSheetHandle aSheet) const override;
- virtual void AddStyleSheet(mozilla::StyleSheetHandle aSheet) override;
- virtual void RemoveStyleSheet(mozilla::StyleSheetHandle aSheet) override;
+ const mozilla::StyleSheet* aSheet) const override;
+ virtual void AddStyleSheet(mozilla::StyleSheet* aSheet) override;
+ virtual void RemoveStyleSheet(mozilla::StyleSheet* aSheet) override;
virtual void UpdateStyleSheets(
- nsTArray<mozilla::StyleSheetHandle::RefPtr>& aOldSheets,
- nsTArray<mozilla::StyleSheetHandle::RefPtr>& aNewSheets) override;
- virtual void AddStyleSheetToStyleSets(mozilla::StyleSheetHandle aSheet);
- virtual void RemoveStyleSheetFromStyleSets(mozilla::StyleSheetHandle aSheet);
+ nsTArray<RefPtr<mozilla::StyleSheet>>& aOldSheets,
+ nsTArray<RefPtr<mozilla::StyleSheet>>& aNewSheets) override;
+ virtual void AddStyleSheetToStyleSets(mozilla::StyleSheet* aSheet);
+ virtual void RemoveStyleSheetFromStyleSets(mozilla::StyleSheet* aSheet);
- virtual void InsertStyleSheetAt(mozilla::StyleSheetHandle aSheet,
+ virtual void InsertStyleSheetAt(mozilla::StyleSheet* aSheet,
int32_t aIndex) override;
- virtual void SetStyleSheetApplicableState(mozilla::StyleSheetHandle aSheet,
+ virtual void SetStyleSheetApplicableState(mozilla::StyleSheet* aSheet,
bool aApplicable) override;
virtual nsresult LoadAdditionalStyleSheet(additionalSheetType aType,
nsIURI* aSheetURI) override;
virtual nsresult AddAdditionalStyleSheet(additionalSheetType aType,
- mozilla::StyleSheetHandle aSheet) override;
+ mozilla::StyleSheet* aSheet) override;
virtual void RemoveAdditionalStyleSheet(additionalSheetType aType,
nsIURI* sheetURI) override;
- virtual mozilla::StyleSheetHandle GetFirstAdditionalAuthorSheet() override;
+ virtual mozilla::StyleSheet* GetFirstAdditionalAuthorSheet() override;
virtual nsIChannel* GetChannel() const override {
return mChannel;
}
virtual nsIChannel* GetFailedChannel() const override {
return mFailedChannel;
}
@@ -706,21 +706,21 @@ public:
virtual void SetReadyStateInternal(ReadyState rs) override;
virtual void ContentStateChanged(nsIContent* aContent,
mozilla::EventStates aStateMask)
override;
virtual void DocumentStatesChanged(
mozilla::EventStates aStateMask) override;
- virtual void StyleRuleChanged(mozilla::StyleSheetHandle aStyleSheet,
+ virtual void StyleRuleChanged(mozilla::StyleSheet* aStyleSheet,
mozilla::css::Rule* aStyleRule) override;
- virtual void StyleRuleAdded(mozilla::StyleSheetHandle aStyleSheet,
+ virtual void StyleRuleAdded(mozilla::StyleSheet* aStyleSheet,
mozilla::css::Rule* aStyleRule) override;
- virtual void StyleRuleRemoved(mozilla::StyleSheetHandle aStyleSheet,
+ virtual void StyleRuleRemoved(mozilla::StyleSheet* aStyleSheet,
mozilla::css::Rule* aStyleRule) override;
virtual void FlushPendingNotifications(mozFlushType aType) override;
virtual void FlushExternalResources(mozFlushType aType) override;
virtual void SetXMLDeclaration(const char16_t *aVersion,
const char16_t *aEncoding,
const int32_t aStandalone) override;
virtual void GetXMLDeclaration(nsAString& aVersion,
@@ -782,17 +782,17 @@ public:
* Called when an app-theme-changed observer notification is
* received by this document.
*/
void OnAppThemeChanged();
void ReportUseCounters();
private:
- void AddOnDemandBuiltInUASheet(mozilla::StyleSheetHandle aSheet);
+ void AddOnDemandBuiltInUASheet(mozilla::StyleSheet* aSheet);
nsRadioGroupStruct* GetRadioGroupInternal(const nsAString& aName) const;
void SendToConsole(nsCOMArray<nsISecurityConsoleMessage>& aMessages);
public:
// nsIDOMNode
NS_FORWARD_NSIDOMNODE_TO_NSINODE_OVERRIDABLE
// nsIDOMDocument
@@ -965,17 +965,17 @@ public:
mozilla::CORSMode aCORSMode) override;
virtual void PreloadStyle(nsIURI* uri, const nsAString& charset,
const nsAString& aCrossOriginAttr,
ReferrerPolicy aReferrerPolicy,
const nsAString& aIntegrity) override;
virtual nsresult LoadChromeSheetSync(nsIURI* uri, bool isAgentSheet,
- mozilla::StyleSheetHandle::RefPtr* aSheet) override;
+ RefPtr<mozilla::StyleSheet>* aSheet) override;
virtual nsISupports* GetCurrentContentSink() override;
virtual mozilla::EventStates GetDocumentState() override;
// Only BlockOnload should call this!
void AsyncBlockOnload();
@@ -1283,17 +1283,17 @@ public:
protected:
already_AddRefed<nsIPresShell> doCreateShell(nsPresContext* aContext,
nsViewManager* aViewManager,
mozilla::StyleSetHandle aStyleSet);
void RemoveDocStyleSheetsFromStyleSets();
void RemoveStyleSheetsFromStyleSets(
- const nsTArray<mozilla::StyleSheetHandle::RefPtr>& aSheets,
+ const nsTArray<RefPtr<mozilla::StyleSheet>>& aSheets,
mozilla::SheetType aType);
void ResetStylesheetsToURI(nsIURI* aURI);
void FillStyleSet(mozilla::StyleSetHandle aStyleSet);
// Return whether all the presshells for this document are safe to flush
bool IsSafeToFlush() const;
void DispatchPageTransition(mozilla::dom::EventTarget* aDispatchTarget,
@@ -1337,19 +1337,19 @@ protected:
// parsed into.
nsCOMPtr<nsIParser> mParser;
// Weak reference to our sink for in case we no longer have a parser. This
// will allow us to flush out any pending stuff from the sink even if
// EndLoad() has already happened.
nsWeakPtr mWeakSink;
- nsTArray<mozilla::StyleSheetHandle::RefPtr> mStyleSheets;
- nsTArray<mozilla::StyleSheetHandle::RefPtr> mOnDemandBuiltInUASheets;
- nsTArray<mozilla::StyleSheetHandle::RefPtr> mAdditionalSheets[AdditionalSheetTypeCount];
+ nsTArray<RefPtr<mozilla::StyleSheet>> mStyleSheets;
+ nsTArray<RefPtr<mozilla::StyleSheet>> mOnDemandBuiltInUASheets;
+ nsTArray<RefPtr<mozilla::StyleSheet>> mAdditionalSheets[AdditionalSheetTypeCount];
// Array of observers
nsTObserverArray<nsIDocumentObserver*> mObservers;
// Tracker for animations that are waiting to start.
// nullptr until GetOrCreatePendingAnimationTracker is called.
RefPtr<mozilla::PendingAnimationTracker> mPendingAnimationTracker;
@@ -1493,18 +1493,18 @@ public:
mozilla::EventStates mDocumentState;
mozilla::EventStates mGotDocumentState;
RefPtr<nsDOMNavigationTiming> mTiming;
private:
friend class nsUnblockOnloadEvent;
// Recomputes the visibility state but doesn't set the new value.
mozilla::dom::VisibilityState GetVisibilityState() const;
- void NotifyStyleSheetAdded(mozilla::StyleSheetHandle aSheet, bool aDocumentSheet);
- void NotifyStyleSheetRemoved(mozilla::StyleSheetHandle aSheet, bool aDocumentSheet);
+ void NotifyStyleSheetAdded(mozilla::StyleSheet* aSheet, bool aDocumentSheet);
+ void NotifyStyleSheetRemoved(mozilla::StyleSheet* aSheet, bool aDocumentSheet);
void PostUnblockOnloadEvent();
void DoUnblockOnload();
nsresult CheckFrameOptions();
nsresult InitCSP(nsIChannel* aChannel);
/**
--- a/dom/base/nsIDocument.h
+++ b/dom/base/nsIDocument.h
@@ -29,17 +29,17 @@
#include "Units.h"
#include "nsContentListDeclarations.h"
#include "nsExpirationTracker.h"
#include "nsClassHashtable.h"
#include "prclist.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/CORSMode.h"
#include "mozilla/StyleBackendType.h"
-#include "mozilla/StyleSheetHandle.h"
+#include "mozilla/StyleSheet.h"
#include <bitset> // for member
#ifdef MOZILLA_INTERNAL_API
#include "mozilla/dom/DocumentBinding.h"
#else
namespace mozilla {
namespace dom {
class ElementCreationOptionsOrString;
@@ -989,96 +989,96 @@ public:
* This function prepends the given style sheet to the document's style set
* in order to make sure that it does not override user-agent style sheets
* supplied by add-ons or by the app (Firefox OS or Firefox Mobile, for
* example), since their sheets should override built-in sheets.
*
* TODO We can get rid of the whole concept of delayed loading if we fix
* bug 77999.
*/
- virtual void EnsureOnDemandBuiltInUASheet(mozilla::StyleSheetHandle aSheet) = 0;
+ virtual void EnsureOnDemandBuiltInUASheet(mozilla::StyleSheet* aSheet) = 0;
/**
* Get the number of (document) stylesheets
*
* @return the number of stylesheets
* @throws no exceptions
*/
virtual int32_t GetNumberOfStyleSheets() const = 0;
/**
* Get a particular stylesheet
* @param aIndex the index the stylesheet lives at. This is zero-based
* @return the stylesheet at aIndex. Null if aIndex is out of range.
* @throws no exceptions
*/
- virtual mozilla::StyleSheetHandle GetStyleSheetAt(int32_t aIndex) const = 0;
+ virtual mozilla::StyleSheet* GetStyleSheetAt(int32_t aIndex) const = 0;
/**
* Insert a sheet at a particular spot in the stylesheet list (zero-based)
* @param aSheet the sheet to insert
* @param aIndex the index to insert at. This index will be
* adjusted for the "special" sheets.
* @throws no exceptions
*/
- virtual void InsertStyleSheetAt(mozilla::StyleSheetHandle aSheet,
+ virtual void InsertStyleSheetAt(mozilla::StyleSheet* aSheet,
int32_t aIndex) = 0;
/**
* Get the index of a particular stylesheet. This will _always_
* consider the "special" sheets as part of the sheet list.
* @param aSheet the sheet to get the index of
* @return aIndex the index of the sheet in the full list
*/
virtual int32_t GetIndexOfStyleSheet(
- const mozilla::StyleSheetHandle aSheet) const = 0;
+ const mozilla::StyleSheet* aSheet) const = 0;
/**
* Replace the stylesheets in aOldSheets with the stylesheets in
* aNewSheets. The two lists must have equal length, and the sheet
* at positon J in the first list will be replaced by the sheet at
* position J in the second list. Some sheets in the second list
* may be null; if so the corresponding sheets in the first list
* will simply be removed.
*/
virtual void UpdateStyleSheets(
- nsTArray<mozilla::StyleSheetHandle::RefPtr>& aOldSheets,
- nsTArray<mozilla::StyleSheetHandle::RefPtr>& aNewSheets) = 0;
+ nsTArray<RefPtr<mozilla::StyleSheet>>& aOldSheets,
+ nsTArray<RefPtr<mozilla::StyleSheet>>& aNewSheets) = 0;
/**
* Add a stylesheet to the document
*/
- virtual void AddStyleSheet(mozilla::StyleSheetHandle aSheet) = 0;
+ virtual void AddStyleSheet(mozilla::StyleSheet* aSheet) = 0;
/**
* Remove a stylesheet from the document
*/
- virtual void RemoveStyleSheet(mozilla::StyleSheetHandle aSheet) = 0;
+ virtual void RemoveStyleSheet(mozilla::StyleSheet* aSheet) = 0;
/**
* Notify the document that the applicable state of the sheet changed
* and that observers should be notified and style sets updated
*/
- virtual void SetStyleSheetApplicableState(mozilla::StyleSheetHandle aSheet,
+ virtual void SetStyleSheetApplicableState(mozilla::StyleSheet* aSheet,
bool aApplicable) = 0;
enum additionalSheetType {
eAgentSheet,
eUserSheet,
eAuthorSheet,
AdditionalSheetTypeCount
};
virtual nsresult LoadAdditionalStyleSheet(additionalSheetType aType,
nsIURI* aSheetURI) = 0;
virtual nsresult AddAdditionalStyleSheet(additionalSheetType aType,
- mozilla::StyleSheetHandle aSheet) = 0;
+ mozilla::StyleSheet* aSheet) = 0;
virtual void RemoveAdditionalStyleSheet(additionalSheetType aType,
nsIURI* sheetURI) = 0;
- virtual mozilla::StyleSheetHandle GetFirstAdditionalAuthorSheet() = 0;
+ virtual mozilla::StyleSheet* GetFirstAdditionalAuthorSheet() = 0;
/**
* Assuming that aDocSheets is an array of document-level style
* sheets for this document, returns the index that aSheet should
* be inserted at to maintain document ordering.
*
* Defined in nsIDocumentInlines.h.
*/
@@ -1389,21 +1389,21 @@ public:
// Notify that a document state has changed.
// This should only be called by callers whose state is also reflected in the
// implementation of nsDocument::GetDocumentState.
virtual void DocumentStatesChanged(mozilla::EventStates aStateMask) = 0;
// Observation hooks for style data to propagate notifications
// to document observers
- virtual void StyleRuleChanged(mozilla::StyleSheetHandle aStyleSheet,
+ virtual void StyleRuleChanged(mozilla::StyleSheet* aStyleSheet,
mozilla::css::Rule* aStyleRule) = 0;
- virtual void StyleRuleAdded(mozilla::StyleSheetHandle aStyleSheet,
+ virtual void StyleRuleAdded(mozilla::StyleSheet* aStyleSheet,
mozilla::css::Rule* aStyleRule) = 0;
- virtual void StyleRuleRemoved(mozilla::StyleSheetHandle aStyleSheet,
+ virtual void StyleRuleRemoved(mozilla::StyleSheet* aStyleSheet,
mozilla::css::Rule* aStyleRule) = 0;
/**
* Flush notifications for this document and its parent documents
* (since those may affect the layout of this one).
*/
virtual void FlushPendingNotifications(mozFlushType aType) = 0;
@@ -2201,17 +2201,17 @@ public:
* Called by the chrome registry to load style sheets. Can be put
* back there if and when when that module is merged with libgklayout.
*
* This always does a synchronous load. If aIsAgentSheet is true,
* it also uses the system principal and enables unsafe rules.
* DO NOT USE FOR UNTRUSTED CONTENT.
*/
virtual nsresult LoadChromeSheetSync(nsIURI* aURI, bool aIsAgentSheet,
- mozilla::StyleSheetHandle::RefPtr* aSheet) = 0;
+ RefPtr<mozilla::StyleSheet>* aSheet) = 0;
/**
* Returns true if the locale used for the document specifies a direction of
* right to left. For chrome documents, this comes from the chrome registry.
* This is used to determine the current state for the :-moz-locale-dir pseudoclass
* so once can know whether a document is expected to be rendered left-to-right
* or right-to-left.
*/
--- a/dom/base/nsIDocumentInlines.h
+++ b/dom/base/nsIDocumentInlines.h
@@ -30,17 +30,17 @@ nsIDocument::FindDocStyleSheetInsertionP
int32_t count = aDocSheets.Length();
int32_t index;
for (index = 0; index < count; index++) {
T* sheet = aDocSheets[index];
int32_t sheetDocIndex = GetIndexOfStyleSheet(sheet);
if (sheetDocIndex > newDocIndex)
break;
- mozilla::StyleSheetHandle sheetHandle = sheet;
+ mozilla::StyleSheet* sheetHandle = sheet;
// If the sheet is not owned by the document it can be an author
// sheet registered at nsStyleSheetService or an additional author
// sheet on the document, which means the new
// doc sheet should end up before it.
if (sheetDocIndex < 0) {
if (sheetService) {
auto& authorSheets = *sheetService->AuthorStyleSheets();
--- a/dom/base/nsIDocumentObserver.h
+++ b/dom/base/nsIDocumentObserver.h
@@ -2,17 +2,17 @@
/* 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/. */
#ifndef nsIDocumentObserver_h___
#define nsIDocumentObserver_h___
#include "mozilla/EventStates.h"
-#include "mozilla/StyleSheetHandle.h"
+#include "mozilla/StyleSheet.h"
#include "nsISupports.h"
#include "nsIMutationObserver.h"
class nsIContent;
class nsIDocument;
namespace mozilla {
namespace css {
@@ -95,75 +95,75 @@ public:
* called automatically when a StyleSheet gets added to the
* document, even if the stylesheet is not applicable. The
* notification is passed on to all of the document observers.
*
* @param aStyleSheet the StyleSheet that has been added
* @param aDocumentSheet True if sheet is in document's style sheet list,
* false if sheet is not (i.e., UA or user sheet)
*/
- virtual void StyleSheetAdded(mozilla::StyleSheetHandle aStyleSheet,
+ virtual void StyleSheetAdded(mozilla::StyleSheet* aStyleSheet,
bool aDocumentSheet) = 0;
/**
* A StyleSheet has just been removed from the document. This
* method is called automatically when a StyleSheet gets removed
* from the document, even if the stylesheet is not applicable. The
* notification is passed on to all of the document observers.
*
* @param aStyleSheet the StyleSheet that has been removed
* @param aDocumentSheet True if sheet is in document's style sheet list,
* false if sheet is not (i.e., UA or user sheet)
*/
- virtual void StyleSheetRemoved(mozilla::StyleSheetHandle aStyleSheet,
+ virtual void StyleSheetRemoved(mozilla::StyleSheet* aStyleSheet,
bool aDocumentSheet) = 0;
/**
* A StyleSheet has just changed its applicable state.
* This method is called automatically when the applicable state
* of a StyleSheet gets changed. The style sheet passes this
* notification to the document. The notification is passed on
* to all of the document observers.
*
* @param aStyleSheet the StyleSheet that has changed state
*/
- virtual void StyleSheetApplicableStateChanged(mozilla::StyleSheetHandle aStyleSheet) = 0;
+ virtual void StyleSheetApplicableStateChanged(mozilla::StyleSheet* aStyleSheet) = 0;
/**
* A StyleRule has just been modified within a style sheet.
* This method is called automatically when the rule gets
* modified. The style sheet passes this notification to
* the document. The notification is passed on to all of
* the document observers.
*
* @param aStyleSheet the StyleSheet that contians the rule
*/
- virtual void StyleRuleChanged(mozilla::StyleSheetHandle aStyleSheet) = 0;
+ virtual void StyleRuleChanged(mozilla::StyleSheet* aStyleSheet) = 0;
/**
* A StyleRule has just been added to a style sheet.
* This method is called automatically when the rule gets
* added to the sheet. The style sheet passes this
* notification to the document. The notification is passed on
* to all of the document observers.
*
* @param aStyleSheet the StyleSheet that has been modified
*/
- virtual void StyleRuleAdded(mozilla::StyleSheetHandle aStyleSheet) = 0;
+ virtual void StyleRuleAdded(mozilla::StyleSheet* aStyleSheet) = 0;
/**
* A StyleRule has just been removed from a style sheet.
* This method is called automatically when the rule gets
* removed from the sheet. The style sheet passes this
* notification to the document. The notification is passed on
* to all of the document observers.
*
* @param aStyleSheet the StyleSheet that has been modified
*/
- virtual void StyleRuleRemoved(mozilla::StyleSheetHandle aStyleSheet) = 0;
+ virtual void StyleRuleRemoved(mozilla::StyleSheet* aStyleSheet) = 0;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsIDocumentObserver, NS_IDOCUMENT_OBSERVER_IID)
#define NS_DECL_NSIDOCUMENTOBSERVER_BEGINUPDATE \
virtual void BeginUpdate(nsIDocument* aDocument, \
nsUpdateType aUpdateType) override;
@@ -181,35 +181,35 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsIDocumen
nsIContent* aContent, \
mozilla::EventStates aStateMask) override;
#define NS_DECL_NSIDOCUMENTOBSERVER_DOCUMENTSTATESCHANGED \
virtual void DocumentStatesChanged(nsIDocument* aDocument, \
mozilla::EventStates aStateMask) override;
#define NS_DECL_NSIDOCUMENTOBSERVER_STYLESHEETADDED \
- virtual void StyleSheetAdded(mozilla::StyleSheetHandle aStyleSheet, \
+ virtual void StyleSheetAdded(mozilla::StyleSheet* aStyleSheet, \
bool aDocumentSheet) override;
#define NS_DECL_NSIDOCUMENTOBSERVER_STYLESHEETREMOVED \
- virtual void StyleSheetRemoved(mozilla::StyleSheetHandle aStyleSheet, \
+ virtual void StyleSheetRemoved(mozilla::StyleSheet* aStyleSheet, \
bool aDocumentSheet) override;
#define NS_DECL_NSIDOCUMENTOBSERVER_STYLESHEETAPPLICABLESTATECHANGED \
virtual void StyleSheetApplicableStateChanged( \
- mozilla::StyleSheetHandle aStyleSheet) override;
+ mozilla::StyleSheet* aStyleSheet) override;
#define NS_DECL_NSIDOCUMENTOBSERVER_STYLERULECHANGED \
- virtual void StyleRuleChanged(mozilla::StyleSheetHandle aStyleSheet) override;
+ virtual void StyleRuleChanged(mozilla::StyleSheet* aStyleSheet) override;
#define NS_DECL_NSIDOCUMENTOBSERVER_STYLERULEADDED \
- virtual void StyleRuleAdded(mozilla::StyleSheetHandle aStyleSheet) override;
+ virtual void StyleRuleAdded(mozilla::StyleSheet* aStyleSheet) override;
#define NS_DECL_NSIDOCUMENTOBSERVER_STYLERULEREMOVED \
- virtual void StyleRuleRemoved(mozilla::StyleSheetHandle aStyleSheet) override;
+ virtual void StyleRuleRemoved(mozilla::StyleSheet* aStyleSheet) override;
#define NS_DECL_NSIDOCUMENTOBSERVER \
NS_DECL_NSIDOCUMENTOBSERVER_BEGINUPDATE \
NS_DECL_NSIDOCUMENTOBSERVER_ENDUPDATE \
NS_DECL_NSIDOCUMENTOBSERVER_BEGINLOAD \
NS_DECL_NSIDOCUMENTOBSERVER_ENDLOAD \
NS_DECL_NSIDOCUMENTOBSERVER_CONTENTSTATECHANGED \
NS_DECL_NSIDOCUMENTOBSERVER_DOCUMENTSTATESCHANGED \
@@ -257,35 +257,35 @@ void
{ \
}
#define NS_IMPL_NSIDOCUMENTOBSERVER_CONTENT(_class) \
NS_IMPL_NSIMUTATIONOBSERVER_CONTENT(_class)
#define NS_IMPL_NSIDOCUMENTOBSERVER_STYLE_STUB(_class) \
void \
-_class::StyleSheetAdded(mozilla::StyleSheetHandle aStyleSheet, \
+_class::StyleSheetAdded(mozilla::StyleSheet* aStyleSheet, \
bool aDocumentSheet) \
{ \
} \
void \
-_class::StyleSheetRemoved(mozilla::StyleSheetHandle aStyleSheet, \
+_class::StyleSheetRemoved(mozilla::StyleSheet* aStyleSheet, \
bool aDocumentSheet) \
{ \
} \
void \
-_class::StyleSheetApplicableStateChanged(mozilla::StyleSheetHandle aStyleSheet) \
+_class::StyleSheetApplicableStateChanged(mozilla::StyleSheet* aStyleSheet) \
{ \
} \
void \
-_class::StyleRuleChanged(mozilla::StyleSheetHandle aStyleSheet) \
+_class::StyleRuleChanged(mozilla::StyleSheet* aStyleSheet) \
{ \
} \
void \
-_class::StyleRuleAdded(mozilla::StyleSheetHandle aStyleSheet) \
+_class::StyleRuleAdded(mozilla::StyleSheet* aStyleSheet) \
{ \
} \
void \
-_class::StyleRuleRemoved(mozilla::StyleSheetHandle aStyleSheet) \
+_class::StyleRuleRemoved(mozilla::StyleSheet* aStyleSheet) \
{ \
}
#endif /* nsIDocumentObserver_h___ */
--- a/dom/base/nsIStyleSheetLinkingElement.h
+++ b/dom/base/nsIStyleSheetLinkingElement.h
@@ -3,17 +3,17 @@
/* 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/. */
#ifndef nsIStyleSheetLinkingElement_h__
#define nsIStyleSheetLinkingElement_h__
#include "nsISupports.h"
-#include "mozilla/StyleSheetHandle.h"
+#include "mozilla/StyleSheet.h"
class nsICSSLoaderObserver;
class nsIURI;
#define NS_ISTYLESHEETLINKINGELEMENT_IID \
{ 0xa8b79f3b, 0x9d18, 0x4f9c, \
{ 0xb1, 0xaa, 0x8c, 0x9b, 0x1b, 0xaa, 0xac, 0xad } }
@@ -23,24 +23,24 @@ public:
/**
* Used to make the association between a style sheet and
* the element that linked it to the document.
*
* @param aStyleSheet the style sheet associated with this
* element.
*/
- NS_IMETHOD SetStyleSheet(mozilla::StyleSheetHandle aStyleSheet) = 0;
+ NS_IMETHOD SetStyleSheet(mozilla::StyleSheet* aStyleSheet) = 0;
/**
* Used to obtain the style sheet linked in by this element.
*
* @return the style sheet associated with this element.
*/
- NS_IMETHOD_(mozilla::StyleSheetHandle) GetStyleSheet() = 0;
+ NS_IMETHOD_(mozilla::StyleSheet*) GetStyleSheet() = 0;
/**
* Initialize the stylesheet linking element. If aDontLoadStyle is
* true the element will ignore the first modification to the
* element that would cause a stylesheet to be loaded. Subsequent
* modifications to the element will not be ignored.
*/
NS_IMETHOD InitStyleLinkElement(bool aDontLoadStyle) = 0;
--- a/dom/base/nsStyleLinkElement.cpp
+++ b/dom/base/nsStyleLinkElement.cpp
@@ -7,18 +7,18 @@
/*
* A base class which implements nsIStyleSheetLinkingElement and can
* be subclassed by various content nodes that want to load
* stylesheets (<style>, <link>, processing instructions, etc).
*/
#include "nsStyleLinkElement.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
#include "mozilla/css/Loader.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/FragmentOrElement.h"
#include "mozilla/dom/HTMLLinkElement.h"
#include "mozilla/dom/ShadowRoot.h"
#include "mozilla/dom/SRILogHelper.h"
#include "mozilla/Preferences.h"
#include "nsIContent.h"
@@ -58,34 +58,34 @@ nsStyleLinkElement::Unlink()
void
nsStyleLinkElement::Traverse(nsCycleCollectionTraversalCallback &cb)
{
nsStyleLinkElement* tmp = this;
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStyleSheet);
}
NS_IMETHODIMP
-nsStyleLinkElement::SetStyleSheet(StyleSheetHandle aStyleSheet)
+nsStyleLinkElement::SetStyleSheet(StyleSheet* aStyleSheet)
{
if (mStyleSheet) {
mStyleSheet->SetOwningNode(nullptr);
}
mStyleSheet = aStyleSheet;
if (mStyleSheet) {
nsCOMPtr<nsINode> node = do_QueryObject(this);
if (node) {
mStyleSheet->SetOwningNode(node);
}
}
return NS_OK;
}
-NS_IMETHODIMP_(StyleSheetHandle)
+NS_IMETHODIMP_(StyleSheet*)
nsStyleLinkElement::GetStyleSheet()
{
return mStyleSheet;
}
NS_IMETHODIMP
nsStyleLinkElement::InitStyleLinkElement(bool aDontLoadStyle)
{
--- a/dom/base/nsStyleLinkElement.h
+++ b/dom/base/nsStyleLinkElement.h
@@ -45,18 +45,18 @@ public:
// exposing them to script.
NS_ASSERTION(!mStyleSheet || mStyleSheet->IsGecko(),
"stylo: ServoStyleSheets can't be exposed to script yet");
return mStyleSheet && mStyleSheet->IsGecko() ? mStyleSheet->AsGecko() :
nullptr;
}
// nsIStyleSheetLinkingElement
- NS_IMETHOD SetStyleSheet(mozilla::StyleSheetHandle aStyleSheet) override;
- NS_IMETHOD_(mozilla::StyleSheetHandle) GetStyleSheet() override;
+ NS_IMETHOD SetStyleSheet(mozilla::StyleSheet* aStyleSheet) override;
+ NS_IMETHOD_(mozilla::StyleSheet*) GetStyleSheet() override;
NS_IMETHOD InitStyleLinkElement(bool aDontLoadStyle) override;
NS_IMETHOD UpdateStyleSheet(nsICSSLoaderObserver* aObserver,
bool* aWillNotify,
bool* aIsAlternate,
bool aForceReload) override;
NS_IMETHOD SetEnableUpdates(bool aEnableUpdates) override;
NS_IMETHOD GetCharset(nsAString& aCharset) override;
@@ -138,17 +138,17 @@ private:
*/
nsresult DoUpdateStyleSheet(nsIDocument* aOldDocument,
mozilla::dom::ShadowRoot* aOldShadowRoot,
nsICSSLoaderObserver* aObserver,
bool* aWillNotify,
bool* aIsAlternate,
bool aForceUpdate);
- mozilla::StyleSheetHandle::RefPtr mStyleSheet;
+ RefPtr<mozilla::StyleSheet> mStyleSheet;
protected:
bool mDontLoadStyle;
bool mUpdatesEnabled;
uint32_t mLineNumber;
};
#endif /* nsStyleLinkElement_h___ */
--- a/dom/html/nsHTMLDocument.cpp
+++ b/dom/html/nsHTMLDocument.cpp
@@ -109,18 +109,18 @@
#include "mozilla/dom/HTMLDocumentBinding.h"
#include "nsCharsetSource.h"
#include "nsIStringBundle.h"
#include "nsDOMClassInfo.h"
#include "nsFocusManager.h"
#include "nsIFrame.h"
#include "nsIContent.h"
#include "nsLayoutStylesheetCache.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
using namespace mozilla;
using namespace mozilla::dom;
#define NS_MAX_DOCUMENT_WRITE_DEPTH 20
#include "prtime.h"
@@ -2545,17 +2545,17 @@ nsHTMLDocument::TearingDownEditor(nsIEdi
if (IsEditingOn()) {
EditingState oldState = mEditingState;
mEditingState = eTearingDown;
nsCOMPtr<nsIPresShell> presShell = GetShell();
if (!presShell)
return;
- nsTArray<StyleSheetHandle::RefPtr> agentSheets;
+ nsTArray<RefPtr<StyleSheet>> agentSheets;
presShell->GetAgentStyleSheets(agentSheets);
auto cache = nsLayoutStylesheetCache::For(GetStyleBackendType());
agentSheets.RemoveElement(cache->ContentEditableSheet());
if (oldState == eDesignMode)
agentSheets.RemoveElement(cache->DesignModeSheet());
@@ -2688,34 +2688,34 @@ nsHTMLDocument::EditingStateChanged()
nsAutoEditingState push(this, eSettingUp);
nsCOMPtr<nsIPresShell> presShell = GetShell();
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
// Before making this window editable, we need to modify UA style sheet
// because new style may change whether focused element will be focusable
// or not.
- nsTArray<StyleSheetHandle::RefPtr> agentSheets;
+ nsTArray<RefPtr<StyleSheet>> agentSheets;
rv = presShell->GetAgentStyleSheets(agentSheets);
NS_ENSURE_SUCCESS(rv, rv);
auto cache = nsLayoutStylesheetCache::For(GetStyleBackendType());
- StyleSheetHandle contentEditableSheet = cache->ContentEditableSheet();
+ StyleSheet* contentEditableSheet = cache->ContentEditableSheet();
if (!agentSheets.Contains(contentEditableSheet)) {
agentSheets.AppendElement(contentEditableSheet);
}
// Should we update the editable state of all the nodes in the document? We
// need to do this when the designMode value changes, as that overrides
// specific states on the elements.
if (designMode) {
// designMode is being turned on (overrides contentEditable).
- StyleSheetHandle designModeSheet = cache->DesignModeSheet();
+ StyleSheet* designModeSheet = cache->DesignModeSheet();
if (!agentSheets.Contains(designModeSheet)) {
agentSheets.AppendElement(designModeSheet);
}
updateState = true;
spellRecheckAll = oldState == eContentEditable;
}
else if (oldState == eDesignMode) {
--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -185,18 +185,18 @@
#include "prio.h"
#include "private/pprio.h"
#include "ContentProcessManager.h"
#include "mozilla/dom/ipc/StructuredCloneData.h"
#include "mozilla/psm/PSMContentListener.h"
#include "nsPluginHost.h"
#include "nsPluginTags.h"
#include "nsIBlocklistService.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
#include "nsHostObjectProtocolHandler.h"
#include "nsIBidiKeyboard.h"
#ifdef MOZ_WEBRTC
#include "signaling/src/peerconnection/WebrtcGlobalParent.h"
#endif
@@ -2259,29 +2259,29 @@ ContentParent::InitInternal(ProcessPrior
Unused << SendAppInit();
}
nsStyleSheetService *sheetService = nsStyleSheetService::GetInstance();
if (sheetService) {
// This looks like a lot of work, but in a normal browser session we just
// send two loads.
- for (StyleSheetHandle sheet : *sheetService->AgentStyleSheets()) {
+ for (StyleSheet* sheet : *sheetService->AgentStyleSheets()) {
URIParams uri;
SerializeURI(sheet->GetSheetURI(), uri);
Unused << SendLoadAndRegisterSheet(uri, nsIStyleSheetService::AGENT_SHEET);
}
- for (StyleSheetHandle sheet : *sheetService->UserStyleSheets()) {
+ for (StyleSheet* sheet : *sheetService->UserStyleSheets()) {
URIParams uri;
SerializeURI(sheet->GetSheetURI(), uri);
Unused << SendLoadAndRegisterSheet(uri, nsIStyleSheetService::USER_SHEET);
}
- for (StyleSheetHandle sheet : *sheetService->AuthorStyleSheets()) {
+ for (StyleSheet* sheet : *sheetService->AuthorStyleSheets()) {
URIParams uri;
SerializeURI(sheet->GetSheetURI(), uri);
Unused << SendLoadAndRegisterSheet(uri, nsIStyleSheetService::AUTHOR_SHEET);
}
}
#ifdef MOZ_CONTENT_SANDBOX
bool shouldSandbox = true;
--- a/dom/svg/SVGDocument.cpp
+++ b/dom/svg/SVGDocument.cpp
@@ -15,18 +15,18 @@
#include "nsNetUtil.h"
#include "nsServiceManagerUtils.h"
#include "nsString.h"
#include "nsLiteralString.h"
#include "nsIDOMSVGElement.h"
#include "mozilla/dom/Element.h"
#include "nsSVGElement.h"
#include "mozilla/dom/SVGDocumentBinding.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
using namespace mozilla::css;
using namespace mozilla::dom;
namespace mozilla {
namespace dom {
//----------------------------------------------------------------------
@@ -152,33 +152,33 @@ SVGDocument::EnsureNonSVGUserAgentStyleS
catMan->GetCategoryEntry("agent-style-sheets", name.get(),
getter_Copies(spec));
mozilla::css::Loader* cssLoader = CSSLoader();
if (cssLoader->GetEnabled()) {
nsCOMPtr<nsIURI> uri;
NS_NewURI(getter_AddRefs(uri), spec);
if (uri) {
- StyleSheetHandle::RefPtr sheet;
+ RefPtr<StyleSheet> sheet;
cssLoader->LoadSheetSync(uri,
mozilla::css::eAgentSheetFeatures,
true, &sheet);
if (sheet) {
EnsureOnDemandBuiltInUASheet(sheet);
}
}
}
}
}
}
}
auto cache = nsLayoutStylesheetCache::For(GetStyleBackendType());
- StyleSheetHandle sheet = cache->NumberControlSheet();
+ StyleSheet* sheet = cache->NumberControlSheet();
if (sheet) {
// number-control.css can be behind a pref
EnsureOnDemandBuiltInUASheet(sheet);
}
EnsureOnDemandBuiltInUASheet(cache->FormsSheet());
EnsureOnDemandBuiltInUASheet(cache->CounterStylesSheet());
EnsureOnDemandBuiltInUASheet(cache->HTMLSheet());
if (nsLayoutUtils::ShouldUseNoFramesSheet(this)) {
--- a/dom/xbl/nsBindingManager.cpp
+++ b/dom/xbl/nsBindingManager.cpp
@@ -765,17 +765,17 @@ nsBindingManager::MediumFeaturesChanged(
bool thisChanged = ruleProcessor->MediumFeaturesChanged(aPresContext);
*aRulesChanged = *aRulesChanged || thisChanged;
}
return NS_OK;
}
void
-nsBindingManager::AppendAllSheets(nsTArray<StyleSheetHandle>& aArray)
+nsBindingManager::AppendAllSheets(nsTArray<StyleSheet*>& aArray)
{
if (!mBoundContentSet) {
return;
}
for (auto iter = mBoundContentSet->Iter(); !iter.Done(); iter.Next()) {
nsIContent* boundContent = iter.Get()->GetKey();
for (nsXBLBinding* binding = boundContent->GetXBLBinding(); binding;
--- a/dom/xbl/nsBindingManager.h
+++ b/dom/xbl/nsBindingManager.h
@@ -13,17 +13,17 @@
#include "nsHashKeys.h"
#include "nsInterfaceHashtable.h"
#include "nsRefPtrHashtable.h"
#include "nsURIHashKey.h"
#include "nsCycleCollectionParticipant.h"
#include "nsXBLBinding.h"
#include "nsTArray.h"
#include "nsThreadUtils.h"
-#include "mozilla/StyleSheetHandle.h"
+#include "mozilla/StyleSheet.h"
struct ElementDependentRuleProcessorData;
class nsIXPConnectWrappedJS;
class nsIAtom;
class nsIDOMNodeList;
class nsIDocument;
class nsIURI;
class nsXBLDocumentInfo;
@@ -133,17 +133,17 @@ public:
/**
* Do any processing that needs to happen as a result of a change in
* the characteristics of the medium, and return whether this rule
* processor's rules have changed (e.g., because of media queries).
*/
nsresult MediumFeaturesChanged(nsPresContext* aPresContext,
bool* aRulesChanged);
- void AppendAllSheets(nsTArray<mozilla::StyleSheetHandle>& aArray);
+ void AppendAllSheets(nsTArray<mozilla::StyleSheet*>& aArray);
void Traverse(nsIContent *aContent,
nsCycleCollectionTraversalCallback &cb);
NS_DECL_CYCLE_COLLECTION_CLASS(nsBindingManager)
// Notify the binding manager when an outermost update begins and
// ends. The end method can execute script.
--- a/dom/xbl/nsXBLPrototypeBinding.cpp
+++ b/dom/xbl/nsXBLPrototypeBinding.cpp
@@ -39,18 +39,18 @@
#include "nsIScriptError.h"
#include "nsCSSRuleProcessor.h"
#include "nsXBLResourceLoader.h"
#include "mozilla/AddonPathService.h"
#include "mozilla/dom/CDATASection.h"
#include "mozilla/dom/Comment.h"
#include "mozilla/dom/Element.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
#ifdef MOZ_XUL
#include "nsXULElement.h"
#endif
using namespace mozilla;
using namespace mozilla::dom;
@@ -1639,40 +1639,40 @@ void
nsXBLPrototypeBinding::EnsureResources()
{
if (!mResources) {
mResources = new nsXBLPrototypeResources(this);
}
}
void
-nsXBLPrototypeBinding::AppendStyleSheet(StyleSheetHandle aSheet)
+nsXBLPrototypeBinding::AppendStyleSheet(StyleSheet* aSheet)
{
EnsureResources();
mResources->AppendStyleSheet(aSheet);
}
void
-nsXBLPrototypeBinding::RemoveStyleSheet(StyleSheetHandle aSheet)
+nsXBLPrototypeBinding::RemoveStyleSheet(StyleSheet* aSheet)
{
if (!mResources) {
MOZ_ASSERT(false, "Trying to remove a sheet that does not exist.");
return;
}
mResources->RemoveStyleSheet(aSheet);
}
void
-nsXBLPrototypeBinding::InsertStyleSheetAt(size_t aIndex, StyleSheetHandle aSheet)
+nsXBLPrototypeBinding::InsertStyleSheetAt(size_t aIndex, StyleSheet* aSheet)
{
EnsureResources();
mResources->InsertStyleSheetAt(aIndex, aSheet);
}
-StyleSheetHandle
+StyleSheet*
nsXBLPrototypeBinding::StyleSheetAt(size_t aIndex) const
{
MOZ_ASSERT(mResources);
return mResources->StyleSheetAt(aIndex);
}
size_t
nsXBLPrototypeBinding::SheetCount() const
@@ -1683,14 +1683,14 @@ nsXBLPrototypeBinding::SheetCount() cons
bool
nsXBLPrototypeBinding::HasStyleSheets() const
{
return mResources && mResources->HasStyleSheets();
}
void
nsXBLPrototypeBinding::AppendStyleSheetsTo(
- nsTArray<StyleSheetHandle>& aResult) const
+ nsTArray<StyleSheet*>& aResult) const
{
if (mResources) {
mResources->AppendStyleSheetsTo(aResult);
}
}
--- a/dom/xbl/nsXBLPrototypeBinding.h
+++ b/dom/xbl/nsXBLPrototypeBinding.h
@@ -15,17 +15,17 @@
#include "nsInterfaceHashtable.h"
#include "nsWeakReference.h"
#include "nsXBLDocumentInfo.h"
#include "nsXBLProtoImpl.h"
#include "nsXBLProtoImplMethod.h"
#include "nsXBLPrototypeHandler.h"
#include "nsXBLPrototypeResources.h"
#include "mozilla/WeakPtr.h"
-#include "mozilla/StyleSheetHandle.h"
+#include "mozilla/StyleSheet.h"
class nsIAtom;
class nsIContent;
class nsIDocument;
class nsXBLAttributeEntry;
class nsXBLBinding;
class nsXBLProtoImplField;
@@ -115,23 +115,23 @@ public:
void SetBasePrototype(nsXBLPrototypeBinding* aBinding);
nsXBLPrototypeBinding* GetBasePrototype() { return mBaseBinding; }
nsXBLDocumentInfo* XBLDocumentInfo() const { return mXBLDocInfoWeak; }
bool IsChrome() { return mXBLDocInfoWeak->IsChrome(); }
void SetInitialAttributes(nsIContent* aBoundElement, nsIContent* aAnonymousContent);
- void AppendStyleSheet(mozilla::StyleSheetHandle aSheet);
- void RemoveStyleSheet(mozilla::StyleSheetHandle aSheet);
- void InsertStyleSheetAt(size_t aIndex, mozilla::StyleSheetHandle aSheet);
- mozilla::StyleSheetHandle StyleSheetAt(size_t aIndex) const;
+ void AppendStyleSheet(mozilla::StyleSheet* aSheet);
+ void RemoveStyleSheet(mozilla::StyleSheet* aSheet);
+ void InsertStyleSheetAt(size_t aIndex, mozilla::StyleSheet* aSheet);
+ mozilla::StyleSheet* StyleSheetAt(size_t aIndex) const;
size_t SheetCount() const;
bool HasStyleSheets() const;
- void AppendStyleSheetsTo(nsTArray<mozilla::StyleSheetHandle>& aResult) const;
+ void AppendStyleSheetsTo(nsTArray<mozilla::StyleSheet*>& aResult) const;
nsIStyleRuleProcessor* GetRuleProcessor();
nsresult FlushSkinSheets();
nsIAtom* GetBaseTag(int32_t* aNamespaceID);
void SetBaseTag(int32_t aNamespaceID, nsIAtom* aTag);
--- a/dom/xbl/nsXBLPrototypeResources.cpp
+++ b/dom/xbl/nsXBLPrototypeResources.cpp
@@ -14,18 +14,18 @@
#include "nsIDocumentObserver.h"
#include "mozilla/css/Loader.h"
#include "nsIURI.h"
#include "nsLayoutCID.h"
#include "nsCSSRuleProcessor.h"
#include "nsStyleSet.h"
#include "mozilla/dom/URL.h"
#include "mozilla/DebugOnly.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
using namespace mozilla;
using mozilla::dom::IsChromeURI;
nsXBLPrototypeResources::nsXBLPrototypeResources(nsXBLPrototypeBinding* aBinding)
{
MOZ_COUNT_CTOR(nsXBLPrototypeResources);
@@ -79,28 +79,28 @@ nsXBLPrototypeResources::FlushSkinSheets
}
// We have scoped stylesheets. Reload any chrome stylesheets we
// encounter. (If they aren't skin sheets, it doesn't matter, since
// they'll still be in the chrome cache. Skip inline sheets, which
// skin sheets can't be, and which in any case don't have a usable
// URL to reload.)
- nsTArray<StyleSheetHandle::RefPtr> oldSheets;
+ nsTArray<RefPtr<StyleSheet>> oldSheets;
oldSheets.SwapElements(mStyleSheetList);
mozilla::css::Loader* cssLoader = doc->CSSLoader();
for (size_t i = 0, count = oldSheets.Length(); i < count; ++i) {
- StyleSheetHandle oldSheet = oldSheets[i];
+ StyleSheet* oldSheet = oldSheets[i];
nsIURI* uri = oldSheet->GetSheetURI();
- StyleSheetHandle::RefPtr newSheet;
+ RefPtr<StyleSheet> newSheet;
if (!oldSheet->IsInline() && IsChromeURI(uri)) {
if (NS_FAILED(cssLoader->LoadSheetSync(uri, &newSheet)))
continue;
}
else {
newSheet = oldSheet;
}
@@ -142,48 +142,48 @@ nsXBLPrototypeResources::ClearLoader()
{
mLoader = nullptr;
}
void
nsXBLPrototypeResources::GatherRuleProcessor()
{
nsTArray<RefPtr<CSSStyleSheet>> sheets(mStyleSheetList.Length());
- for (StyleSheetHandle sheet : mStyleSheetList) {
+ for (StyleSheet* sheet : mStyleSheetList) {
MOZ_ASSERT(sheet->IsGecko(),
"GatherRuleProcessor must only be called for "
"nsXBLPrototypeResources objects with Gecko-flavored style "
"backends");
sheets.AppendElement(sheet->AsGecko());
}
mRuleProcessor = new nsCSSRuleProcessor(Move(sheets),
SheetType::Doc,
nullptr,
mRuleProcessor);
}
void
-nsXBLPrototypeResources::AppendStyleSheet(StyleSheetHandle aSheet)
+nsXBLPrototypeResources::AppendStyleSheet(StyleSheet* aSheet)
{
mStyleSheetList.AppendElement(aSheet);
}
void
-nsXBLPrototypeResources::RemoveStyleSheet(StyleSheetHandle aSheet)
+nsXBLPrototypeResources::RemoveStyleSheet(StyleSheet* aSheet)
{
mStyleSheetList.RemoveElement(aSheet);
}
void
-nsXBLPrototypeResources::InsertStyleSheetAt(size_t aIndex, StyleSheetHandle aSheet)
+nsXBLPrototypeResources::InsertStyleSheetAt(size_t aIndex, StyleSheet* aSheet)
{
mStyleSheetList.InsertElementAt(aIndex, aSheet);
}
-StyleSheetHandle
+StyleSheet*
nsXBLPrototypeResources::StyleSheetAt(size_t aIndex) const
{
return mStyleSheetList[aIndex];
}
size_t
nsXBLPrototypeResources::SheetCount() const
{
@@ -193,12 +193,12 @@ nsXBLPrototypeResources::SheetCount() co
bool
nsXBLPrototypeResources::HasStyleSheets() const
{
return !mStyleSheetList.IsEmpty();
}
void
nsXBLPrototypeResources::AppendStyleSheetsTo(
- nsTArray<StyleSheetHandle>& aResult) const
+ nsTArray<StyleSheet*>& aResult) const
{
aResult.AppendElements(mStyleSheetList);
}
--- a/dom/xbl/nsXBLPrototypeResources.h
+++ b/dom/xbl/nsXBLPrototypeResources.h
@@ -2,17 +2,17 @@
/* 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/. */
#ifndef nsXBLPrototypeResources_h__
#define nsXBLPrototypeResources_h__
-#include "mozilla/StyleSheetHandle.h"
+#include "mozilla/StyleSheet.h"
#include "nsICSSLoaderObserver.h"
class nsCSSRuleProcessor;
class nsIAtom;
class nsIContent;
class nsXBLPrototypeBinding;
class nsXBLResourceLoader;
@@ -36,37 +36,37 @@ public:
nsresult Write(nsIObjectOutputStream* aStream);
void Traverse(nsCycleCollectionTraversalCallback &cb);
void Unlink();
void ClearLoader();
- void AppendStyleSheet(mozilla::StyleSheetHandle aSheet);
- void RemoveStyleSheet(mozilla::StyleSheetHandle aSheet);
- void InsertStyleSheetAt(size_t aIndex, mozilla::StyleSheetHandle aSheet);
- mozilla::StyleSheetHandle StyleSheetAt(size_t aIndex) const;
+ void AppendStyleSheet(mozilla::StyleSheet* aSheet);
+ void RemoveStyleSheet(mozilla::StyleSheet* aSheet);
+ void InsertStyleSheetAt(size_t aIndex, mozilla::StyleSheet* aSheet);
+ mozilla::StyleSheet* StyleSheetAt(size_t aIndex) const;
size_t SheetCount() const;
bool HasStyleSheets() const;
- void AppendStyleSheetsTo(nsTArray<mozilla::StyleSheetHandle>& aResult) const;
+ void AppendStyleSheetsTo(nsTArray<mozilla::StyleSheet*>& aResult) const;
/**
* Recreates mRuleProcessor to represent the current list of style sheets
* stored in mStyleSheetList. (Named GatherRuleProcessor to parallel
* nsStyleSet::GatherRuleProcessors.)
*/
void GatherRuleProcessor();
nsCSSRuleProcessor* GetRuleProcessor() const { return mRuleProcessor; }
private:
// A loader object. Exists only long enough to load resources, and then it dies.
RefPtr<nsXBLResourceLoader> mLoader;
// A list of loaded stylesheets for this binding.
- nsTArray<mozilla::StyleSheetHandle::RefPtr> mStyleSheetList;
+ nsTArray<RefPtr<mozilla::StyleSheet>> mStyleSheetList;
// The list of stylesheets converted to a rule processor.
RefPtr<nsCSSRuleProcessor> mRuleProcessor;
};
#endif
--- a/dom/xbl/nsXBLResourceLoader.cpp
+++ b/dom/xbl/nsXBLResourceLoader.cpp
@@ -12,18 +12,18 @@
#include "nsIPresShell.h"
#include "nsXBLService.h"
#include "nsIServiceManager.h"
#include "nsXBLResourceLoader.h"
#include "nsXBLPrototypeResources.h"
#include "nsIDocumentObserver.h"
#include "imgILoader.h"
#include "imgRequestProxy.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
#include "mozilla/css/Loader.h"
#include "nsIURI.h"
#include "nsNetUtil.h"
#include "nsGkAtoms.h"
#include "nsFrameManager.h"
#include "nsStyleContext.h"
#include "nsXBLPrototypeBinding.h"
#include "nsCSSRuleProcessor.h"
@@ -130,17 +130,17 @@ nsXBLResourceLoader::LoadResources(bool*
bool chrome;
nsresult rv;
if (NS_SUCCEEDED(url->SchemeIs("chrome", &chrome)) && chrome)
{
rv = nsContentUtils::GetSecurityManager()->
CheckLoadURIWithPrincipal(docPrincipal, url,
nsIScriptSecurityManager::ALLOW_CHROME);
if (NS_SUCCEEDED(rv)) {
- StyleSheetHandle::RefPtr sheet;
+ RefPtr<StyleSheet> sheet;
rv = cssLoader->LoadSheetSync(url, &sheet);
NS_ASSERTION(NS_SUCCEEDED(rv), "Load failed!!!");
if (NS_SUCCEEDED(rv))
{
rv = StyleSheetLoaded(sheet, false, NS_OK);
NS_ASSERTION(NS_SUCCEEDED(rv), "Processing the style sheet failed!!!");
}
}
@@ -159,17 +159,17 @@ nsXBLResourceLoader::LoadResources(bool*
// Destroy our resource list.
delete mResourceList;
mResourceList = nullptr;
}
// nsICSSLoaderObserver
NS_IMETHODIMP
-nsXBLResourceLoader::StyleSheetLoaded(StyleSheetHandle aSheet,
+nsXBLResourceLoader::StyleSheetLoaded(StyleSheet* aSheet,
bool aWasAlternate,
nsresult aStatus)
{
if (!mResources) {
// Our resources got destroyed -- just bail out
return NS_OK;
}
--- a/dom/xbl/nsXBLResourceLoader.h
+++ b/dom/xbl/nsXBLResourceLoader.h
@@ -25,17 +25,17 @@ class nsIObjectOutputStream;
class nsXBLResourceLoader : public nsICSSLoaderObserver
{
public:
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_CLASS(nsXBLResourceLoader)
// nsICSSLoaderObserver
- NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheetHandle aSheet,
+ NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheet* aSheet,
bool aWasAlternate,
nsresult aStatus) override;
void LoadResources(bool* aResult);
void AddResource(nsIAtom* aResourceType, const nsAString& aSrc);
void AddResourceListener(nsIContent* aElement);
nsXBLResourceLoader(nsXBLPrototypeBinding* aBinding,
--- a/dom/xml/nsXMLContentSink.cpp
+++ b/dom/xml/nsXMLContentSink.cpp
@@ -406,17 +406,17 @@ nsXMLContentSink::OnTransformDone(nsresu
ScrollToRef();
originalDocument->EndLoad();
return NS_OK;
}
NS_IMETHODIMP
-nsXMLContentSink::StyleSheetLoaded(StyleSheetHandle aSheet,
+nsXMLContentSink::StyleSheetLoaded(StyleSheet* aSheet,
bool aWasAlternate,
nsresult aStatus)
{
if (!mPrettyPrinting) {
return nsContentSink::StyleSheetLoaded(aSheet, aWasAlternate, aStatus);
}
if (!mDocument->CSSLoader()->HasPendingLoads()) {
--- a/dom/xml/nsXMLContentSink.h
+++ b/dom/xml/nsXMLContentSink.h
@@ -77,17 +77,17 @@ public:
virtual bool IsScriptExecuting() override;
virtual void ContinueInterruptedParsingAsync() override;
// nsITransformObserver
NS_IMETHOD OnDocumentCreated(nsIDocument *aResultDocument) override;
NS_IMETHOD OnTransformDone(nsresult aResult, nsIDocument *aResultDocument) override;
// nsICSSLoaderObserver
- NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheetHandle aSheet,
+ NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheet* aSheet,
bool aWasAlternate,
nsresult aStatus) override;
static bool ParsePIData(const nsString &aData, nsString &aHref,
nsString &aTitle, nsString &aMedia,
bool &aIsAlternate);
protected:
virtual ~nsXMLContentSink();
--- a/dom/xslt/xslt/txMozillaXMLOutput.cpp
+++ b/dom/xslt/xslt/txMozillaXMLOutput.cpp
@@ -971,17 +971,17 @@ txTransformNotifier::ScriptEvaluated(nsr
if (mScriptElements.RemoveObject(aElement)) {
SignalTransformEnd();
}
return NS_OK;
}
NS_IMETHODIMP
-txTransformNotifier::StyleSheetLoaded(StyleSheetHandle aSheet,
+txTransformNotifier::StyleSheetLoaded(StyleSheet* aSheet,
bool aWasAlternate,
nsresult aStatus)
{
if (mPendingStylesheetCount == 0) {
// We weren't waiting on this stylesheet anyway. This can happen if
// SignalTransformEnd got called with an error aResult. See
// http://bugzilla.mozilla.org/show_bug.cgi?id=215465.
return NS_OK;
--- a/dom/xslt/xslt/txMozillaXMLOutput.h
+++ b/dom/xslt/xslt/txMozillaXMLOutput.h
@@ -30,17 +30,17 @@ class txTransformNotifier final : public
{
public:
txTransformNotifier();
NS_DECL_ISUPPORTS
NS_DECL_NSISCRIPTLOADEROBSERVER
// nsICSSLoaderObserver
- NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheetHandle aSheet,
+ NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheet* aSheet,
bool aWasAlternate,
nsresult aStatus) override;
void Init(nsITransformObserver* aObserver);
nsresult AddScriptElement(nsIScriptElement* aElement);
void AddPendingStylesheet();
void OnTransformEnd(nsresult aResult = NS_OK);
void OnTransformStart();
--- a/dom/xul/XULDocument.cpp
+++ b/dom/xul/XULDocument.cpp
@@ -89,18 +89,18 @@
#include "mozilla/LoadInfo.h"
#include "mozilla/Preferences.h"
#include "nsTextNode.h"
#include "nsJSUtils.h"
#include "mozilla/dom/URL.h"
#include "nsIContentPolicy.h"
#include "mozAutoDocUpdate.h"
#include "xpcpublic.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
using namespace mozilla;
using namespace mozilla::dom;
//----------------------------------------------------------------------
//
// CIDs
//
@@ -3101,17 +3101,17 @@ XULDocument::DoneWalking()
}
}
}
return NS_OK;
}
NS_IMETHODIMP
-XULDocument::StyleSheetLoaded(StyleSheetHandle aSheet,
+XULDocument::StyleSheetLoaded(StyleSheet* aSheet,
bool aWasAlternate,
nsresult aStatus)
{
if (!aWasAlternate) {
// Don't care about when alternate sheets finish loading
NS_ASSERTION(mPendingSheets > 0,
"Unexpected StyleSheetLoaded notification");
@@ -3725,17 +3725,17 @@ XULDocument::AddPrototypeSheets()
{
nsresult rv;
const nsCOMArray<nsIURI>& sheets = mCurrentPrototype->GetStyleSheetReferences();
for (int32_t i = 0; i < sheets.Count(); i++) {
nsCOMPtr<nsIURI> uri = sheets[i];
- StyleSheetHandle::RefPtr incompleteSheet;
+ RefPtr<StyleSheet> incompleteSheet;
rv = CSSLoader()->LoadSheet(uri,
mCurrentPrototype->DocumentPrincipal(),
EmptyCString(), this,
&incompleteSheet);
// XXXldb We need to prevent bogus sheets from being held in the
// prototype's list, but until then, don't propagate the failure
// from LoadSheet (and thus exit the loop).
--- a/dom/xul/XULDocument.h
+++ b/dom/xul/XULDocument.h
@@ -8,17 +8,17 @@
#include "nsAutoPtr.h"
#include "nsCOMPtr.h"
#include "nsXULPrototypeDocument.h"
#include "nsXULPrototypeCache.h"
#include "nsTArray.h"
#include "mozilla/dom/XMLDocument.h"
-#include "mozilla/StyleSheetHandle.h"
+#include "mozilla/StyleSheet.h"
#include "nsForwardReference.h"
#include "nsIContent.h"
#include "nsIDOMXULCommandDispatcher.h"
#include "nsIDOMXULDocument.h"
#include "nsCOMArray.h"
#include "nsIURI.h"
#include "nsIXULDocument.h"
#include "nsScriptLoader.h"
@@ -158,17 +158,17 @@ public:
// nsDocument interface overrides
virtual Element* GetElementById(const nsAString & elementId) override;
// nsIDOMXULDocument interface
NS_DECL_NSIDOMXULDOCUMENT
// nsICSSLoaderObserver
- NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheetHandle aSheet,
+ NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheet* aSheet,
bool aWasAlternate,
nsresult aStatus) override;
virtual void EndUpdate(nsUpdateType aUpdateType) override;
virtual bool IsDocumentRightToLeft() override;
virtual void ResetDocumentDirection() override;
@@ -339,17 +339,17 @@ protected:
*/
bool mRestrictPersistence;
nsTHashtable<nsStringHashKey> mPersistenceIds;
/**
* An array of style sheets, that will be added (preserving order) to the
* document after all of them are loaded (in DoneWalking).
*/
- nsTArray<StyleSheetHandle::RefPtr> mOverlaySheets;
+ nsTArray<RefPtr<StyleSheet>> mOverlaySheets;
nsCOMPtr<nsIDOMXULCommandDispatcher> mCommandDispatcher; // [OWNER] of the focus tracker
// Maintains the template builders that have been attached to
// content elements
typedef nsInterfaceHashtable<nsISupportsHashKey, nsIXULTemplateBuilder>
BuilderTable;
BuilderTable* mTemplateBuilderTable;
--- a/editor/libeditor/EditorBase.cpp
+++ b/editor/libeditor/EditorBase.cpp
@@ -4232,32 +4232,32 @@ EditorBase::CreateTxnForComposition(cons
RefPtr<CompositionTransaction> transaction =
new CompositionTransaction(*mIMETextNode, mIMETextOffset, mIMETextLength,
mComposition->GetRanges(), aStringToInsert,
*this);
return transaction.forget();
}
NS_IMETHODIMP
-EditorBase::CreateTxnForAddStyleSheet(StyleSheetHandle aSheet,
+EditorBase::CreateTxnForAddStyleSheet(StyleSheet* aSheet,
AddStyleSheetTransaction** aTransaction)
{
RefPtr<AddStyleSheetTransaction> transaction = new AddStyleSheetTransaction();
nsresult rv = transaction->Init(this, aSheet);
if (NS_SUCCEEDED(rv)) {
transaction.forget(aTransaction);
}
return rv;
}
NS_IMETHODIMP
EditorBase::CreateTxnForRemoveStyleSheet(
- StyleSheetHandle aSheet,
+ StyleSheet* aSheet,
RemoveStyleSheetTransaction** aTransaction)
{
RefPtr<RemoveStyleSheetTransaction> transaction =
new RemoveStyleSheetTransaction();
nsresult rv = transaction->Init(this, aSheet);
if (NS_SUCCEEDED(rv)) {
transaction.forget(aTransaction);
--- a/editor/libeditor/EditorBase.h
+++ b/editor/libeditor/EditorBase.h
@@ -4,17 +4,17 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_EditorBase_h
#define mozilla_EditorBase_h
#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc.
#include "mozilla/OwningNonNull.h" // for OwningNonNull
#include "mozilla/SelectionState.h" // for RangeUpdater, etc.
-#include "mozilla/StyleSheetHandle.h" // for StyleSheetHandle
+#include "mozilla/StyleSheet.h" // for StyleSheet
#include "mozilla/dom/Text.h"
#include "nsCOMPtr.h" // for already_AddRefed, nsCOMPtr
#include "nsCycleCollectionParticipant.h"
#include "nsGkAtoms.h"
#include "nsIEditor.h" // for nsIEditor::EDirection, etc.
#include "nsIEditorIMESupport.h" // for NS_DECL_NSIEDITORIMESUPPORT, etc.
#include "nsIObserver.h" // for NS_DECL_NSIOBSERVER, etc.
#include "nsIPhonetic.h" // for NS_DECL_NSIPHONETIC, etc.
@@ -323,24 +323,24 @@ protected:
*/
already_AddRefed<mozilla::CompositionTransaction>
CreateTxnForComposition(const nsAString& aStringToInsert);
/**
* Create a transaction for adding a style sheet.
*/
NS_IMETHOD CreateTxnForAddStyleSheet(
- StyleSheetHandle aSheet,
+ StyleSheet* aSheet,
AddStyleSheetTransaction** aTransaction);
/**
* Create a transaction for removing a style sheet.
*/
NS_IMETHOD CreateTxnForRemoveStyleSheet(
- StyleSheetHandle aSheet,
+ StyleSheet* aSheet,
RemoveStyleSheetTransaction** aTransaction);
nsresult DeleteText(nsGenericDOMDataNode& aElement,
uint32_t aOffset, uint32_t aLength);
already_AddRefed<DeleteTextTransaction>
CreateTxnForDeleteText(nsGenericDOMDataNode& aElement,
uint32_t aOffset, uint32_t aLength);
--- a/editor/libeditor/HTMLEditor.cpp
+++ b/editor/libeditor/HTMLEditor.cpp
@@ -68,18 +68,18 @@
#include "mozilla/dom/Selection.h"
#include "mozilla/dom/DocumentFragment.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/Event.h"
#include "mozilla/dom/EventTarget.h"
#include "mozilla/dom/HTMLBodyElement.h"
#include "nsTextFragment.h"
#include "nsContentList.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
namespace mozilla {
using namespace dom;
using namespace widget;
// Some utilities to handle overloading of "A" tag for link and named anchor.
static bool
@@ -2853,17 +2853,17 @@ HTMLEditor::ReplaceStyleSheet(const nsAS
return ps->GetDocument()->CSSLoader()->
LoadSheet(uaURI, false, nullptr, EmptyCString(), this);
}
NS_IMETHODIMP
HTMLEditor::RemoveStyleSheet(const nsAString& aURL)
{
- StyleSheetHandle::RefPtr sheet = GetStyleSheetForURL(aURL);
+ RefPtr<StyleSheet> sheet = GetStyleSheetForURL(aURL);
NS_ENSURE_TRUE(sheet, NS_ERROR_UNEXPECTED);
RefPtr<RemoveStyleSheetTransaction> transaction;
nsresult rv =
CreateTxnForRemoveStyleSheet(sheet, getter_AddRefs(transaction));
if (!transaction) {
rv = NS_ERROR_NULL_POINTER;
}
@@ -2893,17 +2893,17 @@ HTMLEditor::AddOverrideStyleSheet(const
nsCOMPtr<nsIURI> uaURI;
nsresult rv = NS_NewURI(getter_AddRefs(uaURI), aURL);
NS_ENSURE_SUCCESS(rv, rv);
// We MUST ONLY load synchronous local files (no @import)
// XXXbz Except this will actually try to load remote files
// synchronously, of course..
- StyleSheetHandle::RefPtr sheet;
+ RefPtr<StyleSheet> sheet;
// Editor override style sheets may want to style Gecko anonymous boxes
rv = ps->GetDocument()->CSSLoader()->
LoadSheetSync(uaURI, mozilla::css::eAgentSheetFeatures, true,
&sheet);
// Synchronous loads should ALWAYS return completed
NS_ENSURE_TRUE(sheet, NS_ERROR_NULL_POINTER);
@@ -2938,17 +2938,17 @@ HTMLEditor::ReplaceOverrideStyleSheet(co
return AddOverrideStyleSheet(aURL);
}
// Do NOT use transaction system for override style sheets
NS_IMETHODIMP
HTMLEditor::RemoveOverrideStyleSheet(const nsAString& aURL)
{
- StyleSheetHandle::RefPtr sheet = GetStyleSheetForURL(aURL);
+ RefPtr<StyleSheet> sheet = GetStyleSheetForURL(aURL);
// Make sure we remove the stylesheet from our internal list in all
// cases.
nsresult rv = RemoveStyleSheetFromList(aURL);
NS_ENSURE_TRUE(sheet, NS_OK); /// Don't fail if sheet not found
NS_ENSURE_TRUE(mDocWeak, NS_ERROR_NOT_INITIALIZED);
@@ -2961,17 +2961,17 @@ HTMLEditor::RemoveOverrideStyleSheet(con
// Remove it from our internal list
return rv;
}
NS_IMETHODIMP
HTMLEditor::EnableStyleSheet(const nsAString& aURL,
bool aEnable)
{
- StyleSheetHandle::RefPtr sheet = GetStyleSheetForURL(aURL);
+ RefPtr<StyleSheet> sheet = GetStyleSheetForURL(aURL);
NS_ENSURE_TRUE(sheet, NS_OK); // Don't fail if sheet not found
// Ensure the style sheet is owned by our document.
nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
sheet->SetOwningDocument(doc);
if (sheet->IsServo()) {
// XXXheycam ServoStyleSheets don't support being enabled/disabled yet.
@@ -2979,17 +2979,17 @@ HTMLEditor::EnableStyleSheet(const nsASt
return NS_ERROR_FAILURE;
}
return sheet->AsGecko()->SetDisabled(!aEnable);
}
bool
HTMLEditor::EnableExistingStyleSheet(const nsAString& aURL)
{
- StyleSheetHandle::RefPtr sheet = GetStyleSheetForURL(aURL);
+ RefPtr<StyleSheet> sheet = GetStyleSheetForURL(aURL);
// Enable sheet if already loaded.
if (sheet)
{
// Ensure the style sheet is owned by our document.
nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
sheet->SetOwningDocument(doc);
@@ -3001,17 +3001,17 @@ HTMLEditor::EnableExistingStyleSheet(con
sheet->AsGecko()->SetDisabled(false);
return true;
}
return false;
}
nsresult
HTMLEditor::AddNewStyleSheetToList(const nsAString& aURL,
- StyleSheetHandle aStyleSheet)
+ StyleSheet* aStyleSheet)
{
uint32_t countSS = mStyleSheets.Length();
uint32_t countU = mStyleSheetURLs.Length();
if (countSS != countU)
return NS_ERROR_UNEXPECTED;
if (!mStyleSheetURLs.AppendElement(aURL))
@@ -3031,32 +3031,32 @@ HTMLEditor::RemoveStyleSheetFromList(con
// Attempt both removals; if one fails there's not much we can do.
mStyleSheets.RemoveElementAt(foundIndex);
mStyleSheetURLs.RemoveElementAt(foundIndex);
return NS_OK;
}
-StyleSheetHandle
+StyleSheet*
HTMLEditor::GetStyleSheetForURL(const nsAString& aURL)
{
// is it already in the list?
size_t foundIndex;
foundIndex = mStyleSheetURLs.IndexOf(aURL);
if (foundIndex == mStyleSheetURLs.NoIndex) {
return nullptr;
}
MOZ_ASSERT(mStyleSheets[foundIndex]);
return mStyleSheets[foundIndex];
}
void
-HTMLEditor::GetURLForStyleSheet(StyleSheetHandle aStyleSheet,
+HTMLEditor::GetURLForStyleSheet(StyleSheet* aStyleSheet,
nsAString& aURL)
{
// is it already in the list?
int32_t foundIndex = mStyleSheets.IndexOf(aStyleSheet);
// Don't fail if we don't find it in our list
if (foundIndex == -1)
return;
@@ -3425,17 +3425,17 @@ HTMLEditor::DebugUnitTests(int32_t* outN
delete tester;
return NS_OK;
#else
return NS_ERROR_NOT_IMPLEMENTED;
#endif
}
NS_IMETHODIMP
-HTMLEditor::StyleSheetLoaded(StyleSheetHandle aSheet,
+HTMLEditor::StyleSheetLoaded(StyleSheet* aSheet,
bool aWasAlternate,
nsresult aStatus)
{
nsresult rv = NS_OK;
AutoEditBatch batchIt(this);
if (!mLastStyleSheetURL.IsEmpty())
RemoveStyleSheet(mLastStyleSheetURL);
--- a/editor/libeditor/HTMLEditor.h
+++ b/editor/libeditor/HTMLEditor.h
@@ -3,17 +3,17 @@
* 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/. */
#ifndef mozilla_HTMLEditor_h
#define mozilla_HTMLEditor_h
#include "mozilla/Attributes.h"
#include "mozilla/CSSEditUtils.h"
-#include "mozilla/StyleSheetHandle.h"
+#include "mozilla/StyleSheet.h"
#include "mozilla/TextEditor.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/File.h"
#include "nsAttrName.h"
#include "nsAutoPtr.h"
#include "nsCOMPtr.h"
#include "nsIContentFilter.h"
@@ -360,17 +360,17 @@ public:
NS_IMETHOD GetIsSelectionEditable(bool* aIsSelectionEditable) override;
NS_IMETHOD SelectAll() override;
NS_IMETHOD GetRootElement(nsIDOMElement** aRootElement) override;
// nsICSSLoaderObserver
- NS_IMETHOD StyleSheetLoaded(StyleSheetHandle aSheet,
+ NS_IMETHOD StyleSheetLoaded(StyleSheet* aSheet,
bool aWasAlternate, nsresult aStatus) override;
// Utility Routines, not part of public API
NS_IMETHOD TypedText(const nsAString& aString,
ETypingAction aAction) override;
nsresult InsertNodeAtPoint(nsIDOMNode* aNode,
nsCOMPtr<nsIDOMNode>* ioParent,
int32_t* ioOffset,
@@ -412,25 +412,25 @@ public:
/**
* Returns TRUE if sheet was loaded, false if it wasn't.
*/
bool EnableExistingStyleSheet(const nsAString& aURL);
/**
* Dealing with the internal style sheet lists.
*/
- StyleSheetHandle GetStyleSheetForURL(const nsAString& aURL);
- void GetURLForStyleSheet(StyleSheetHandle aStyleSheet,
+ StyleSheet* GetStyleSheetForURL(const nsAString& aURL);
+ void GetURLForStyleSheet(StyleSheet* aStyleSheet,
nsAString& aURL);
/**
* Add a url + known style sheet to the internal lists.
*/
nsresult AddNewStyleSheetToList(const nsAString &aURL,
- StyleSheetHandle aStyleSheet);
+ StyleSheet* aStyleSheet);
nsresult RemoveStyleSheetFromList(const nsAString &aURL);
bool IsCSSEnabled()
{
// TODO: removal of mCSSAware and use only the presence of mCSSEditUtils
return mCSSAware && mCSSEditUtils && mCSSEditUtils->IsCSSPrefChecked();
}
@@ -902,17 +902,17 @@ protected:
// Used by GetFirstSelectedCell and GetNextSelectedCell
int32_t mSelectedCellIndex;
nsString mLastStyleSheetURL;
nsString mLastOverrideStyleSheetURL;
// Maintain a list of associated style sheets and their urls.
nsTArray<nsString> mStyleSheetURLs;
- nsTArray<StyleSheetHandle::RefPtr> mStyleSheets;
+ nsTArray<RefPtr<StyleSheet>> mStyleSheets;
// an array for holding default style settings
nsTArray<PropItem*> mDefaultStyles;
protected:
// ANONYMOUS UTILS
void RemoveListenerAndDeleteRef(const nsAString& aEvent,
nsIDOMEventListener* aListener,
--- a/editor/libeditor/StyleSheetTransactions.cpp
+++ b/editor/libeditor/StyleSheetTransactions.cpp
@@ -4,42 +4,42 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "StyleSheetTransactions.h"
#include <stddef.h> // for nullptr
#include "nsAString.h"
#include "nsCOMPtr.h" // for nsCOMPtr, do_QueryInterface, etc.
-#include "mozilla/StyleSheetHandle.h" // for mozilla::StyleSheetHandle
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h" // for mozilla::StyleSheet
+#include "mozilla/StyleSheetInlines.h"
#include "nsDebug.h" // for NS_ENSURE_TRUE
#include "nsError.h" // for NS_OK, etc.
#include "nsIDOMDocument.h" // for nsIDOMDocument
#include "nsIDocument.h" // for nsIDocument
#include "nsIDocumentObserver.h" // for UPDATE_STYLE
#include "nsIEditor.h" // for nsIEditor
namespace mozilla {
static void
-AddStyleSheet(nsIEditor* aEditor, StyleSheetHandle aSheet)
+AddStyleSheet(nsIEditor* aEditor, StyleSheet* aSheet)
{
nsCOMPtr<nsIDOMDocument> domDoc;
aEditor->GetDocument(getter_AddRefs(domDoc));
nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
if (doc) {
doc->BeginUpdate(UPDATE_STYLE);
doc->AddStyleSheet(aSheet);
doc->EndUpdate(UPDATE_STYLE);
}
}
static void
-RemoveStyleSheet(nsIEditor* aEditor, StyleSheetHandle aSheet)
+RemoveStyleSheet(nsIEditor* aEditor, StyleSheet* aSheet)
{
nsCOMPtr<nsIDOMDocument> domDoc;
aEditor->GetDocument(getter_AddRefs(domDoc));
nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
if (doc) {
doc->BeginUpdate(UPDATE_STYLE);
doc->RemoveStyleSheet(aSheet);
doc->EndUpdate(UPDATE_STYLE);
@@ -59,17 +59,17 @@ NS_IMPL_CYCLE_COLLECTION_INHERITED(AddSt
EditTransactionBase,
mSheet)
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(AddStyleSheetTransaction)
NS_INTERFACE_MAP_END_INHERITING(EditTransactionBase)
NS_IMETHODIMP
AddStyleSheetTransaction::Init(nsIEditor* aEditor,
- StyleSheetHandle aSheet)
+ StyleSheet* aSheet)
{
NS_ENSURE_TRUE(aEditor && aSheet, NS_ERROR_INVALID_ARG);
mEditor = aEditor;
mSheet = aSheet;
return NS_OK;
}
@@ -113,17 +113,17 @@ NS_IMPL_CYCLE_COLLECTION_INHERITED(Remov
EditTransactionBase,
mSheet)
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(RemoveStyleSheetTransaction)
NS_INTERFACE_MAP_END_INHERITING(EditTransactionBase)
NS_IMETHODIMP
RemoveStyleSheetTransaction::Init(nsIEditor* aEditor,
- StyleSheetHandle aSheet)
+ StyleSheet* aSheet)
{
NS_ENSURE_TRUE(aEditor && aSheet, NS_ERROR_INVALID_ARG);
mEditor = aEditor;
mSheet = aSheet;
return NS_OK;
}
--- a/editor/libeditor/StyleSheetTransactions.h
+++ b/editor/libeditor/StyleSheetTransactions.h
@@ -2,72 +2,72 @@
/* 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/. */
#ifndef StylesheetTransactions_h
#define StylesheetTransactions_h
#include "mozilla/EditTransactionBase.h" // for EditTransactionBase, etc.
-#include "mozilla/StyleSheetHandle.h" // for mozilla::StyleSheetHandle
+#include "mozilla/StyleSheet.h" // for mozilla::StyleSheet
#include "nsCycleCollectionParticipant.h"
#include "nsID.h" // for REFNSIID
#include "nscore.h" // for NS_IMETHOD
class nsIEditor;
namespace mozilla {
class AddStyleSheetTransaction final : public EditTransactionBase
{
public:
/**
* Initialize the transaction.
* @param aEditor The object providing core editing operations
* @param aSheet The stylesheet to add
*/
- NS_IMETHOD Init(nsIEditor* aEditor, StyleSheetHandle aSheet);
+ NS_IMETHOD Init(nsIEditor* aEditor, StyleSheet* aSheet);
AddStyleSheetTransaction();
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(AddStyleSheetTransaction,
EditTransactionBase)
NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr) override;
NS_DECL_EDITTRANSACTIONBASE
protected:
// The editor that created this transaction.
nsIEditor* mEditor;
// The style sheet to add.
- mozilla::StyleSheetHandle::RefPtr mSheet;
+ RefPtr<mozilla::StyleSheet> mSheet;
};
class RemoveStyleSheetTransaction final : public EditTransactionBase
{
public:
/**
* Initialize the transaction.
* @param aEditor The object providing core editing operations.
* @param aSheet The stylesheet to remove.
*/
- NS_IMETHOD Init(nsIEditor* aEditor, StyleSheetHandle aSheet);
+ NS_IMETHOD Init(nsIEditor* aEditor, StyleSheet* aSheet);
RemoveStyleSheetTransaction();
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(RemoveStyleSheetTransaction,
EditTransactionBase)
NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr) override;
NS_DECL_EDITTRANSACTIONBASE
protected:
// The editor that created this transaction.
nsIEditor* mEditor;
// The style sheet to remove.
- StyleSheetHandle::RefPtr mSheet;
+ RefPtr<StyleSheet> mSheet;
};
} // namespace mozilla
#endif // #ifndef StylesheetTransactions_h
--- a/layout/base/nsDocumentViewer.cpp
+++ b/layout/base/nsDocumentViewer.cpp
@@ -37,18 +37,18 @@
#include "nsLayoutStylesheetCache.h"
#ifdef ACCESSIBILITY
#include "mozilla/a11y/DocAccessible.h"
#endif
#include "mozilla/BasicEvents.h"
#include "mozilla/Preferences.h"
#include "mozilla/dom/EncodingUtils.h"
#include "mozilla/WeakPtr.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
#include "nsViewManager.h"
#include "nsView.h"
#include "nsIPageSequenceFrame.h"
#include "nsNetUtil.h"
#include "nsIContentViewerEdit.h"
#include "nsIContentViewerFile.h"
@@ -2200,34 +2200,34 @@ nsDocumentViewer::CreateStyleSet(nsIDocu
// Caller will handle calling EndUpdate, per contract.
return styleSet;
}
auto cache = nsLayoutStylesheetCache::For(backendType);
// Handle the user sheets.
- StyleSheetHandle sheet = nullptr;
+ StyleSheet* sheet = nullptr;
if (nsContentUtils::IsInChromeDocshell(aDocument)) {
sheet = cache->UserChromeSheet();
} else {
sheet = cache->UserContentSheet();
}
if (sheet)
styleSet->AppendStyleSheet(SheetType::User, sheet);
// Append chrome sheets (scrollbars + forms).
bool shouldOverride = false;
// We don't want a docshell here for external resource docs, so just
// look at mContainer.
nsCOMPtr<nsIDocShell> ds(mContainer);
nsCOMPtr<nsIDOMEventTarget> chromeHandler;
nsCOMPtr<nsIURI> uri;
- StyleSheetHandle::RefPtr chromeSheet;
+ RefPtr<StyleSheet> chromeSheet;
if (ds) {
ds->GetChromeEventHandler(getter_AddRefs(chromeHandler));
}
if (chromeHandler) {
nsCOMPtr<nsIDOMElement> elt(do_QueryInterface(chromeHandler));
nsCOMPtr<nsIContent> content(do_QueryInterface(elt));
if (elt && content) {
@@ -2336,20 +2336,20 @@ nsDocumentViewer::CreateStyleSet(nsIDocu
if (sheet) {
styleSet->PrependStyleSheet(SheetType::Agent, sheet);
}
}
if (styleSet->IsGecko()) {
nsStyleSheetService* sheetService = nsStyleSheetService::GetInstance();
if (sheetService) {
- for (StyleSheetHandle sheet : *sheetService->AgentStyleSheets()) {
+ for (StyleSheet* sheet : *sheetService->AgentStyleSheets()) {
styleSet->AppendStyleSheet(SheetType::Agent, sheet);
}
- for (StyleSheetHandle sheet : Reversed(*sheetService->UserStyleSheets())) {
+ for (StyleSheet* sheet : Reversed(*sheetService->UserStyleSheets())) {
styleSet->PrependStyleSheet(SheetType::User, sheet);
}
}
} else {
NS_WARNING("stylo: Not yet checking nsStyleSheetService for Servo-backed "
"documents. See bug 1290224");
}
--- a/layout/base/nsIPresShell.h
+++ b/layout/base/nsIPresShell.h
@@ -20,17 +20,17 @@
#ifndef nsIPresShell_h___
#define nsIPresShell_h___
#include "mozilla/ArenaObjectID.h"
#include "mozilla/EventForwards.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/StyleSetHandle.h"
-#include "mozilla/StyleSheetHandle.h"
+#include "mozilla/StyleSheet.h"
#include "mozilla/WeakPtr.h"
#include "gfxPoint.h"
#include "nsTHashtable.h"
#include "nsHashKeys.h"
#include "nsISupports.h"
#include "nsIContent.h"
#include "nsISelectionController.h"
#include "nsQueryFrame.h"
@@ -955,33 +955,33 @@ public:
* Indicates whether theme support is enabled.
*/
bool IsThemeSupportEnabled() const { return !mIsThemeSupportDisabled; }
/**
* Get the set of agent style sheets for this presentation
*/
virtual nsresult GetAgentStyleSheets(
- nsTArray<mozilla::StyleSheetHandle::RefPtr>& aSheets) = 0;
+ nsTArray<RefPtr<mozilla::StyleSheet>>& aSheets) = 0;
/**
* Replace the set of agent style sheets
*/
virtual nsresult SetAgentStyleSheets(
- const nsTArray<mozilla::StyleSheetHandle::RefPtr>& aSheets) = 0;
+ const nsTArray<RefPtr<mozilla::StyleSheet>>& aSheets) = 0;
/**
* Add an override style sheet for this presentation
*/
- virtual nsresult AddOverrideStyleSheet(mozilla::StyleSheetHandle aSheet) = 0;
+ virtual nsresult AddOverrideStyleSheet(mozilla::StyleSheet* aSheet) = 0;
/**
* Remove an override style sheet
*/
- virtual nsresult RemoveOverrideStyleSheet(mozilla::StyleSheetHandle aSheet) = 0;
+ virtual nsresult RemoveOverrideStyleSheet(mozilla::StyleSheet* aSheet) = 0;
/**
* Reconstruct frames for all elements in the document
*/
virtual nsresult ReconstructFrames() = 0;
/**
* Notify that a content node's state has changed
--- a/layout/base/nsPresContext.cpp
+++ b/layout/base/nsPresContext.cpp
@@ -69,18 +69,18 @@
#include "nsFrameLoader.h"
#include "mozilla/dom/FontFaceSet.h"
#include "nsContentUtils.h"
#include "nsPIWindowRoot.h"
#include "mozilla/Preferences.h"
#include "gfxTextRun.h"
#include "nsFontFaceUtils.h"
#include "nsLayoutStylesheetCache.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
#if defined(MOZ_WIDGET_GTK)
#include "gfxPlatformGtk.h" // xxx - for UseFcFontList
#endif
// Needed for Start/Stop of Image Animation
#include "imgIContainer.h"
@@ -1150,17 +1150,17 @@ nsPresContext::CompatibilityModeChanged(
bool needsQuirkSheet = CompatibilityMode() == eCompatibility_NavQuirks;
if (mQuirkSheetAdded == needsQuirkSheet) {
return;
}
StyleSetHandle styleSet = mShell->StyleSet();
auto cache = nsLayoutStylesheetCache::For(styleSet->BackendType());
- StyleSheetHandle sheet = cache->QuirkSheet();
+ StyleSheet* sheet = cache->QuirkSheet();
if (needsQuirkSheet) {
// quirk.css needs to come after html.css; we just keep it at the end.
DebugOnly<nsresult> rv =
styleSet->AppendStyleSheet(SheetType::Agent, sheet);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "failed to insert quirk.css");
} else {
DebugOnly<nsresult> rv =
--- a/layout/base/nsPresShell.cpp
+++ b/layout/base/nsPresShell.cpp
@@ -188,18 +188,18 @@
#include "nsSubDocumentFrame.h"
#include "nsQueryObject.h"
#include "nsLayoutStylesheetCache.h"
#include "mozilla/layers/InputAPZContext.h"
#include "mozilla/layers/ScrollInputMethods.h"
#include "nsStyleSet.h"
#include "mozilla/StyleSetHandle.h"
#include "mozilla/StyleSetHandleInlines.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
#ifdef ANDROID
#include "nsIDocShellTreeOwner.h"
#endif
#ifdef MOZ_B2G
#include "nsIHardwareKeyHandler.h"
#endif
@@ -1369,17 +1369,17 @@ PresShell::UpdatePreferenceStyles()
// needs to recreate the pref style sheet, it has somewhere to get the
// pref styling information from. All pres contexts for
// IsChromeOriginImage() == false will have the same pref styling information,
// and similarly for IsChromeOriginImage() == true, so it doesn't really
// matter which pres context we pass in when it does need to be recreated.
// (See nsPresContext::GetDocumentColorPreferences for how whether we
// are a chrome origin image affects some pref styling information.)
auto cache = nsLayoutStylesheetCache::For(mStyleSet->BackendType());
- StyleSheetHandle::RefPtr newPrefSheet =
+ RefPtr<StyleSheet> newPrefSheet =
mPresContext->IsChromeOriginImage() ?
cache->ChromePreferenceSheet(mPresContext) :
cache->ContentPreferenceSheet(mPresContext);
if (mPrefStyleSheet == newPrefSheet) {
return;
}
@@ -1416,26 +1416,26 @@ PresShell::AddUserSheet(nsISupports* aSh
// for the ordering. Just remove and readd all the nsStyleSheetService
// sheets.
nsCOMPtr<nsIStyleSheetService> dummy =
do_GetService(NS_STYLESHEETSERVICE_CONTRACTID);
mStyleSet->BeginUpdate();
nsStyleSheetService* sheetService = nsStyleSheetService::gInstance;
- nsTArray<StyleSheetHandle::RefPtr>& userSheets = *sheetService->UserStyleSheets();
+ nsTArray<RefPtr<StyleSheet>>& userSheets = *sheetService->UserStyleSheets();
// Iterate forwards when removing so the searches for RemoveStyleSheet are as
// short as possible.
- for (StyleSheetHandle sheet : userSheets) {
+ for (StyleSheet* sheet : userSheets) {
mStyleSet->RemoveStyleSheet(SheetType::User, sheet);
}
// Now iterate backwards, so that the order of userSheets will be the same as
// the order of sheets from it in the style set.
- for (StyleSheetHandle sheet : Reversed(userSheets)) {
+ for (StyleSheet* sheet : Reversed(userSheets)) {
mStyleSet->PrependStyleSheet(SheetType::User, sheet);
}
mStyleSet->EndUpdate();
RestyleForCSSRuleChanges();
}
@@ -1462,17 +1462,17 @@ PresShell::AddAuthorSheet(nsISupports* a
RefPtr<CSSStyleSheet> sheet = do_QueryObject(aSheet);
if (!sheet) {
NS_ERROR("stylo: AddAuthorSheet needs to support ServoStyleSheets");
return;
}
// Document specific "additional" Author sheets should be stronger than the
// ones added with the StyleSheetService.
- StyleSheetHandle firstAuthorSheet =
+ StyleSheet* firstAuthorSheet =
mDocument->GetFirstAdditionalAuthorSheet();
if (firstAuthorSheet) {
mStyleSet->InsertStyleSheetBefore(SheetType::Doc, sheet, firstAuthorSheet);
} else {
mStyleSet->AppendStyleSheet(SheetType::Doc, sheet);
}
RestyleForCSSRuleChanges();
@@ -4493,17 +4493,17 @@ nsIPresShell::RestyleForCSSRuleChanges()
for (Element* scopeRoot : scopeRoots) {
restyleManager->PostRestyleEvent(scopeRoot, eRestyle_Subtree,
nsChangeHint(0));
}
}
}
void
-PresShell::RecordStyleSheetChange(StyleSheetHandle aStyleSheet)
+PresShell::RecordStyleSheetChange(StyleSheet* aStyleSheet)
{
// too bad we can't check that the update is UPDATE_STYLE
NS_ASSERTION(mUpdateCount != 0, "must be in an update");
if (mStylesHaveChanged)
return;
if (aStyleSheet->IsGecko()) {
@@ -4517,61 +4517,61 @@ PresShell::RecordStyleSheetChange(StyleS
NS_WARNING("stylo: ServoStyleSheets don't support <style scoped>");
return;
}
mStylesHaveChanged = true;
}
void
-PresShell::StyleSheetAdded(StyleSheetHandle aStyleSheet,
+PresShell::StyleSheetAdded(StyleSheet* aStyleSheet,
bool aDocumentSheet)
{
// We only care when enabled sheets are added
NS_PRECONDITION(aStyleSheet, "Must have a style sheet!");
if (aStyleSheet->IsApplicable() && aStyleSheet->HasRules()) {
RecordStyleSheetChange(aStyleSheet);
}
}
void
-PresShell::StyleSheetRemoved(StyleSheetHandle aStyleSheet,
+PresShell::StyleSheetRemoved(StyleSheet* aStyleSheet,
bool aDocumentSheet)
{
// We only care when enabled sheets are removed
NS_PRECONDITION(aStyleSheet, "Must have a style sheet!");
if (aStyleSheet->IsApplicable() && aStyleSheet->HasRules()) {
RecordStyleSheetChange(aStyleSheet);
}
}
void
-PresShell::StyleSheetApplicableStateChanged(StyleSheetHandle aStyleSheet)
+PresShell::StyleSheetApplicableStateChanged(StyleSheet* aStyleSheet)
{
if (aStyleSheet->HasRules()) {
RecordStyleSheetChange(aStyleSheet);
}
}
void
-PresShell::StyleRuleChanged(StyleSheetHandle aStyleSheet)
+PresShell::StyleRuleChanged(StyleSheet* aStyleSheet)
{
RecordStyleSheetChange(aStyleSheet);
}
void
-PresShell::StyleRuleAdded(StyleSheetHandle aStyleSheet)
+PresShell::StyleRuleAdded(StyleSheet* aStyleSheet)
{
RecordStyleSheetChange(aStyleSheet);
}
void
-PresShell::StyleRuleRemoved(StyleSheetHandle aStyleSheet)
+PresShell::StyleRuleRemoved(StyleSheet* aStyleSheet)
{
RecordStyleSheetChange(aStyleSheet);
}
nsIFrame*
PresShell::GetPlaceholderFrameFor(nsIFrame* aFrame) const
{
return mFrameConstructor->GetPlaceholderFrameFor(aFrame);
@@ -8905,47 +8905,47 @@ PresShell::IsVisible()
nsIFrame* frame = view->GetFrame();
if (!frame)
return true;
return frame->IsVisibleConsideringAncestors(nsIFrame::VISIBILITY_CROSS_CHROME_CONTENT_BOUNDARY);
}
nsresult
-PresShell::GetAgentStyleSheets(nsTArray<StyleSheetHandle::RefPtr>& aSheets)
+PresShell::GetAgentStyleSheets(nsTArray<RefPtr<StyleSheet>>& aSheets)
{
aSheets.Clear();
int32_t sheetCount = mStyleSet->SheetCount(SheetType::Agent);
if (!aSheets.SetCapacity(sheetCount, fallible)) {
return NS_ERROR_OUT_OF_MEMORY;
}
for (int32_t i = 0; i < sheetCount; ++i) {
- StyleSheetHandle sheet = mStyleSet->StyleSheetAt(SheetType::Agent, i);
+ StyleSheet* sheet = mStyleSet->StyleSheetAt(SheetType::Agent, i);
aSheets.AppendElement(sheet);
}
return NS_OK;
}
nsresult
-PresShell::SetAgentStyleSheets(const nsTArray<StyleSheetHandle::RefPtr>& aSheets)
+PresShell::SetAgentStyleSheets(const nsTArray<RefPtr<StyleSheet>>& aSheets)
{
return mStyleSet->ReplaceSheets(SheetType::Agent, aSheets);
}
nsresult
-PresShell::AddOverrideStyleSheet(StyleSheetHandle aSheet)
+PresShell::AddOverrideStyleSheet(StyleSheet* aSheet)
{
return mStyleSet->PrependStyleSheet(SheetType::Override, aSheet);
}
nsresult
-PresShell::RemoveOverrideStyleSheet(StyleSheetHandle aSheet)
+PresShell::RemoveOverrideStyleSheet(StyleSheet* aSheet)
{
return mStyleSet->RemoveStyleSheet(SheetType::Override, aSheet);
}
static void
FreezeElement(nsISupports *aSupports, void * /* unused */)
{
nsCOMPtr<nsIObjectLoadingContent> olc(do_QueryInterface(aSupports));
--- a/layout/base/nsPresShell.h
+++ b/layout/base/nsPresShell.h
@@ -177,22 +177,22 @@ public:
virtual void SetIgnoreFrameDestruction(bool aIgnore) override;
virtual void NotifyDestroyingFrame(nsIFrame* aFrame) override;
virtual nsresult CaptureHistoryState(nsILayoutHistoryState** aLayoutHistoryState) override;
virtual void UnsuppressPainting() override;
virtual nsresult GetAgentStyleSheets(
- nsTArray<mozilla::StyleSheetHandle::RefPtr>& aSheets) override;
+ nsTArray<RefPtr<mozilla::StyleSheet>>& aSheets) override;
virtual nsresult SetAgentStyleSheets(
- const nsTArray<mozilla::StyleSheetHandle::RefPtr>& aSheets) override;
+ const nsTArray<RefPtr<mozilla::StyleSheet>>& aSheets) override;
- virtual nsresult AddOverrideStyleSheet(mozilla::StyleSheetHandle aSheet) override;
- virtual nsresult RemoveOverrideStyleSheet(mozilla::StyleSheetHandle aSheet) override;
+ virtual nsresult AddOverrideStyleSheet(mozilla::StyleSheet* aSheet) override;
+ virtual nsresult RemoveOverrideStyleSheet(mozilla::StyleSheet* aSheet) override;
virtual nsresult HandleEventWithTarget(
mozilla::WidgetEvent* aEvent,
nsIFrame* aFrame,
nsIContent* aContent,
nsEventStatus* aStatus) override;
virtual nsIFrame* GetEventTargetFrame() override;
virtual already_AddRefed<nsIContent> GetEventTargetContent(
@@ -534,17 +534,17 @@ protected:
#ifdef DEBUG
nsStyleSet* CloneStyleSet(nsStyleSet* aSet);
bool VerifyIncrementalReflow();
bool mInVerifyReflow;
void ShowEventTargetDebug();
#endif
- void RecordStyleSheetChange(mozilla::StyleSheetHandle aStyleSheet);
+ void RecordStyleSheetChange(mozilla::StyleSheet* aStyleSheet);
void RemovePreferenceStyles();
// methods for painting a range to an offscreen buffer
// given a display list, clip the items within the list to
// the range
nsRect ClipListToRange(nsDisplayListBuilder *aBuilder,
@@ -855,17 +855,17 @@ protected:
// reason.
nsPoint mMouseLocation;
// This is an APZ state variable that tracks the target guid for the last
// mouse event that was processed (corresponding to mMouseLocation). This is
// needed for the synthetic mouse events.
mozilla::layers::ScrollableLayerGuid mMouseEventTargetGuid;
// mStyleSet owns it but we maintain a ref, may be null
- mozilla::StyleSheetHandle::RefPtr mPrefStyleSheet;
+ RefPtr<mozilla::StyleSheet> mPrefStyleSheet;
// Set of frames that we should mark with NS_FRAME_HAS_DIRTY_CHILDREN after
// we finish reflowing mCurrentReflowRoot.
nsTHashtable<nsPtrHashKey<nsIFrame> > mFramesToDirty;
// Reflow roots that need to be reflowed.
nsTArray<nsIFrame*> mDirtyRoots;
--- a/layout/base/nsStyleSheetService.cpp
+++ b/layout/base/nsStyleSheetService.cpp
@@ -4,18 +4,18 @@
* 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/CSSStyleSheet.h"
#include "mozilla/MemoryReporting.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.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/ipc/URIUtils.h"
#include "nsIURI.h"
#include "nsCOMPtr.h"
#include "nsICategoryManager.h"
#include "nsISupportsPrimitives.h"
@@ -76,17 +76,17 @@ nsStyleSheetService::RegisterFromEnumera
nsCOMPtr<nsIURI> uri;
NS_NewURI(getter_AddRefs(uri), spec);
if (uri)
LoadAndRegisterSheetInternal(uri, aSheetType);
}
}
int32_t
-nsStyleSheetService::FindSheetByURI(const nsTArray<StyleSheetHandle::RefPtr>& aSheets,
+nsStyleSheetService::FindSheetByURI(const nsTArray<RefPtr<StyleSheet>>& aSheets,
nsIURI* aSheetURI)
{
for (int32_t i = aSheets.Length() - 1; i >= 0; i-- ) {
bool bEqual;
nsIURI* uri = aSheets[i]->GetSheetURI();
if (uri
&& NS_SUCCEEDED(uri->Equals(aSheetURI, &bEqual))
&& bEqual) {
@@ -153,17 +153,17 @@ nsStyleSheetService::LoadAndRegisterShee
}
nsCOMPtr<nsIObserverService> serv = services::GetObserverService();
if (serv) {
// We're guaranteed that the new sheet is the last sheet in
// mSheets[aSheetType]
// XXXheycam Once the nsStyleSheetService can hold ServoStyleSheets too,
// we'll need to include them in the notification.
- StyleSheetHandle sheet = mSheets[aSheetType].LastElement();
+ StyleSheet* sheet = mSheets[aSheetType].LastElement();
if (sheet->IsGecko()) {
CSSStyleSheet* cssSheet = sheet->AsGecko();
serv->NotifyObservers(NS_ISUPPORTS_CAST(nsIDOMCSSStyleSheet*, cssSheet),
message, nullptr);
} else {
NS_ERROR("stylo: can't notify observers of ServoStyleSheets");
}
}
@@ -211,17 +211,17 @@ nsStyleSheetService::LoadAndRegisterShee
NS_WARNING("invalid sheet type argument");
return NS_ERROR_INVALID_ARG;
}
// XXXheycam We'll need to load and register both a Gecko- and Servo-backed
// style sheet.
RefPtr<css::Loader> loader = new css::Loader(StyleBackendType::Gecko);
- StyleSheetHandle::RefPtr sheet;
+ RefPtr<StyleSheet> sheet;
nsresult rv = loader->LoadSheetSync(aSheetURI, parsingMode, true, &sheet);
NS_ENSURE_SUCCESS(rv, rv);
mSheets[aSheetType].AppendElement(sheet);
return rv;
}
@@ -265,17 +265,17 @@ nsStyleSheetService::PreloadSheet(nsIURI
return NS_ERROR_INVALID_ARG;
}
// XXXheycam PreloadSheet can't support ServoStyleSheets until they implement
// nsIDOMStyleSheet.
RefPtr<css::Loader> loader = new css::Loader(StyleBackendType::Gecko);
- StyleSheetHandle::RefPtr sheet;
+ RefPtr<StyleSheet> sheet;
nsresult rv = loader->LoadSheetSync(aSheetURI, parsingMode, true, &sheet);
NS_ENSURE_SUCCESS(rv, rv);
MOZ_ASSERT(sheet->IsGecko(),
"stylo: didn't expect Loader to create a ServoStyleSheet");
RefPtr<CSSStyleSheet> cssSheet = sheet->AsGecko();
cssSheet.forget(aSheet);
@@ -288,17 +288,17 @@ nsStyleSheetService::UnregisterSheet(nsI
{
NS_ENSURE_ARG(aSheetType == AGENT_SHEET ||
aSheetType == USER_SHEET ||
aSheetType == AUTHOR_SHEET);
NS_ENSURE_ARG_POINTER(aSheetURI);
int32_t foundIndex = FindSheetByURI(mSheets[aSheetType], aSheetURI);
NS_ENSURE_TRUE(foundIndex >= 0, NS_ERROR_INVALID_ARG);
- StyleSheetHandle::RefPtr sheet = mSheets[aSheetType][foundIndex];
+ RefPtr<StyleSheet> sheet = mSheets[aSheetType][foundIndex];
mSheets[aSheetType].RemoveElementAt(foundIndex);
const char* message;
switch (aSheetType) {
case AGENT_SHEET:
message = "agent-sheet-removed";
break;
case USER_SHEET:
@@ -371,14 +371,14 @@ nsStyleSheetService::CollectReports(nsIH
}
size_t
nsStyleSheetService::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
{
size_t n = aMallocSizeOf(this);
for (auto& sheetArray : mSheets) {
n += sheetArray.ShallowSizeOfExcludingThis(aMallocSizeOf);
- for (StyleSheetHandle sheet : sheetArray) {
+ for (StyleSheet* sheet : sheetArray) {
n += sheet->SizeOfIncludingThis(aMallocSizeOf);
}
}
return n;
}
--- a/layout/base/nsStyleSheetService.h
+++ b/layout/base/nsStyleSheetService.h
@@ -10,17 +10,17 @@
#define nsStyleSheetService_h_
#include "nsCOMArray.h"
#include "nsCOMPtr.h"
#include "nsIMemoryReporter.h"
#include "nsIStyleSheetService.h"
#include "mozilla/Attributes.h"
#include "mozilla/MemoryReporting.h"
-#include "mozilla/StyleSheetHandle.h"
+#include "mozilla/StyleSheet.h"
class nsICategoryManager;
class nsIMemoryReporter;
class nsISimpleEnumerator;
#define NS_STYLESHEETSERVICE_CID \
{ 0x3b55e72e, 0xab7e, 0x431b, \
{ 0x89, 0xc0, 0x3b, 0x06, 0xa8, 0xb1, 0x40, 0x16 } }
@@ -36,25 +36,25 @@ class nsStyleSheetService final
nsStyleSheetService();
NS_DECL_ISUPPORTS
NS_DECL_NSISTYLESHEETSERVICE
NS_DECL_NSIMEMORYREPORTER
nsresult Init();
- nsTArray<mozilla::StyleSheetHandle::RefPtr>* AgentStyleSheets()
+ nsTArray<RefPtr<mozilla::StyleSheet>>* AgentStyleSheets()
{
return &mSheets[AGENT_SHEET];
}
- nsTArray<mozilla::StyleSheetHandle::RefPtr>* UserStyleSheets()
+ nsTArray<RefPtr<mozilla::StyleSheet>>* UserStyleSheets()
{
return &mSheets[USER_SHEET];
}
- nsTArray<mozilla::StyleSheetHandle::RefPtr>* AuthorStyleSheets()
+ nsTArray<RefPtr<mozilla::StyleSheet>>* AuthorStyleSheets()
{
return &mSheets[AUTHOR_SHEET];
}
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
static nsStyleSheetService *GetInstance();
static nsStyleSheetService *gInstance;
@@ -62,20 +62,20 @@ class nsStyleSheetService final
private:
~nsStyleSheetService();
void RegisterFromEnumerator(nsICategoryManager *aManager,
const char *aCategory,
nsISimpleEnumerator *aEnumerator,
uint32_t aSheetType);
- int32_t FindSheetByURI(const nsTArray<mozilla::StyleSheetHandle::RefPtr>& aSheets,
+ int32_t FindSheetByURI(const nsTArray<RefPtr<mozilla::StyleSheet>>& aSheets,
nsIURI* aSheetURI);
// Like LoadAndRegisterSheet, but doesn't notify. If successful, the
// new sheet will be the last sheet in mSheets[aSheetType].
nsresult LoadAndRegisterSheetInternal(nsIURI *aSheetURI,
uint32_t aSheetType);
- nsTArray<mozilla::StyleSheetHandle::RefPtr> mSheets[3];
+ nsTArray<RefPtr<mozilla::StyleSheet>> mSheets[3];
};
#endif
--- a/layout/style/CSSStyleSheet.cpp
+++ b/layout/style/CSSStyleSheet.cpp
@@ -2081,17 +2081,17 @@ CSSStyleSheet::InsertRuleIntoGroup(const
}
*_retval = aIndex;
return NS_OK;
}
// nsICSSLoaderObserver implementation
NS_IMETHODIMP
-CSSStyleSheet::StyleSheetLoaded(StyleSheetHandle aSheet,
+CSSStyleSheet::StyleSheetLoaded(StyleSheet* aSheet,
bool aWasAlternate,
nsresult aStatus)
{
MOZ_ASSERT(aSheet->IsGecko(),
"why we were called back with a ServoStyleSheet?");
CSSStyleSheet* sheet = aSheet->AsGecko();
--- a/layout/style/CSSStyleSheet.h
+++ b/layout/style/CSSStyleSheet.h
@@ -190,17 +190,17 @@ public:
/**
* Like the DOM insertRule() method, but doesn't do any security checks
*/
nsresult InsertRuleInternal(const nsAString& aRule,
uint32_t aIndex, uint32_t* aReturn);
// nsICSSLoaderObserver interface
- NS_IMETHOD StyleSheetLoaded(StyleSheetHandle aSheet, bool aWasAlternate,
+ NS_IMETHOD StyleSheetLoaded(StyleSheet* aSheet, bool aWasAlternate,
nsresult aStatus) override;
void EnsureUniqueInner();
// Append all of this sheet's child sheets to aArray.
void AppendAllChildSheets(nsTArray<CSSStyleSheet*>& aArray);
bool UseForPresentation(nsPresContext* aPresContext,
--- a/layout/style/FontFaceSet.cpp
+++ b/layout/style/FontFaceSet.cpp
@@ -1687,17 +1687,17 @@ FontFaceSet::PrefEnabled()
Preferences::AddBoolVarCache(&enabled, FONT_LOADING_API_ENABLED_PREF);
}
return enabled;
}
// nsICSSLoaderObserver
NS_IMETHODIMP
-FontFaceSet::StyleSheetLoaded(StyleSheetHandle aSheet,
+FontFaceSet::StyleSheetLoaded(StyleSheet* aSheet,
bool aWasAlternate,
nsresult aStatus)
{
CheckLoadingFinished();
return NS_OK;
}
void
--- a/layout/style/FontFaceSet.h
+++ b/layout/style/FontFaceSet.h
@@ -143,17 +143,17 @@ public:
void DidRefresh();
/**
* Returns whether the "layout.css.font-loading-api.enabled" pref is true.
*/
static bool PrefEnabled();
// nsICSSLoaderObserver
- NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheetHandle aSheet,
+ NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheet* aSheet,
bool aWasAlternate,
nsresult aStatus) override;
FontFace* GetFontFaceAt(uint32_t aIndex);
void FlushUserFontSet();
static nsPresContext* GetPresContextFor(gfxUserFontSet* aUserFontSet)
--- a/layout/style/HandleRefPtr.h
+++ b/layout/style/HandleRefPtr.h
@@ -14,17 +14,17 @@
#ifndef mozilla_HandleRefPtr_h
#define mozilla_HandleRefPtr_h
namespace mozilla {
/**
* A class for holding strong references to handle-managed objects.
*
- * This is intended for use with objects like StyleSheetHandle, where
+ * This is intended for use with objects like StyleSheet*, where
* the handle type is not a pointer but which can still have ->AddRef()
* and ->Release() called on it.
*/
template<typename T>
class HandleRefPtr
{
public:
HandleRefPtr() {}
--- a/layout/style/Loader.cpp
+++ b/layout/style/Loader.cpp
@@ -48,18 +48,18 @@
#include "mozilla/css/ImportRule.h"
#include "nsThreadUtils.h"
#include "nsGkAtoms.h"
#include "nsIThreadInternal.h"
#include "nsINetworkPredictor.h"
#include "mozilla/dom/ShadowRoot.h"
#include "mozilla/dom/URL.h"
#include "mozilla/AsyncEventDispatcher.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
#include "mozilla/ConsoleReportCollector.h"
#ifdef MOZ_XUL
#include "nsXULPrototypeCache.h"
#endif
#include "nsIMediaList.h"
#include "nsIDOMStyleSheet.h"
@@ -119,36 +119,36 @@ class SheetLoadData final : public nsIRu
protected:
virtual ~SheetLoadData(void);
public:
// Data for loading a sheet linked from a document
SheetLoadData(Loader* aLoader,
const nsSubstring& aTitle,
nsIURI* aURI,
- StyleSheetHandle aSheet,
+ StyleSheet* aSheet,
nsIStyleSheetLinkingElement* aOwningElement,
bool aIsAlternate,
nsICSSLoaderObserver* aObserver,
nsIPrincipal* aLoaderPrincipal,
nsINode* aRequestingNode);
// Data for loading a sheet linked from an @import rule
SheetLoadData(Loader* aLoader,
nsIURI* aURI,
- StyleSheetHandle aSheet,
+ StyleSheet* aSheet,
SheetLoadData* aParentData,
nsICSSLoaderObserver* aObserver,
nsIPrincipal* aLoaderPrincipal,
nsINode* aRequestingNode);
// Data for loading a non-document sheet
SheetLoadData(Loader* aLoader,
nsIURI* aURI,
- StyleSheetHandle aSheet,
+ StyleSheet* aSheet,
bool aSyncLoad,
bool aUseSystemPrincipal,
const nsCString& aCharset,
nsICSSLoaderObserver* aObserver,
nsIPrincipal* aLoaderPrincipal,
nsINode* aRequestingNode);
already_AddRefed<nsIURI> GetReferrerURI();
@@ -173,17 +173,17 @@ public:
// URI we're loading. Null for inline sheets
nsCOMPtr<nsIURI> mURI;
// Should be 1 for non-inline sheets.
uint32_t mLineNumber;
// The sheet we're loading data for
- StyleSheetHandle::RefPtr mSheet;
+ RefPtr<StyleSheet> mSheet;
// Linked list of datas for the same URI as us
SheetLoadData* mNext; // strong ref
// Load data for the sheet that @import-ed us if we were @import-ed
// during the parse
RefPtr<SheetLoadData> mParentData;
@@ -295,17 +295,17 @@ static const char* const gStateStrings[]
* SheetLoadData implementation *
********************************/
NS_IMPL_ISUPPORTS(SheetLoadData, nsIUnicharStreamLoaderObserver, nsIRunnable,
nsIThreadObserver)
SheetLoadData::SheetLoadData(Loader* aLoader,
const nsSubstring& aTitle,
nsIURI* aURI,
- StyleSheetHandle aSheet,
+ StyleSheet* aSheet,
nsIStyleSheetLinkingElement* aOwningElement,
bool aIsAlternate,
nsICSSLoaderObserver* aObserver,
nsIPrincipal* aLoaderPrincipal,
nsINode* aRequestingNode)
: mLoader(aLoader),
mTitle(aTitle),
mURI(aURI),
@@ -326,17 +326,17 @@ SheetLoadData::SheetLoadData(Loader* aLo
mLoaderPrincipal(aLoaderPrincipal),
mRequestingNode(aRequestingNode)
{
NS_PRECONDITION(mLoader, "Must have a loader!");
}
SheetLoadData::SheetLoadData(Loader* aLoader,
nsIURI* aURI,
- StyleSheetHandle aSheet,
+ StyleSheet* aSheet,
SheetLoadData* aParentData,
nsICSSLoaderObserver* aObserver,
nsIPrincipal* aLoaderPrincipal,
nsINode* aRequestingNode)
: mLoader(aLoader),
mURI(aURI),
mLineNumber(1),
mSheet(aSheet),
@@ -365,17 +365,17 @@ SheetLoadData::SheetLoadData(Loader* aLo
}
NS_POSTCONDITION(!mUseSystemPrincipal || mSyncLoad,
"Shouldn't use system principal for async loads");
}
SheetLoadData::SheetLoadData(Loader* aLoader,
nsIURI* aURI,
- StyleSheetHandle aSheet,
+ StyleSheet* aSheet,
bool aSyncLoad,
bool aUseSystemPrincipal,
const nsCString& aCharset,
nsICSSLoaderObserver* aObserver,
nsIPrincipal* aLoaderPrincipal,
nsINode* aRequestingNode)
: mLoader(aLoader),
mURI(aURI),
@@ -1076,17 +1076,17 @@ Loader::CreateSheet(nsIURI* aURI,
CORSMode aCORSMode,
ReferrerPolicy aReferrerPolicy,
const nsAString& aIntegrity,
bool aSyncLoad,
bool aHasAlternateRel,
const nsAString& aTitle,
StyleSheetState& aSheetState,
bool *aIsAlternate,
- StyleSheetHandle::RefPtr* aSheet)
+ RefPtr<StyleSheet>* aSheet)
{
LOG(("css::Loader::CreateSheet"));
NS_PRECONDITION(aSheet, "Null out param!");
if (!mSheets) {
mSheets = new Sheets();
}
@@ -1095,40 +1095,40 @@ Loader::CreateSheet(nsIURI* aURI,
// Check the alternate state before doing anything else, because it
// can mess with our hashtables.
*aIsAlternate = IsAlternate(aTitle, aHasAlternateRel);
// XXXheycam Cached sheets currently must be CSSStyleSheets.
if (aURI && GetStyleBackendType() == StyleBackendType::Gecko) {
aSheetState = eSheetComplete;
- StyleSheetHandle::RefPtr sheet;
+ RefPtr<StyleSheet> sheet;
// First, the XUL cache
#ifdef MOZ_XUL
if (IsChromeURI(aURI)) {
nsXULPrototypeCache* cache = nsXULPrototypeCache::GetInstance();
if (cache) {
if (cache->IsEnabled()) {
sheet = cache->GetStyleSheet(aURI);
- LOG((" From XUL cache: %p", sheet->AsVoidPtr()));
+ LOG((" From XUL cache: %p", sheet.get()));
}
}
}
#endif
bool fromCompleteSheets = false;
if (!sheet) {
// Then our per-document complete sheets.
URIPrincipalReferrerPolicyAndCORSModeHashKey key(aURI, aLoaderPrincipal, aCORSMode, aReferrerPolicy);
- StyleSheetHandle completeSheet = nullptr;
+ StyleSheet* completeSheet = nullptr;
mSheets->mCompleteSheets.Get(&key, &completeSheet);
sheet = completeSheet;
- LOG((" From completed: %p", sheet->AsVoidPtr()));
+ LOG((" From completed: %p", sheet.get()));
fromCompleteSheets = !!sheet;
}
if (sheet) {
if (sheet->IsServo()) {
MOZ_CRASH("stylo: can't clone ServoStyleSheets yet");
}
@@ -1136,31 +1136,31 @@ Loader::CreateSheet(nsIURI* aURI,
// This sheet came from the XUL cache or our per-document hashtable; it
// better be a complete sheet.
NS_ASSERTION(sheet->AsGecko()->IsComplete(),
"Sheet thinks it's not complete while we think it is");
// Make sure it hasn't been modified; if it has, we can't use it
if (sheet->AsGecko()->IsModified()) {
LOG((" Not cloning completed sheet %p because it's been modified",
- sheet->AsVoidPtr()));
+ sheet.get()));
sheet = nullptr;
fromCompleteSheets = false;
}
}
// Then loading sheets
if (!sheet && !aSyncLoad) {
aSheetState = eSheetLoading;
SheetLoadData* loadData = nullptr;
URIPrincipalReferrerPolicyAndCORSModeHashKey key(aURI, aLoaderPrincipal, aCORSMode, aReferrerPolicy);
mSheets->mLoadingDatas.Get(&key, &loadData);
if (loadData) {
sheet = loadData->mSheet;
- LOG((" From loading: %p", sheet->AsVoidPtr()));
+ LOG((" From loading: %p", sheet.get()));
#ifdef DEBUG
bool debugEqual;
NS_ASSERTION((!aLoaderPrincipal && !loadData->mLoaderPrincipal) ||
(aLoaderPrincipal && loadData->mLoaderPrincipal &&
NS_SUCCEEDED(aLoaderPrincipal->
Equals(loadData->mLoaderPrincipal,
&debugEqual)) && debugEqual),
@@ -1170,17 +1170,17 @@ Loader::CreateSheet(nsIURI* aURI,
// Then alternate sheets
if (!sheet) {
aSheetState = eSheetPending;
loadData = nullptr;
mSheets->mPendingDatas.Get(&key, &loadData);
if (loadData) {
sheet = loadData->mSheet;
- LOG((" From pending: %p", sheet->AsVoidPtr()));
+ LOG((" From pending: %p", sheet.get()));
#ifdef DEBUG
bool debugEqual;
NS_ASSERTION((!aLoaderPrincipal && !loadData->mLoaderPrincipal) ||
(aLoaderPrincipal && loadData->mLoaderPrincipal &&
NS_SUCCEEDED(aLoaderPrincipal->
Equals(loadData->mLoaderPrincipal,
&debugEqual)) && debugEqual),
@@ -1267,17 +1267,17 @@ Loader::CreateSheet(nsIURI* aURI,
}
/**
* PrepareSheet() handles setting the media and title on the sheet, as
* well as setting the enabled state based on the title and whether
* the sheet had "alternate" in its rel.
*/
void
-Loader::PrepareSheet(StyleSheetHandle aSheet,
+Loader::PrepareSheet(StyleSheet* aSheet,
const nsSubstring& aTitle,
const nsSubstring& aMediaString,
nsMediaList* aMediaList,
Element* aScopeElement,
bool isAlternate)
{
NS_PRECONDITION(aSheet, "Must have a sheet!");
@@ -1319,17 +1319,17 @@ Loader::PrepareSheet(StyleSheetHandle aS
* linking elements
* 2) Sheets without linking elements are inserted in the order in
* which the inserting requests come in, since all of these are
* inserted during header data processing in the content sink
* 3) Sheets with linking elements are ordered based on document order
* as determined by CompareDocumentPosition.
*/
nsresult
-Loader::InsertSheetInDoc(StyleSheetHandle aSheet,
+Loader::InsertSheetInDoc(StyleSheet* aSheet,
nsIContent* aLinkingContent,
nsIDocument* aDocument)
{
LOG(("css::Loader::InsertSheetInDoc"));
NS_PRECONDITION(aSheet, "Nothing to insert");
NS_PRECONDITION(aDocument, "Must have a document to insert into");
// XXX Need to cancel pending sheet loads for this element, if any
@@ -1341,17 +1341,17 @@ Loader::InsertSheetInDoc(StyleSheetHandl
* case we'll just want to append anyway. We want to break out of
* the loop when insertionPoint points to just before the index we
* want to insert at. In other words, when we leave the loop
* insertionPoint is the index of the stylesheet that immediately
* precedes the one we're inserting.
*/
int32_t insertionPoint;
for (insertionPoint = sheetCount - 1; insertionPoint >= 0; --insertionPoint) {
- StyleSheetHandle curSheet = aDocument->GetStyleSheetAt(insertionPoint);
+ StyleSheet* curSheet = aDocument->GetStyleSheetAt(insertionPoint);
NS_ASSERTION(curSheet, "There must be a sheet here!");
nsCOMPtr<nsINode> sheetOwner = curSheet->GetOwnerNode();
if (sheetOwner && !aLinkingContent) {
// Keep moving; all sheets with a sheetOwner come after all
// sheets without a linkingNode
continue;
}
@@ -1398,18 +1398,18 @@ Loader::InsertSheetInDoc(StyleSheetHandl
* practice, we get the call to load the child sheet before the CSSOM
* has finished inserting the @import rule, so we have no idea where
* to put it anyway. So just append for now. (In the future if we
* want to insert the sheet at the correct position, we'll need to
* restore CSSStyleSheet::InsertStyleSheetAt, which was removed in
* bug 1220506.)
*/
nsresult
-Loader::InsertChildSheet(StyleSheetHandle aSheet,
- StyleSheetHandle aParentSheet,
+Loader::InsertChildSheet(StyleSheet* aSheet,
+ StyleSheet* aParentSheet,
ImportRule* aParentRule)
{
LOG(("css::Loader::InsertChildSheet"));
NS_PRECONDITION(aSheet, "Nothing to insert");
NS_PRECONDITION(aParentSheet, "Need a parent to insert into");
NS_PRECONDITION(aParentSheet, "How did we get imported?");
// XXXheycam The InsertChildSheet API doesn't work with ServoStyleSheets,
@@ -1889,17 +1889,17 @@ Loader::DoSheetComplete(SheetLoadData* a
while (data) {
if (!data->mSheetAlreadyComplete) {
// If mSheetAlreadyComplete, then the sheet could well be modified between
// when we posted the async call to SheetComplete and now, since the sheet
// was page-accessible during that whole time.
MOZ_ASSERT(!(data->mSheet->IsGecko() &&
data->mSheet->AsGecko()->IsModified()),
"should not get marked modified during parsing");
- data->mSheet->AsStyleSheet()->SetComplete();
+ data->mSheet->SetComplete();
data->ScheduleLoadEventIfNeeded(aStatus);
}
if (data->mMustNotify && (data->mObserver || !mObservers.IsEmpty())) {
// Don't notify here so we don't trigger script. Remember the
// info we need to notify, then do it later when it's safe.
aDatasToNotify.AppendElement(data);
// On append failure, just press on. We'll fail to notify the observer,
@@ -2000,17 +2000,17 @@ Loader::LoadInlineStyle(nsIContent* aEle
nsCOMPtr<nsIStyleSheetLinkingElement> owningElement(do_QueryInterface(aElement));
NS_ASSERTION(owningElement, "Element is not a style linking element!");
// Since we're not planning to load a URI, no need to hand a principal to the
// load data or to CreateSheet(). Also, OK to use CORS_NONE for the CORS
// mode and mDocument's ReferrerPolicy.
StyleSheetState state;
- StyleSheetHandle::RefPtr sheet;
+ RefPtr<StyleSheet> sheet;
nsresult rv = CreateSheet(nullptr, aElement, nullptr, eAuthorSheetFeatures,
CORS_NONE, mDocument->GetReferrerPolicy(),
EmptyString(), // no inline integrity checks
false, false, aTitle, state, aIsAlternate,
&sheet);
NS_ENSURE_SUCCESS(rv, rv);
NS_ASSERTION(state == eSheetNeedsParser,
"Inline sheets should not be cached");
@@ -2098,34 +2098,34 @@ Loader::LoadStyleLink(nsIContent* aEleme
NS_LITERAL_STRING("error"),
false, false);
loadBlockingAsyncDispatcher->PostDOMEvent();
}
return rv;
}
StyleSheetState state;
- StyleSheetHandle::RefPtr sheet;
+ RefPtr<StyleSheet> sheet;
rv = CreateSheet(aURL, aElement, principal, eAuthorSheetFeatures,
aCORSMode, aReferrerPolicy, aIntegrity, false,
aHasAlternateRel, aTitle, state, aIsAlternate,
&sheet);
NS_ENSURE_SUCCESS(rv, rv);
LOG((" Sheet is alternate: %d", *aIsAlternate));
PrepareSheet(sheet, aTitle, aMedia, nullptr, nullptr, *aIsAlternate);
rv = InsertSheetInDoc(sheet, aElement, mDocument);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIStyleSheetLinkingElement> owningElement(do_QueryInterface(aElement));
if (state == eSheetComplete) {
- LOG((" Sheet already complete: 0x%p", sheet->AsVoidPtr()));
+ LOG((" Sheet already complete: 0x%p", sheet.get()));
if (aObserver || !mObservers.IsEmpty() || owningElement) {
rv = PostLoadEvent(aURL, sheet, aObserver, *aIsAlternate,
owningElement);
return rv;
}
return NS_OK;
}
@@ -2185,17 +2185,17 @@ HaveAncestorDataWithURI(SheetLoadData *a
aData = aData->mNext;
}
return false;
}
nsresult
-Loader::LoadChildSheet(StyleSheetHandle aParentSheet,
+Loader::LoadChildSheet(StyleSheet* aParentSheet,
nsIURI* aURL,
nsMediaList* aMedia,
ImportRule* aParentRule,
LoaderReusableStyleSheets* aReusableSheets)
{
LOG(("css::Loader::LoadChildSheet"));
NS_PRECONDITION(aURL, "Must have a URI to load");
NS_PRECONDITION(aParentSheet, "Must have a parent sheet");
@@ -2207,18 +2207,18 @@ Loader::LoadChildSheet(StyleSheetHandle
LOG_URI(" Child uri: '%s'", aURL);
nsCOMPtr<nsINode> owningNode;
// check for an owning document: if none, don't bother walking up the parent
// sheets
if (aParentSheet->GetOwningDocument()) {
- StyleSheetHandle topSheet = aParentSheet;
- while (StyleSheetHandle parent = topSheet->GetParentSheet()) {
+ StyleSheet* topSheet = aParentSheet;
+ while (StyleSheet* parent = topSheet->GetParentSheet()) {
topSheet = parent;
}
owningNode = topSheet->GetOwnerNode();
}
nsISupports* context = owningNode;
if (!context) {
context = mDocument;
@@ -2252,29 +2252,29 @@ Loader::LoadChildSheet(StyleSheetHandle
// XXXheycam ServoStyleSheet doesn't implement nsICSSLoaderObserver yet.
MOZ_ASSERT(aParentSheet->IsGecko(),
"stylo: ServoStyleSheets don't support child sheet loading yet");
observer = aParentSheet->AsGecko();
}
// Now that we know it's safe to load this (passes security check and not a
// loop) do so.
- StyleSheetHandle::RefPtr sheet;
+ RefPtr<StyleSheet> sheet;
RefPtr<CSSStyleSheet> reusableSheet;
StyleSheetState state;
if (aReusableSheets && aReusableSheets->FindReusableStyleSheet(aURL, reusableSheet)) {
sheet = reusableSheet;
aParentRule->SetSheet(reusableSheet);
state = eSheetComplete;
} else {
bool isAlternate;
const nsSubstring& empty = EmptyString();
// For now, use CORS_NONE for child sheets
rv = CreateSheet(aURL, nullptr, principal,
- aParentSheet->AsStyleSheet()->ParsingMode(),
+ aParentSheet->ParsingMode(),
CORS_NONE, aParentSheet->GetReferrerPolicy(),
EmptyString(), // integrity is only checked on main sheet
parentData ? parentData->mSyncLoad : false,
false, empty, state, &isAlternate, &sheet);
NS_ENSURE_SUCCESS(rv, rv);
PrepareSheet(sheet, empty, empty, aMedia, nullptr, isAlternate);
}
@@ -2307,31 +2307,31 @@ Loader::LoadChildSheet(StyleSheetHandle
}
return rv;
}
nsresult
Loader::LoadSheetSync(nsIURI* aURL,
SheetParsingMode aParsingMode,
bool aUseSystemPrincipal,
- StyleSheetHandle::RefPtr* aSheet)
+ RefPtr<StyleSheet>* aSheet)
{
LOG(("css::Loader::LoadSheetSync"));
return InternalLoadNonDocumentSheet(aURL,
false, aParsingMode, aUseSystemPrincipal,
nullptr, EmptyCString(),
aSheet, nullptr);
}
nsresult
Loader::LoadSheet(nsIURI* aURL,
nsIPrincipal* aOriginPrincipal,
const nsCString& aCharset,
nsICSSLoaderObserver* aObserver,
- StyleSheetHandle::RefPtr* aSheet)
+ RefPtr<StyleSheet>* aSheet)
{
LOG(("css::Loader::LoadSheet(aURL, aObserver, aSheet) api call"));
NS_PRECONDITION(aSheet, "aSheet is null");
return InternalLoadNonDocumentSheet(aURL,
false, eAuthorSheetFeatures, false,
aOriginPrincipal, aCharset,
aSheet, aObserver);
}
@@ -2356,17 +2356,17 @@ Loader::LoadSheet(nsIURI* aURL,
nsresult
Loader::InternalLoadNonDocumentSheet(nsIURI* aURL,
bool aIsPreload,
SheetParsingMode aParsingMode,
bool aUseSystemPrincipal,
nsIPrincipal* aOriginPrincipal,
const nsCString& aCharset,
- StyleSheetHandle::RefPtr* aSheet,
+ RefPtr<StyleSheet>* aSheet,
nsICSSLoaderObserver* aObserver,
CORSMode aCORSMode,
ReferrerPolicy aReferrerPolicy,
const nsAString& aIntegrity)
{
NS_PRECONDITION(aURL, "Must have a URI to load");
NS_PRECONDITION(aSheet || aObserver, "Sheet and observer can't both be null");
NS_PRECONDITION(!aUseSystemPrincipal || !aObserver,
@@ -2384,17 +2384,17 @@ Loader::InternalLoadNonDocumentSheet(nsI
return NS_ERROR_NOT_AVAILABLE;
}
nsresult rv = CheckContentPolicy(aOriginPrincipal, aURL, mDocument, aIsPreload);
NS_ENSURE_SUCCESS(rv, rv);
StyleSheetState state;
bool isAlternate;
- StyleSheetHandle::RefPtr sheet;
+ RefPtr<StyleSheet> sheet;
bool syncLoad = (aObserver == nullptr);
const nsSubstring& empty = EmptyString();
rv = CreateSheet(aURL, nullptr, aOriginPrincipal, aParsingMode,
aCORSMode, aReferrerPolicy, aIntegrity, syncLoad,
false, empty, state, &isAlternate, &sheet);
NS_ENSURE_SUCCESS(rv, rv);
@@ -2427,17 +2427,17 @@ Loader::InternalLoadNonDocumentSheet(nsI
data->mMustNotify = true;
}
return rv;
}
nsresult
Loader::PostLoadEvent(nsIURI* aURI,
- StyleSheetHandle aSheet,
+ StyleSheet* aSheet,
nsICSSLoaderObserver* aObserver,
bool aWasAlternate,
nsIStyleSheetLinkingElement* aElement)
{
LOG(("css::Loader::PostLoadEvent"));
NS_PRECONDITION(aSheet, "Must have sheet");
NS_PRECONDITION(aObserver || !mObservers.IsEmpty() || aElement,
"Must have observer or element");
@@ -2647,17 +2647,17 @@ Loader::SizeOfIncludingThis(mozilla::Mal
if (mSheets) {
n += mSheets->mCompleteSheets.ShallowSizeOfExcludingThis(aMallocSizeOf);
for (auto iter = mSheets->mCompleteSheets.ConstIter();
!iter.Done();
iter.Next()) {
// If aSheet has a parent, then its parent will report it so we don't
// have to worry about it here. Likewise, if aSheet has an owning node,
// then the document that node is in will report it.
- const StyleSheetHandle sheet = iter.UserData();
+ const StyleSheet* sheet = iter.UserData();
n += (sheet->GetOwnerNode() || sheet->GetParentSheet())
? 0
: sheet->SizeOfIncludingThis(aMallocSizeOf);
}
}
n += mObservers.ShallowSizeOfExcludingThis(aMallocSizeOf);
// Measurement of the following members may be added later if DMD finds it is
--- a/layout/style/Loader.h
+++ b/layout/style/Loader.h
@@ -19,17 +19,17 @@
#include "nsTObserverArray.h"
#include "nsURIHashKey.h"
#include "mozilla/Attributes.h"
#include "mozilla/CORSMode.h"
#include "mozilla/StyleSheetInlines.h"
#include "mozilla/Maybe.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/StyleBackendType.h"
-#include "mozilla/StyleSheetHandle.h"
+#include "mozilla/StyleSheet.h"
#include "mozilla/net/ReferrerPolicy.h"
class nsICSSLoaderObserver;
class nsIConsoleReportCollector;
class nsIContent;
class nsIDocument;
class nsMediaList;
class nsIStyleSheetLinkingElement;
@@ -285,17 +285,17 @@ public:
* @param aParentSheet the parent of this child sheet
* @param aURL the URL of the child sheet
* @param aMedia the already-parsed media list for the child sheet
* @param aRule the @import rule importing this child. This is used to
* properly order the child sheet list of aParentSheet.
* @param aSavedSheets any saved style sheets which could be reused
* for this load
*/
- nsresult LoadChildSheet(StyleSheetHandle aParentSheet,
+ nsresult LoadChildSheet(StyleSheet* aParentSheet,
nsIURI* aURL,
nsMediaList* aMedia,
ImportRule* aRule,
LoaderReusableStyleSheets* aSavedSheets);
/**
* Synchronously load and return the stylesheet at aURL. Any child sheets
* will also be loaded synchronously. Note that synchronous loads over some
@@ -316,23 +316,23 @@ public:
*
* NOTE: A successful return from this method doesn't indicate anything about
* whether the data could be parsed as CSS and doesn't indicate anything
* about the status of child sheets of the returned sheet.
*/
nsresult LoadSheetSync(nsIURI* aURL,
SheetParsingMode aParsingMode,
bool aUseSystemPrincipal,
- StyleSheetHandle::RefPtr* aSheet);
+ RefPtr<StyleSheet>* aSheet);
/**
* As above, but defaults aParsingMode to eAuthorSheetFeatures and
* aUseSystemPrincipal to false.
*/
- nsresult LoadSheetSync(nsIURI* aURL, StyleSheetHandle::RefPtr* aSheet) {
+ nsresult LoadSheetSync(nsIURI* aURL, RefPtr<StyleSheet>* aSheet) {
return LoadSheetSync(aURL, eAuthorSheetFeatures, false, aSheet);
}
/**
* Asynchronously load the stylesheet at aURL. If a successful result is
* returned, aObserver is guaranteed to be notified asynchronously once the
* sheet is loaded and marked complete. This method can be used to load
* sheets not associated with a document. This method cannot be used to
@@ -351,17 +351,17 @@ public:
* Must not be null.
* @param [out] aSheet the sheet to load. Note that the sheet may well
* not be loaded by the time this method returns.
*/
nsresult LoadSheet(nsIURI* aURL,
nsIPrincipal* aOriginPrincipal,
const nsCString& aCharset,
nsICSSLoaderObserver* aObserver,
- StyleSheetHandle::RefPtr* aSheet);
+ RefPtr<StyleSheet>* aSheet);
/**
* Same as above, to be used when the caller doesn't care about the
* not-yet-loaded sheet.
*/
nsresult LoadSheet(nsIURI* aURL,
bool aIsPreload,
nsIPrincipal* aOriginPrincipal,
@@ -461,57 +461,57 @@ private:
CORSMode aCORSMode,
ReferrerPolicy aReferrerPolicy,
const nsAString& aIntegrity,
bool aSyncLoad,
bool aHasAlternateRel,
const nsAString& aTitle,
StyleSheetState& aSheetState,
bool *aIsAlternate,
- StyleSheetHandle::RefPtr* aSheet);
+ RefPtr<StyleSheet>* aSheet);
// Pass in either a media string or the nsMediaList from the
// CSSParser. Don't pass both.
// This method will set the sheet's enabled state based on isAlternate
- void PrepareSheet(StyleSheetHandle aSheet,
+ void PrepareSheet(StyleSheet* aSheet,
const nsAString& aTitle,
const nsAString& aMediaString,
nsMediaList* aMediaList,
dom::Element* aScopeElement,
bool isAlternate);
- nsresult InsertSheetInDoc(StyleSheetHandle aSheet,
+ nsresult InsertSheetInDoc(StyleSheet* aSheet,
nsIContent* aLinkingContent,
nsIDocument* aDocument);
- nsresult InsertChildSheet(StyleSheetHandle aSheet,
- StyleSheetHandle aParentSheet,
+ nsresult InsertChildSheet(StyleSheet* aSheet,
+ StyleSheet* aParentSheet,
ImportRule* aParentRule);
nsresult InternalLoadNonDocumentSheet(nsIURI* aURL,
bool aIsPreload,
SheetParsingMode aParsingMode,
bool aUseSystemPrincipal,
nsIPrincipal* aOriginPrincipal,
const nsCString& aCharset,
- StyleSheetHandle::RefPtr* aSheet,
+ RefPtr<StyleSheet>* aSheet,
nsICSSLoaderObserver* aObserver,
CORSMode aCORSMode = CORS_NONE,
ReferrerPolicy aReferrerPolicy = mozilla::net::RP_Default,
const nsAString& aIntegrity = EmptyString());
// Post a load event for aObserver to be notified about aSheet. The
// notification will be sent with status NS_OK unless the load event is
// canceled at some point (in which case it will be sent with
// NS_BINDING_ABORTED). aWasAlternate indicates the state when the load was
// initiated, not the state at some later time. aURI should be the URI the
// sheet was loaded from (may be null for inline sheets). aElement is the
// owning element for this sheet.
nsresult PostLoadEvent(nsIURI* aURI,
- StyleSheetHandle aSheet,
+ StyleSheet* aSheet,
nsICSSLoaderObserver* aObserver,
bool aWasAlternate,
nsIStyleSheetLinkingElement* aElement);
// Start the loads of all the sheets in mPendingDatas
void StartAlternateLoads();
// Handle an event posted by PostLoadEvent
@@ -540,18 +540,18 @@ private:
// datas whose observers need to be notified can be added to it.
void DoSheetComplete(SheetLoadData* aLoadData, nsresult aStatus,
LoadDataArray& aDatasToNotify);
StyleBackendType GetStyleBackendType() const;
struct Sheets {
nsBaseHashtable<URIPrincipalReferrerPolicyAndCORSModeHashKey,
- StyleSheetHandle::RefPtr,
- StyleSheetHandle> mCompleteSheets;
+ RefPtr<StyleSheet>,
+ StyleSheet*> mCompleteSheets;
nsDataHashtable<URIPrincipalReferrerPolicyAndCORSModeHashKey, SheetLoadData*>
mLoadingDatas; // weak refs
nsDataHashtable<URIPrincipalReferrerPolicyAndCORSModeHashKey, SheetLoadData*>
mPendingDatas; // weak refs
};
nsAutoPtr<Sheets> mSheets;
// We're not likely to have many levels of @import... But likely to have
--- a/layout/style/ServoStyleSet.cpp
+++ b/layout/style/ServoStyleSet.cpp
@@ -347,17 +347,17 @@ ServoStyleSet::RemoveDocStyleSheet(Servo
{
return RemoveStyleSheet(SheetType::Doc, aSheet);
}
nsresult
ServoStyleSet::AddDocStyleSheet(ServoStyleSheet* aSheet,
nsIDocument* aDocument)
{
- StyleSheetHandle::RefPtr strong(aSheet);
+ RefPtr<StyleSheet> strong(aSheet);
mSheets[SheetType::Doc].RemoveElement(aSheet);
size_t index =
aDocument->FindDocStyleSheetInsertionPoint(mSheets[SheetType::Doc], aSheet);
mSheets[SheetType::Doc].InsertElementAt(index, aSheet);
// Maintain a mirrored list of sheets on the servo side.
--- a/layout/style/StyleSetHandle.h
+++ b/layout/style/StyleSetHandle.h
@@ -6,17 +6,17 @@
#ifndef mozilla_StyleSetHandle_h
#define mozilla_StyleSetHandle_h
#include "mozilla/EventStates.h"
#include "mozilla/RefPtr.h"
#include "mozilla/SheetType.h"
#include "mozilla/StyleBackendType.h"
-#include "mozilla/StyleSheetHandle.h"
+#include "mozilla/StyleSheet.h"
#include "nsChangeHint.h"
#include "nsCSSPseudoElements.h"
#include "nsTArray.h"
namespace mozilla {
class CSSStyleSheet;
class ServoStyleSet;
namespace dom {
@@ -127,28 +127,28 @@ public:
inline already_AddRefed<nsStyleContext>
ResolvePseudoElementStyle(dom::Element* aParentElement,
mozilla::CSSPseudoElementType aType,
nsStyleContext* aParentContext,
dom::Element* aPseudoElement);
inline already_AddRefed<nsStyleContext>
ResolveAnonymousBoxStyle(nsIAtom* aPseudoTag, nsStyleContext* aParentContext,
uint32_t aFlags = 0);
- inline nsresult AppendStyleSheet(SheetType aType, StyleSheetHandle aSheet);
- inline nsresult PrependStyleSheet(SheetType aType, StyleSheetHandle aSheet);
- inline nsresult RemoveStyleSheet(SheetType aType, StyleSheetHandle aSheet);
+ inline nsresult AppendStyleSheet(SheetType aType, StyleSheet* aSheet);
+ inline nsresult PrependStyleSheet(SheetType aType, StyleSheet* aSheet);
+ inline nsresult RemoveStyleSheet(SheetType aType, StyleSheet* aSheet);
inline nsresult ReplaceSheets(SheetType aType,
- const nsTArray<StyleSheetHandle::RefPtr>& aNewSheets);
+ const nsTArray<RefPtr<StyleSheet>>& aNewSheets);
inline nsresult InsertStyleSheetBefore(SheetType aType,
- StyleSheetHandle aNewSheet,
- StyleSheetHandle aReferenceSheet);
+ StyleSheet* aNewSheet,
+ StyleSheet* aReferenceSheet);
inline int32_t SheetCount(SheetType aType) const;
- inline StyleSheetHandle StyleSheetAt(SheetType aType, int32_t aIndex) const;
- inline nsresult RemoveDocStyleSheet(StyleSheetHandle aSheet);
- inline nsresult AddDocStyleSheet(StyleSheetHandle aSheet, nsIDocument* aDocument);
+ inline StyleSheet* StyleSheetAt(SheetType aType, int32_t aIndex) const;
+ inline nsresult RemoveDocStyleSheet(StyleSheet* aSheet);
+ inline nsresult AddDocStyleSheet(StyleSheet* aSheet, nsIDocument* aDocument);
inline already_AddRefed<nsStyleContext>
ProbePseudoElementStyle(dom::Element* aParentElement,
mozilla::CSSPseudoElementType aType,
nsStyleContext* aParentContext);
inline already_AddRefed<nsStyleContext>
ProbePseudoElementStyle(dom::Element* aParentElement,
mozilla::CSSPseudoElementType aType,
nsStyleContext* aParentContext,
--- a/layout/style/StyleSetHandleInlines.h
+++ b/layout/style/StyleSetHandleInlines.h
@@ -121,39 +121,39 @@ StyleSetHandle::Ptr::ResolveAnonymousBox
nsStyleContext* aParentContext,
uint32_t aFlags)
{
FORWARD(ResolveAnonymousBoxStyle, (aPseudoTag, aParentContext, aFlags));
}
// manage the set of style sheets in the style set
nsresult
-StyleSetHandle::Ptr::AppendStyleSheet(SheetType aType, StyleSheetHandle aSheet)
+StyleSetHandle::Ptr::AppendStyleSheet(SheetType aType, StyleSheet* aSheet)
{
FORWARD_CONCRETE(AppendStyleSheet, (aType, aSheet->AsGecko()),
(aType, aSheet->AsServo()));
}
nsresult
-StyleSetHandle::Ptr::PrependStyleSheet(SheetType aType, StyleSheetHandle aSheet)
+StyleSetHandle::Ptr::PrependStyleSheet(SheetType aType, StyleSheet* aSheet)
{
FORWARD_CONCRETE(PrependStyleSheet, (aType, aSheet->AsGecko()),
(aType, aSheet->AsServo()));
}
nsresult
-StyleSetHandle::Ptr::RemoveStyleSheet(SheetType aType, StyleSheetHandle aSheet)
+StyleSetHandle::Ptr::RemoveStyleSheet(SheetType aType, StyleSheet* aSheet)
{
FORWARD_CONCRETE(RemoveStyleSheet, (aType, aSheet->AsGecko()),
(aType, aSheet->AsServo()));
}
nsresult
StyleSetHandle::Ptr::ReplaceSheets(SheetType aType,
- const nsTArray<StyleSheetHandle::RefPtr>& aNewSheets)
+ const nsTArray<RefPtr<StyleSheet>>& aNewSheets)
{
if (IsGecko()) {
nsTArray<RefPtr<CSSStyleSheet>> newSheets(aNewSheets.Length());
for (auto& sheet : aNewSheets) {
newSheets.AppendElement(sheet->AsGecko());
}
return AsGecko()->ReplaceSheets(aType, newSheets);
} else {
@@ -162,46 +162,46 @@ StyleSetHandle::Ptr::ReplaceSheets(Sheet
newSheets.AppendElement(sheet->AsServo());
}
return AsServo()->ReplaceSheets(aType, newSheets);
}
}
nsresult
StyleSetHandle::Ptr::InsertStyleSheetBefore(SheetType aType,
- StyleSheetHandle aNewSheet,
- StyleSheetHandle aReferenceSheet)
+ StyleSheet* aNewSheet,
+ StyleSheet* aReferenceSheet)
{
FORWARD_CONCRETE(
InsertStyleSheetBefore,
(aType, aNewSheet->AsGecko(), aReferenceSheet->AsGecko()),
(aType, aReferenceSheet->AsServo(), aReferenceSheet->AsServo()));
}
int32_t
StyleSetHandle::Ptr::SheetCount(SheetType aType) const
{
FORWARD(SheetCount, (aType));
}
-StyleSheetHandle
+StyleSheet*
StyleSetHandle::Ptr::StyleSheetAt(SheetType aType, int32_t aIndex) const
{
FORWARD(StyleSheetAt, (aType, aIndex));
}
nsresult
-StyleSetHandle::Ptr::RemoveDocStyleSheet(StyleSheetHandle aSheet)
+StyleSetHandle::Ptr::RemoveDocStyleSheet(StyleSheet* aSheet)
{
FORWARD_CONCRETE(RemoveDocStyleSheet, (aSheet->AsGecko()),
(aSheet->AsServo()));
}
nsresult
-StyleSetHandle::Ptr::AddDocStyleSheet(StyleSheetHandle aSheet,
+StyleSetHandle::Ptr::AddDocStyleSheet(StyleSheet* aSheet,
nsIDocument* aDocument)
{
FORWARD_CONCRETE(AddDocStyleSheet, (aSheet->AsGecko(), aDocument),
(aSheet->AsServo(), aDocument));
}
// check whether there is ::before/::after style for an element
already_AddRefed<nsStyleContext>
--- a/layout/style/StyleSheet.cpp
+++ b/layout/style/StyleSheet.cpp
@@ -59,17 +59,17 @@ void
StyleSheet::SetComplete()
{
NS_ASSERTION(!IsGecko() || !AsGecko()->mDirty,
"Can't set a dirty sheet complete!");
SheetInfo().mComplete = true;
if (mDocument && !mDisabled) {
// Let the document know
mDocument->BeginUpdate(UPDATE_STYLE);
- mDocument->SetStyleSheetApplicableState(AsHandle(), true);
+ mDocument->SetStyleSheetApplicableState(this, true);
mDocument->EndUpdate(UPDATE_STYLE);
}
if (mOwningNode && !mDisabled &&
mOwningNode->HasFlag(NODE_IS_IN_SHADOW_TREE) &&
mOwningNode->IsContent()) {
dom::ShadowRoot* shadowRoot = mOwningNode->AsContent()->GetContainingShadow();
shadowRoot->StyleSheetChanged();
--- a/layout/style/nsICSSLoaderObserver.h
+++ b/layout/style/nsICSSLoaderObserver.h
@@ -4,17 +4,17 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/* internal interface for observing CSS style sheet loads */
#ifndef nsICSSLoaderObserver_h___
#define nsICSSLoaderObserver_h___
#include "nsISupports.h"
-#include "mozilla/StyleSheetHandle.h"
+#include "mozilla/StyleSheet.h"
#define NS_ICSSLOADEROBSERVER_IID \
{ 0xf51fbf2c, 0xfe4b, 0x4a15, \
{ 0xaf, 0x7e, 0x5e, 0x20, 0x64, 0x5f, 0xaf, 0x58 } }
class nsICSSLoaderObserver : public nsISupports {
public:
NS_DECLARE_STATIC_IID_ACCESSOR(NS_ICSSLOADEROBSERVER_IID)
@@ -29,16 +29,16 @@ public:
* aIsAlternate if one of those methods were used to load the sheet,
* and will always be false otherwise.
* @param aStatus is a success code if the sheet loaded successfully and a
* failure code otherwise. Note that successful load of aSheet
* doesn't indicate anything about whether the data actually parsed
* as CSS, and doesn't indicate anything about the status of any child
* sheets of aSheet.
*/
- NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheetHandle aSheet,
+ NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheet* aSheet,
bool aWasAlternate,
nsresult aStatus) = 0;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsICSSLoaderObserver, NS_ICSSLOADEROBSERVER_IID)
#endif // nsICSSLoaderObserver_h___
--- a/layout/style/nsLayoutStylesheetCache.cpp
+++ b/layout/style/nsLayoutStylesheetCache.cpp
@@ -5,18 +5,18 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsLayoutStylesheetCache.h"
#include "nsAppDirectoryServiceDefs.h"
#include "mozilla/StyleSheetInlines.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/Preferences.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
#include "mozilla/css/Loader.h"
#include "mozilla/dom/SRIMetadata.h"
#include "nsIFile.h"
#include "nsNetUtil.h"
#include "nsIObserverService.h"
#include "nsServiceManagerUtils.h"
#include "nsIXULRuntime.h"
#include "nsPrintfCString.h"
@@ -63,184 +63,184 @@ nsLayoutStylesheetCache::Observe(nsISupp
mNumberControlSheet = nullptr;
}
else {
NS_NOTREACHED("Unexpected observer topic.");
}
return NS_OK;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::ScrollbarsSheet()
{
if (!mScrollbarsSheet) {
// Scrollbars don't need access to unsafe rules
LoadSheetURL("chrome://global/skin/scrollbars.css",
&mScrollbarsSheet, eAuthorSheetFeatures);
}
return mScrollbarsSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::FormsSheet()
{
if (!mFormsSheet) {
// forms.css needs access to unsafe rules
LoadSheetURL("resource://gre-resources/forms.css",
&mFormsSheet, eAgentSheetFeatures);
}
return mFormsSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::NumberControlSheet()
{
if (!sNumberControlEnabled) {
return nullptr;
}
if (!mNumberControlSheet) {
LoadSheetURL("resource://gre-resources/number-control.css",
&mNumberControlSheet, eAgentSheetFeatures);
}
return mNumberControlSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::UserContentSheet()
{
return mUserContentSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::UserChromeSheet()
{
return mUserChromeSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::UASheet()
{
if (!mUASheet) {
LoadSheetURL("resource://gre-resources/ua.css",
&mUASheet, eAgentSheetFeatures);
}
return mUASheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::HTMLSheet()
{
if (!mHTMLSheet) {
LoadSheetURL("resource://gre-resources/html.css",
&mHTMLSheet, eAgentSheetFeatures);
}
return mHTMLSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::MinimalXULSheet()
{
return mMinimalXULSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::XULSheet()
{
return mXULSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::QuirkSheet()
{
return mQuirkSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::SVGSheet()
{
return mSVGSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::MathMLSheet()
{
if (!mMathMLSheet) {
LoadSheetURL("resource://gre-resources/mathml.css",
&mMathMLSheet, eAgentSheetFeatures);
}
return mMathMLSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::CounterStylesSheet()
{
return mCounterStylesSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::NoScriptSheet()
{
if (!mNoScriptSheet) {
LoadSheetURL("resource://gre-resources/noscript.css",
&mNoScriptSheet, eAgentSheetFeatures);
}
return mNoScriptSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::NoFramesSheet()
{
if (!mNoFramesSheet) {
LoadSheetURL("resource://gre-resources/noframes.css",
&mNoFramesSheet, eAgentSheetFeatures);
}
return mNoFramesSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::ChromePreferenceSheet(nsPresContext* aPresContext)
{
if (!mChromePreferenceSheet) {
BuildPreferenceSheet(&mChromePreferenceSheet, aPresContext);
}
return mChromePreferenceSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::ContentPreferenceSheet(nsPresContext* aPresContext)
{
if (!mContentPreferenceSheet) {
BuildPreferenceSheet(&mContentPreferenceSheet, aPresContext);
}
return mContentPreferenceSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::ContentEditableSheet()
{
if (!mContentEditableSheet) {
LoadSheetURL("resource://gre/res/contenteditable.css",
&mContentEditableSheet, eAgentSheetFeatures);
}
return mContentEditableSheet;
}
-StyleSheetHandle
+StyleSheet*
nsLayoutStylesheetCache::DesignModeSheet()
{
if (!mDesignModeSheet) {
LoadSheetURL("resource://gre/res/designmode.css",
&mDesignModeSheet, eAgentSheetFeatures);
}
return mDesignModeSheet;
@@ -413,30 +413,30 @@ nsLayoutStylesheetCache::InitFromProfile
chromeFile->Append(NS_LITERAL_STRING("userChrome.css"));
LoadSheetFile(contentFile, &mUserContentSheet, eUserSheetFeatures);
LoadSheetFile(chromeFile, &mUserChromeSheet, eUserSheetFeatures);
}
void
nsLayoutStylesheetCache::LoadSheetURL(const char* aURL,
- StyleSheetHandle::RefPtr* aSheet,
+ RefPtr<StyleSheet>* aSheet,
SheetParsingMode aParsingMode)
{
nsCOMPtr<nsIURI> uri;
NS_NewURI(getter_AddRefs(uri), aURL);
LoadSheet(uri, aSheet, aParsingMode);
if (!aSheet) {
NS_ERROR(nsPrintfCString("Could not load %s", aURL).get());
}
}
void
nsLayoutStylesheetCache::LoadSheetFile(nsIFile* aFile,
- StyleSheetHandle::RefPtr* aSheet,
+ RefPtr<StyleSheet>* aSheet,
SheetParsingMode aParsingMode)
{
bool exists = false;
aFile->Exists(&exists);
if (!exists) return;
nsCOMPtr<nsIURI> uri;
@@ -728,17 +728,17 @@ ErrorLoadingBuiltinSheet(nsIURI* aURI, c
NS_RUNTIMEABORT(
nsPrintfCString("%s loading built-in stylesheet '%s'",
aMsg, aURI ? aURI->GetSpecOrDefault().get() : "").get());
}
void
nsLayoutStylesheetCache::LoadSheet(nsIURI* aURI,
- StyleSheetHandle::RefPtr* aSheet,
+ RefPtr<StyleSheet>* aSheet,
SheetParsingMode aParsingMode)
{
if (!aURI) {
ErrorLoadingBuiltinSheet(aURI, "null URI");
return;
}
auto& loader = mBackendType == StyleBackendType::Gecko ?
@@ -759,18 +759,18 @@ nsLayoutStylesheetCache::LoadSheet(nsIUR
nsresult rv = loader->LoadSheetSync(aURI, aParsingMode, true, aSheet);
if (NS_FAILED(rv)) {
ErrorLoadingBuiltinSheet(aURI,
nsPrintfCString("LoadSheetSync failed with error %x", rv).get());
}
}
/* static */ void
-nsLayoutStylesheetCache::InvalidateSheet(StyleSheetHandle::RefPtr* aGeckoSheet,
- StyleSheetHandle::RefPtr* aServoSheet)
+nsLayoutStylesheetCache::InvalidateSheet(RefPtr<StyleSheet>* aGeckoSheet,
+ RefPtr<StyleSheet>* aServoSheet)
{
MOZ_ASSERT(gCSSLoader_Gecko || gCSSLoader_Servo,
"pref changed before we loaded a sheet?");
const bool gotGeckoSheet = aGeckoSheet && *aGeckoSheet;
const bool gotServoSheet = aServoSheet && *aServoSheet;
// Make sure sheets have the expected types
@@ -834,35 +834,35 @@ nsLayoutStylesheetCache::InvalidatePrefe
}
if (gStyleCache_Servo) {
gStyleCache_Servo->mContentPreferenceSheet = nullptr;
gStyleCache_Servo->mChromePreferenceSheet = nullptr;
}
}
void
-nsLayoutStylesheetCache::BuildPreferenceSheet(StyleSheetHandle::RefPtr* aSheet,
+nsLayoutStylesheetCache::BuildPreferenceSheet(RefPtr<StyleSheet>* aSheet,
nsPresContext* aPresContext)
{
if (mBackendType == StyleBackendType::Gecko) {
*aSheet = new CSSStyleSheet(eAgentSheetFeatures, CORS_NONE,
mozilla::net::RP_Default);
} else {
*aSheet = new ServoStyleSheet(eAgentSheetFeatures, CORS_NONE,
mozilla::net::RP_Default, dom::SRIMetadata());
}
- StyleSheetHandle sheet = *aSheet;
+ StyleSheet* sheet = *aSheet;
nsCOMPtr<nsIURI> uri;
NS_NewURI(getter_AddRefs(uri), "about:PreferenceStyleSheet", nullptr);
MOZ_ASSERT(uri, "URI creation shouldn't fail");
sheet->SetURIs(uri, uri, uri);
- sheet->AsStyleSheet()->SetComplete();
+ sheet->SetComplete();
static const uint32_t kPreallocSize = 1024;
nsString sheetText;
sheetText.SetCapacity(kPreallocSize);
#define NS_GET_R_G_B(color_) \
NS_GET_R(color_), NS_GET_G(color_), NS_GET_B(color_)
--- a/layout/style/nsLayoutStylesheetCache.h
+++ b/layout/style/nsLayoutStylesheetCache.h
@@ -35,83 +35,83 @@ class nsLayoutStylesheetCache final
* Callers should pass in a value for aType that matches the style system
* backend type for the style set in use. (A process may call For
* and obtain nsLayoutStylesheetCache objects for both backend types,
* and a particular UA style sheet might be cached in both, one or neither
* nsLayoutStylesheetCache.)
*/
static nsLayoutStylesheetCache* For(mozilla::StyleBackendType aType);
- mozilla::StyleSheetHandle ScrollbarsSheet();
- mozilla::StyleSheetHandle FormsSheet();
+ mozilla::StyleSheet* ScrollbarsSheet();
+ mozilla::StyleSheet* FormsSheet();
// This function is expected to return nullptr when the dom.forms.number
// pref is disabled.
- mozilla::StyleSheetHandle NumberControlSheet();
- mozilla::StyleSheetHandle UserContentSheet();
- mozilla::StyleSheetHandle UserChromeSheet();
- mozilla::StyleSheetHandle UASheet();
- mozilla::StyleSheetHandle HTMLSheet();
- mozilla::StyleSheetHandle MinimalXULSheet();
- mozilla::StyleSheetHandle XULSheet();
- mozilla::StyleSheetHandle QuirkSheet();
- mozilla::StyleSheetHandle SVGSheet();
- mozilla::StyleSheetHandle MathMLSheet();
- mozilla::StyleSheetHandle CounterStylesSheet();
- mozilla::StyleSheetHandle NoScriptSheet();
- mozilla::StyleSheetHandle NoFramesSheet();
- mozilla::StyleSheetHandle ChromePreferenceSheet(nsPresContext* aPresContext);
- mozilla::StyleSheetHandle ContentPreferenceSheet(nsPresContext* aPresContext);
- mozilla::StyleSheetHandle ContentEditableSheet();
- mozilla::StyleSheetHandle DesignModeSheet();
+ mozilla::StyleSheet* NumberControlSheet();
+ mozilla::StyleSheet* UserContentSheet();
+ mozilla::StyleSheet* UserChromeSheet();
+ mozilla::StyleSheet* UASheet();
+ mozilla::StyleSheet* HTMLSheet();
+ mozilla::StyleSheet* MinimalXULSheet();
+ mozilla::StyleSheet* XULSheet();
+ mozilla::StyleSheet* QuirkSheet();
+ mozilla::StyleSheet* SVGSheet();
+ mozilla::StyleSheet* MathMLSheet();
+ mozilla::StyleSheet* CounterStylesSheet();
+ mozilla::StyleSheet* NoScriptSheet();
+ mozilla::StyleSheet* NoFramesSheet();
+ mozilla::StyleSheet* ChromePreferenceSheet(nsPresContext* aPresContext);
+ mozilla::StyleSheet* ContentPreferenceSheet(nsPresContext* aPresContext);
+ mozilla::StyleSheet* ContentEditableSheet();
+ mozilla::StyleSheet* DesignModeSheet();
static void InvalidatePreferenceSheets();
static void Shutdown();
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
private:
explicit nsLayoutStylesheetCache(mozilla::StyleBackendType aImpl);
~nsLayoutStylesheetCache();
void InitFromProfile();
void InitMemoryReporter();
void LoadSheetURL(const char* aURL,
- mozilla::StyleSheetHandle::RefPtr* aSheet,
+ RefPtr<mozilla::StyleSheet>* aSheet,
mozilla::css::SheetParsingMode aParsingMode);
void LoadSheetFile(nsIFile* aFile,
- mozilla::StyleSheetHandle::RefPtr* aSheet,
+ RefPtr<mozilla::StyleSheet>* aSheet,
mozilla::css::SheetParsingMode aParsingMode);
- void LoadSheet(nsIURI* aURI, mozilla::StyleSheetHandle::RefPtr* aSheet,
+ void LoadSheet(nsIURI* aURI, RefPtr<mozilla::StyleSheet>* aSheet,
mozilla::css::SheetParsingMode aParsingMode);
- static void InvalidateSheet(mozilla::StyleSheetHandle::RefPtr* aGeckoSheet,
- mozilla::StyleSheetHandle::RefPtr* aServoSheet);
+ static void InvalidateSheet(RefPtr<mozilla::StyleSheet>* aGeckoSheet,
+ RefPtr<mozilla::StyleSheet>* aServoSheet);
static void DependentPrefChanged(const char* aPref, void* aData);
- void BuildPreferenceSheet(mozilla::StyleSheetHandle::RefPtr* aSheet,
+ void BuildPreferenceSheet(RefPtr<mozilla::StyleSheet>* aSheet,
nsPresContext* aPresContext);
static mozilla::StaticRefPtr<nsLayoutStylesheetCache> gStyleCache_Gecko;
static mozilla::StaticRefPtr<nsLayoutStylesheetCache> gStyleCache_Servo;
static mozilla::StaticRefPtr<mozilla::css::Loader> gCSSLoader_Gecko;
static mozilla::StaticRefPtr<mozilla::css::Loader> gCSSLoader_Servo;
mozilla::StyleBackendType mBackendType;
- mozilla::StyleSheetHandle::RefPtr mChromePreferenceSheet;
- mozilla::StyleSheetHandle::RefPtr mContentEditableSheet;
- mozilla::StyleSheetHandle::RefPtr mContentPreferenceSheet;
- mozilla::StyleSheetHandle::RefPtr mCounterStylesSheet;
- mozilla::StyleSheetHandle::RefPtr mDesignModeSheet;
- mozilla::StyleSheetHandle::RefPtr mFormsSheet;
- mozilla::StyleSheetHandle::RefPtr mHTMLSheet;
- mozilla::StyleSheetHandle::RefPtr mMathMLSheet;
- mozilla::StyleSheetHandle::RefPtr mMinimalXULSheet;
- mozilla::StyleSheetHandle::RefPtr mNoFramesSheet;
- mozilla::StyleSheetHandle::RefPtr mNoScriptSheet;
- mozilla::StyleSheetHandle::RefPtr mNumberControlSheet;
- mozilla::StyleSheetHandle::RefPtr mQuirkSheet;
- mozilla::StyleSheetHandle::RefPtr mSVGSheet;
- mozilla::StyleSheetHandle::RefPtr mScrollbarsSheet;
- mozilla::StyleSheetHandle::RefPtr mUASheet;
- mozilla::StyleSheetHandle::RefPtr mUserChromeSheet;
- mozilla::StyleSheetHandle::RefPtr mUserContentSheet;
- mozilla::StyleSheetHandle::RefPtr mXULSheet;
+ RefPtr<mozilla::StyleSheet> mChromePreferenceSheet;
+ RefPtr<mozilla::StyleSheet> mContentEditableSheet;
+ RefPtr<mozilla::StyleSheet> mContentPreferenceSheet;
+ RefPtr<mozilla::StyleSheet> mCounterStylesSheet;
+ RefPtr<mozilla::StyleSheet> mDesignModeSheet;
+ RefPtr<mozilla::StyleSheet> mFormsSheet;
+ RefPtr<mozilla::StyleSheet> mHTMLSheet;
+ RefPtr<mozilla::StyleSheet> mMathMLSheet;
+ RefPtr<mozilla::StyleSheet> mMinimalXULSheet;
+ RefPtr<mozilla::StyleSheet> mNoFramesSheet;
+ RefPtr<mozilla::StyleSheet> mNoScriptSheet;
+ RefPtr<mozilla::StyleSheet> mNumberControlSheet;
+ RefPtr<mozilla::StyleSheet> mQuirkSheet;
+ RefPtr<mozilla::StyleSheet> mSVGSheet;
+ RefPtr<mozilla::StyleSheet> mScrollbarsSheet;
+ RefPtr<mozilla::StyleSheet> mUASheet;
+ RefPtr<mozilla::StyleSheet> mUserChromeSheet;
+ RefPtr<mozilla::StyleSheet> mUserContentSheet;
+ RefPtr<mozilla::StyleSheet> mXULSheet;
};
#endif
--- a/layout/style/nsMediaFeatures.cpp
+++ b/layout/style/nsMediaFeatures.cpp
@@ -15,18 +15,18 @@
#ifdef XP_WIN
#include "mozilla/LookAndFeel.h"
#endif
#include "nsCSSRuleProcessor.h"
#include "nsDeviceContext.h"
#include "nsIBaseWindow.h"
#include "nsIDocument.h"
#include "nsContentUtils.h"
-#include "mozilla/StyleSheetHandle.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
using namespace mozilla;
static const nsCSSProps::KTableEntry kOrientationKeywords[] = {
{ eCSSKeyword_portrait, NS_STYLE_ORIENTATION_PORTRAIT },
{ eCSSKeyword_landscape, NS_STYLE_ORIENTATION_LANDSCAPE },
{ eCSSKeyword_UNKNOWN, -1 }
};
--- a/layout/style/nsStyleSet.cpp
+++ b/layout/style/nsStyleSet.cpp
@@ -13,17 +13,17 @@
#include "mozilla/ArrayUtils.h"
#include "mozilla/StyleSheetInlines.h"
#include "mozilla/EffectCompositor.h"
#include "mozilla/EnumeratedRange.h"
#include "mozilla/EventStates.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/RuleProcessorCache.h"
-#include "mozilla/StyleSheetHandleInlines.h"
+#include "mozilla/StyleSheetInlines.h"
#include "nsIDocumentInlines.h"
#include "nsRuleWalker.h"
#include "nsStyleContext.h"
#include "mozilla/css/StyleRule.h"
#include "nsCSSAnonBoxes.h"
#include "nsCSSPseudoElements.h"
#include "nsCSSRuleProcessor.h"
#include "nsDataHashtable.h"
@@ -746,19 +746,19 @@ nsStyleSet::AddDocStyleSheet(CSSStyleShe
void
nsStyleSet::AppendAllXBLStyleSheets(nsTArray<mozilla::CSSStyleSheet*>& aArray) const
{
if (mBindingManager) {
// XXXheycam stylo: AppendAllSheets will need to be able to return either
// CSSStyleSheets or ServoStyleSheets, on request (and then here requesting
// CSSStyleSheets).
- AutoTArray<StyleSheetHandle, 32> sheets;
+ AutoTArray<StyleSheet*, 32> sheets;
mBindingManager->AppendAllSheets(sheets);
- for (StyleSheetHandle handle : sheets) {
+ for (StyleSheet* handle : sheets) {
MOZ_ASSERT(handle->IsGecko(), "stylo: AppendAllSheets shouldn't give us "
"ServoStyleSheets yet");
aArray.AppendElement(handle->AsGecko());
}
}
}
nsresult
@@ -2469,22 +2469,22 @@ nsStyleSet::EnsureUniqueInnerOnCSSSheets
AutoTArray<CSSStyleSheet*, 32> queue;
for (SheetType type : gCSSSheetTypes) {
for (CSSStyleSheet* sheet : mSheets[type]) {
queue.AppendElement(sheet);
}
}
if (mBindingManager) {
- AutoTArray<StyleSheetHandle, 32> sheets;
+ AutoTArray<StyleSheet*, 32> sheets;
// XXXheycam stylo: AppendAllSheets will need to be able to return either
// CSSStyleSheets or ServoStyleSheets, on request (and then here requesting
// CSSStyleSheets).
mBindingManager->AppendAllSheets(sheets);
- for (StyleSheetHandle sheet : sheets) {
+ for (StyleSheet* sheet : sheets) {
MOZ_ASSERT(sheet->IsGecko(), "stylo: AppendAllSheets shouldn't give us "
"ServoStyleSheets yet");
queue.AppendElement(sheet->AsGecko());
}
}
while (!queue.IsEmpty()) {
uint32_t idx = queue.Length() - 1;