Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-02-16 22:04:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove nsINameSpace and replace with a simple array-based list of namespace mappings for CSS. Bug 281728, r+sr=bzbarsky.

Browse Source
This commit is contained in:
bryner%brianryner.com 2005-02-18 19:18:37 +00:00
parent 48a9ab5e12
commit 58396e7490
12 changed files with 369 additions and 358 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
content/base/public/Makefile.in
View File

@ -56,7 +56,7 @@ nsContentUtils.h \
nsIDocument.h \ nsIDocument.h \
nsIDocumentEncoder.h \ nsIDocumentEncoder.h \
nsIDocumentObserver.h \ nsIDocumentObserver.h \
nsINameSpace.h \ nsNameSpaceMap.h \
nsINameSpaceManager.h \ nsINameSpaceManager.h \
nsINodeInfo.h \ nsINodeInfo.h \
nsIRangeUtils.h \ nsIRangeUtils.h \

78
content/base/public/nsINameSpace.h
View File

@ -1,78 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla Communicator client code.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef nsINameSpace_h___
#define nsINameSpace_h___
#include "nsISupports.h"
class nsIAtom;
#define NS_INAMESPACE_IID \
{ 0x72022492, 0x0fdf, 0x11d9, \
{ 0xa3, 0x76, 0x00, 0x0a, 0x95, 0xdc, 0x23, 0x4c } }
/**
* A nsINameSpace registers the NameSpace URI with the NameSpaceManager
* (creating or finding an ID), and manages the relationship between
* the NameSpace ID and the (optional) Prefix.
*
* New NameSpaces are created as a child of an existing NameSpace. Searches
* for NameSpaces based on prefix search up the chain of nested NameSpaces
*
* Each NameSpace keeps a live reference on its parent.
*
*/
class nsINameSpace : public nsISupports {
public:
NS_DEFINE_STATIC_IID_ACCESSOR(NS_INAMESPACE_IID)
// Get data of this name space
NS_IMETHOD GetNameSpaceID(PRInt32* aID) const = 0;
// Find name space within self and parents (not children)
NS_IMETHOD FindNameSpace(nsIAtom* aPrefix, nsINameSpace** aNameSpace) const = 0;
NS_IMETHOD FindNameSpaceID(nsIAtom* aPrefix, PRInt32* aNameSpaceID) const = 0;
NS_IMETHOD FindNameSpacePrefix(PRInt32 aNameSpaceID, nsIAtom** aPrefix) const = 0;
// Create new child name space
NS_IMETHOD CreateChildNameSpace(nsIAtom* aPrefix,
const nsAString& aURI,
nsINameSpace** aChildNameSpace) = 0;
};
#endif // nsINameSpace_h___

10
content/base/public/nsINameSpaceManager.h
View File

@ -43,7 +43,6 @@
class nsIAtom; class nsIAtom;
class nsString; class nsString;
class nsINameSpace;
#define kNameSpaceID_Unknown -1 #define kNameSpaceID_Unknown -1
// 0 is special at C++, so use a static const PRInt32 for // 0 is special at C++, so use a static const PRInt32 for
@ -68,8 +67,8 @@ static const PRInt32 kNameSpaceID_None = 0;
#define NS_NAMESPACEMANAGER_CONTRACTID "@mozilla.org/content/namespacemanager;1" #define NS_NAMESPACEMANAGER_CONTRACTID "@mozilla.org/content/namespacemanager;1"
#define NS_INAMESPACEMANAGER_IID \ #define NS_INAMESPACEMANAGER_IID \
{ 0x409cd4de, 0xb3ca, 0x11d8, \ { 0x30977ca5, 0xc6af, 0x4687, \
{ 0xb2, 0x67, 0x00, 0x0a, 0x95, 0xdc, 0x23, 0x4c } } { 0x88, 0x43, 0xa9, 0x7d, 0x0f, 0x95, 0x00, 0x17 } }
/** /**
* The Name Space Manager tracks the associtation between a NameSpace * The Name Space Manager tracks the associtation between a NameSpace
@ -83,9 +82,6 @@ static const PRInt32 kNameSpaceID_None = 0;
* The nsINameSpaceManager needs to have a live reference for as long as * The nsINameSpaceManager needs to have a live reference for as long as
* the NameSpace IDs are needed. * the NameSpace IDs are needed.
* *
* To create a stack of NameSpaces, call CreateRootNameSpace, and then create
* child NameSpaces from the root.
*
*/ */
class nsINameSpaceManager : public nsISupports class nsINameSpaceManager : public nsISupports
@ -93,8 +89,6 @@ class nsINameSpaceManager : public nsISupports
public: public:
NS_DEFINE_STATIC_IID_ACCESSOR(NS_INAMESPACEMANAGER_IID) NS_DEFINE_STATIC_IID_ACCESSOR(NS_INAMESPACEMANAGER_IID)
NS_IMETHOD CreateRootNameSpace(nsINameSpace** aRootNameSpace) = 0;
NS_IMETHOD RegisterNameSpace(const nsAString& aURI, NS_IMETHOD RegisterNameSpace(const nsAString& aURI,
PRInt32& aNameSpaceID) = 0; PRInt32& aNameSpaceID) = 0;

100
content/base/public/nsNameSpaceMap.h Executable file
View File

@ -0,0 +1,100 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla Communicator client code.
*
* The Initial Developer of the Original Code is
* IBM Corporation.
* Portions created by the Initial Developer are Copyright (C) 2005
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Brian Ryner <bryner@brianryner.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef nsNameSpaceMap_h_
#define nsNameSpaceMap_h_
#include "nsVoidArray.h"
class nsIAtom;
/**
* nsNameSpaceMap contains a set of prefixes which are mapped onto namespaces.
* It allows the set to be searched by prefix or by namespace ID.
*/
class nsNameSpaceMap
{
public:
/**
* Allocates a new nsNameSpaceMap (with new()) and initializes it with the
* xmlns and xml namespaces.
*/
static NS_HIDDEN_(nsNameSpaceMap*) Create();
/**
* Add a prefix and its corresponding namespace ID to the map.
* Passing a null |aPrefix| corresponds to the default namespace, which may
* be set to something other than kNameSpaceID_None.
*/
NS_HIDDEN_(nsresult) AddPrefix(nsIAtom *aPrefix, PRInt32 aNameSpaceID);
/**
* Add a prefix and a namespace URI to the map. The URI will be converted
* to its corresponding namespace ID.
*/
NS_HIDDEN_(nsresult) AddPrefix(nsIAtom *aPrefix, nsString &aURI);
/* Remove a prefix from the map. */
NS_HIDDEN_(void) RemovePrefix(nsIAtom *aPrefix);
/*
* Returns the namespace ID for the given prefix, if it is in the map.
* If |aPrefix| is null and is not in the map, then a null namespace
* (kNameSpaceID_None) is returned. If |aPrefix| is non-null and is not in
* the map, then kNameSpaceID_Unknown is returned.
*/
NS_HIDDEN_(PRInt32) FindNameSpaceID(nsIAtom *aPrefix) const;
/**
* If the given namespace ID is in the map, then the first prefix which
* maps to that namespace is returned. Otherwise, null is returned.
*/
NS_HIDDEN_(nsIAtom*) FindPrefix(PRInt32 aNameSpaceID) const;
/* Removes all prefix mappings. */
NS_HIDDEN_(void) Clear();
~nsNameSpaceMap() { Clear(); }
private:
nsNameSpaceMap() NS_HIDDEN; // use Create() to create new instances
nsVoidArray mNameSpaces;
};
#endif

1
content/base/src/Makefile.in
View File

@ -111,6 +111,7 @@ CPPSRCS = \
nsImageLoadingContent.cpp \ nsImageLoadingContent.cpp \
nsMappedAttributes.cpp \ nsMappedAttributes.cpp \
nsNameSpaceManager.cpp \ nsNameSpaceManager.cpp \
nsNameSpaceMap.cpp \
nsNodeInfo.cpp \ nsNodeInfo.cpp \
nsNodeInfoManager.cpp \ nsNodeInfoManager.cpp \
nsParserUtils.cpp \ nsParserUtils.cpp \

165
content/base/src/nsNameSpaceManager.cpp
View File

@ -36,7 +36,6 @@
* ***** END LICENSE BLOCK ***** */ * ***** END LICENSE BLOCK ***** */
#include "nscore.h" #include "nscore.h"
#include "nsINameSpaceManager.h" #include "nsINameSpaceManager.h"
#include "nsINameSpace.h"
#include "nsAutoPtr.h" #include "nsAutoPtr.h"
#include "nsINodeInfo.h" #include "nsINodeInfo.h"
#include "nsCOMArray.h" #include "nsCOMArray.h"
@ -67,37 +66,6 @@ static NS_DEFINE_CID(kXTFServiceCID, NS_XTFSERVICE_CID);
#define kRolesWAIUnofficialNameSpaceURI "http://www.w3.org/2005/01/wai-rdf/GUIRoleTaxonomy#" // Will eventually change #define kRolesWAIUnofficialNameSpaceURI "http://www.w3.org/2005/01/wai-rdf/GUIRoleTaxonomy#" // Will eventually change
#define kStatesWAIUnofficialNameSpaceURI "http://www.w3.org/2005/01/wai-rdf/GUIStateTaxonomy#" // Will eventually change #define kStatesWAIUnofficialNameSpaceURI "http://www.w3.org/2005/01/wai-rdf/GUIStateTaxonomy#" // Will eventually change
//-----------------------------------------------------------
// Name Space
class NameSpaceImpl : public nsINameSpace {
public:
NameSpaceImpl(NameSpaceImpl* aParent,
nsIAtom* aPrefix,
PRInt32 aNameSpaceID);
virtual ~NameSpaceImpl();
NS_DECL_ISUPPORTS
NS_IMETHOD GetNameSpaceID(PRInt32* aID) const;
NS_IMETHOD FindNameSpace(nsIAtom* aPrefix, nsINameSpace** aNameSpace) const;
NS_IMETHOD FindNameSpaceID(nsIAtom* aPrefix, PRInt32* aNameSpaceID) const;
NS_IMETHOD FindNameSpacePrefix(PRInt32 aNameSpaceID, nsIAtom** aPrefix) const;
NS_IMETHOD CreateChildNameSpace(nsIAtom* aPrefix, const nsAString& aURI,
nsINameSpace** aChildNameSpace);
private:
// These are not supported and are not implemented!
NameSpaceImpl(const NameSpaceImpl& aCopy);
NameSpaceImpl& operator=(const NameSpaceImpl& aCopy);
nsRefPtr<NameSpaceImpl> mParent;
nsCOMPtr<nsIAtom> mPrefix;
PRInt32 mID;
};
class nsNameSpaceEntry : public PLDHashEntryHdr class nsNameSpaceEntry : public PLDHashEntryHdr
{ {
public: public:
@ -151,8 +119,6 @@ public:
nsresult Init(); nsresult Init();
NS_IMETHOD CreateRootNameSpace(nsINameSpace** aRootNameSpace);
NS_IMETHOD RegisterNameSpace(const nsAString& aURI, NS_IMETHOD RegisterNameSpace(const nsAString& aURI,
PRInt32& aNameSpaceID); PRInt32& aNameSpaceID);
@ -178,113 +144,6 @@ private:
static NameSpaceManagerImpl* gNameSpaceManager = nsnull; static NameSpaceManagerImpl* gNameSpaceManager = nsnull;
NameSpaceImpl::NameSpaceImpl(NameSpaceImpl* aParent,
nsIAtom* aPrefix,
PRInt32 aNameSpaceID)
: mParent(aParent),
mPrefix(aPrefix),
mID(aNameSpaceID)
{
}
NameSpaceImpl::~NameSpaceImpl()
{
}
NS_IMPL_ISUPPORTS1(NameSpaceImpl, nsINameSpace)
NS_IMETHODIMP
NameSpaceImpl::GetNameSpaceID(PRInt32* aID) const
{
*aID = mID;
return NS_OK;
}
NS_IMETHODIMP
NameSpaceImpl::FindNameSpace(nsIAtom* aPrefix, nsINameSpace** aNameSpace) const
{
const NameSpaceImpl* nameSpace = this;
do {
if (aPrefix == nameSpace->mPrefix) {
*aNameSpace = (nsINameSpace*)nameSpace;
NS_ADDREF(*aNameSpace);
return NS_OK;
}
nameSpace = nameSpace->mParent;
} while (nameSpace);
*aNameSpace = nsnull;
return NS_ERROR_ILLEGAL_VALUE;
}
NS_IMETHODIMP
NameSpaceImpl::FindNameSpaceID(nsIAtom* aPrefix, PRInt32* aNameSpaceID) const
{
const NameSpaceImpl* nameSpace = this;
do {
if (aPrefix == nameSpace->mPrefix) {
*aNameSpaceID = nameSpace->mID;
return NS_OK;
}
nameSpace = nameSpace->mParent;
} while (nameSpace);
if (!aPrefix) {
*aNameSpaceID = kNameSpaceID_None;
}
else {
*aNameSpaceID = kNameSpaceID_Unknown;
}
return NS_ERROR_ILLEGAL_VALUE;
}
NS_IMETHODIMP
NameSpaceImpl::FindNameSpacePrefix(PRInt32 aNameSpaceID,
nsIAtom** aPrefix) const
{
const NameSpaceImpl* nameSpace = this;
do {
if (aNameSpaceID == nameSpace->mID) {
NS_IF_ADDREF(*aPrefix = nameSpace->mPrefix);
return NS_OK;
}
nameSpace = nameSpace->mParent;
} while (nameSpace);
*aPrefix = nsnull;
return NS_ERROR_ILLEGAL_VALUE;
}
NS_IMETHODIMP
NameSpaceImpl::CreateChildNameSpace(nsIAtom* aPrefix, const nsAString& aURI,
nsINameSpace** aChildNameSpace)
{
*aChildNameSpace = nsnull;
PRInt32 id;
nsresult rv = gNameSpaceManager->RegisterNameSpace(aURI, id);
NS_ENSURE_SUCCESS(rv, rv);
*aChildNameSpace = new NameSpaceImpl(this, aPrefix, id);
if (!*aChildNameSpace) {
return NS_ERROR_OUT_OF_MEMORY;
}
NS_ADDREF(*aChildNameSpace);
return NS_OK;
}
NameSpaceManagerImpl::NameSpaceManagerImpl() NameSpaceManagerImpl::NameSpaceManagerImpl()
{ {
} }
@ -319,30 +178,6 @@ nsresult NameSpaceManagerImpl::Init()
return NS_OK; return NS_OK;
} }
NS_IMETHODIMP
NameSpaceManagerImpl::CreateRootNameSpace(nsINameSpace** aRootNameSpace)
{
nsresult rv = NS_ERROR_OUT_OF_MEMORY;
*aRootNameSpace = nsnull;
NameSpaceImpl* xmlns = new NameSpaceImpl(nsnull,
nsLayoutAtoms::xmlnsNameSpace,
kNameSpaceID_XMLNS);
if (xmlns) {
NameSpaceImpl* xml = new NameSpaceImpl(xmlns,
nsLayoutAtoms::xmlNameSpace,
kNameSpaceID_XML);
if (xml) {
rv = CallQueryInterface(xml, aRootNameSpace);
}
else {
delete xmlns;
}
}
return rv;
}
NS_IMETHODIMP NS_IMETHODIMP
NameSpaceManagerImpl::RegisterNameSpace(const nsAString& aURI, NameSpaceManagerImpl::RegisterNameSpace(const nsAString& aURI,
PRInt32& aNameSpaceID) PRInt32& aNameSpaceID)

191
content/base/src/nsNameSpaceMap.cpp Executable file
View File

@ -0,0 +1,191 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla Communicator client code.
*
* The Initial Developer of the Original Code is
* IBM Corporation.
* Portions created by the Initial Developer are Copyright (C) 2005
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Brian Ryner <bryner@brianryner.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsNameSpaceMap.h"
#include "nsIAtom.h"
#include "nsCOMPtr.h"
#include "nsINameSpaceManager.h"
#include "nsContentUtils.h"
#include "nsLayoutAtoms.h"
struct nsNameSpaceEntry
{
nsNameSpaceEntry(nsIAtom *aPrefix)
: prefix(aPrefix) {}
nsCOMPtr<nsIAtom> prefix;
PRInt32 nameSpaceID;
};
/* static */ nsNameSpaceMap*
nsNameSpaceMap::Create()
{
nsNameSpaceMap *map = new nsNameSpaceMap();
NS_ENSURE_TRUE(map, nsnull);
nsresult rv = map->AddPrefix(nsLayoutAtoms::xmlnsNameSpace,
kNameSpaceID_XMLNS);
rv |= map->AddPrefix(nsLayoutAtoms::xmlNameSpace, kNameSpaceID_XML);
if (NS_FAILED(rv)) {
delete map;
map = nsnull;
}
return map;
}
nsNameSpaceMap::nsNameSpaceMap()
: mNameSpaces(4)
{
}
nsresult
nsNameSpaceMap::AddPrefix(nsIAtom *aPrefix, PRInt32 aNameSpaceID)
{
PRInt32 count = mNameSpaces.Count();
nsNameSpaceEntry *foundEntry = nsnull;
for (PRInt32 i = 0; i < count; ++i) {
nsNameSpaceEntry *entry = NS_STATIC_CAST(nsNameSpaceEntry*,
mNameSpaces.FastElementAt(i));
NS_ASSERTION(entry, "null entry in namespace map!");
if (entry->prefix == aPrefix) {
foundEntry = entry;
break;
}
}
if (!foundEntry) {
foundEntry = new nsNameSpaceEntry(aPrefix);
NS_ENSURE_TRUE(foundEntry, NS_ERROR_OUT_OF_MEMORY);
if (!mNameSpaces.AppendElement(foundEntry)) {
delete foundEntry;
return NS_ERROR_OUT_OF_MEMORY;
}
}
foundEntry->nameSpaceID = aNameSpaceID;
return NS_OK;
}
nsresult
nsNameSpaceMap::AddPrefix(nsIAtom *aPrefix, nsString &aURI)
{
PRInt32 id;
nsresult rv = nsContentUtils::GetNSManagerWeakRef()->RegisterNameSpace(aURI,
id);
NS_ENSURE_SUCCESS(rv, rv);
return AddPrefix(aPrefix, id);
}
void
nsNameSpaceMap::RemovePrefix(nsIAtom *aPrefix)
{
PRInt32 count = mNameSpaces.Count();
for (PRInt32 i = 0; i < count; ++i) {
nsNameSpaceEntry *entry = NS_STATIC_CAST(nsNameSpaceEntry*,
mNameSpaces.FastElementAt(i));
NS_ASSERTION(entry, "null entry in namespace map!");
if (entry->prefix == aPrefix) {
mNameSpaces.RemoveElementAt(i);
return;
}
}
}
PRInt32
nsNameSpaceMap::FindNameSpaceID(nsIAtom *aPrefix) const
{
PRInt32 count = mNameSpaces.Count();
for (PRInt32 i = 0; i < count; ++i) {
nsNameSpaceEntry *entry = NS_STATIC_CAST(nsNameSpaceEntry*,
mNameSpaces.FastElementAt(i));
NS_ASSERTION(entry, "null entry in namespace map!");
if (entry->prefix == aPrefix) {
return entry->nameSpaceID;
}
}
// The default mapping for no prefix is no namespace. If a non-null prefix
// was specified and we didn't find it, we return an error.
return aPrefix ? kNameSpaceID_Unknown : kNameSpaceID_None;
}
nsIAtom*
nsNameSpaceMap::FindPrefix(PRInt32 aNameSpaceID) const
{
PRInt32 count = mNameSpaces.Count();
for (PRInt32 i = 0; i < count; ++i) {
nsNameSpaceEntry *entry = NS_STATIC_CAST(nsNameSpaceEntry*,
mNameSpaces.FastElementAt(i));
NS_ASSERTION(entry, "null entry in namespace map!");
if (entry->nameSpaceID == aNameSpaceID) {
return entry->prefix;
}
}
return nsnull;
}
PR_STATIC_CALLBACK(PRBool) DeleteEntry(void *aElement, void *aData)
{
delete NS_STATIC_CAST(nsNameSpaceEntry*, aElement);
return PR_TRUE;
}
void
nsNameSpaceMap::Clear()
{
mNameSpaces.EnumerateForwards(DeleteEntry, nsnull);
}

60
layout/style/nsCSSParser.cpp
View File

@ -68,7 +68,7 @@
#include "nsCSSPseudoElements.h" #include "nsCSSPseudoElements.h"
#include "nsCSSAnonBoxes.h" #include "nsCSSAnonBoxes.h"
#include "nsINameSpaceManager.h" #include "nsINameSpaceManager.h"
#include "nsINameSpace.h" #include "nsNameSpaceMap.h"
#include "nsThemeConstants.h" #include "nsThemeConstants.h"
#include "nsContentErrors.h" #include "nsContentErrors.h"
#include "nsUnitConversion.h" #include "nsUnitConversion.h"
@ -367,7 +367,7 @@ protected:
}; };
nsCSSSection mSection; nsCSSSection mSection;
nsCOMPtr<nsINameSpace> mNameSpace; nsNameSpaceMap *mNameSpaceMap; // weak, mSheet owns it
// After an UngetToken is done this flag is true. The next call to // After an UngetToken is done this flag is true. The next call to
// GetToken clears the flag. // GetToken clears the flag.
@ -472,6 +472,7 @@ CSSParserImpl::CSSParserImpl()
mScanner(), mScanner(),
mChildLoader(nsnull), mChildLoader(nsnull),
mSection(eCSSSection_Charset), mSection(eCSSSection_Charset),
mNameSpaceMap(nsnull),
mHavePushBack(PR_FALSE), mHavePushBack(PR_FALSE),
mNavQuirkMode(PR_FALSE), mNavQuirkMode(PR_FALSE),
#ifdef MOZ_SVG #ifdef MOZ_SVG
@ -505,7 +506,7 @@ CSSParserImpl::SetStyleSheet(nsICSSStyleSheet* aSheet)
// Switch to using the new sheet // Switch to using the new sheet
mGroupStack.Clear(); mGroupStack.Clear();
mSheet = aSheet; mSheet = aSheet;
mSheet->GetNameSpace(*getter_AddRefs(mNameSpace)); mNameSpaceMap = mSheet->GetNameSpaceMap();
} }
return NS_OK; return NS_OK;
@ -582,7 +583,10 @@ CSSParserImpl::Parse(nsIUnicharInputStream* aInput,
if (! mSheet) { if (! mSheet) {
NS_NewCSSStyleSheet(getter_AddRefs(mSheet)); NS_NewCSSStyleSheet(getter_AddRefs(mSheet));
NS_ENSURE_TRUE(mSheet, NS_ERROR_OUT_OF_MEMORY);
mSheet->SetURIs(aSheetURI, aBaseURI); mSheet->SetURIs(aSheetURI, aBaseURI);
mNameSpaceMap = nsnull;
} }
#ifdef DEBUG #ifdef DEBUG
else { else {
@ -594,10 +598,6 @@ CSSParserImpl::Parse(nsIUnicharInputStream* aInput,
} }
#endif #endif
if (! mSheet) {
return NS_ERROR_OUT_OF_MEMORY;
}
nsresult errorCode = NS_OK; nsresult errorCode = NS_OK;
nsresult result = InitScanner(aInput, aSheetURI, aLineNumber, aBaseURI); nsresult result = InitScanner(aInput, aSheetURI, aLineNumber, aBaseURI);
@ -1429,7 +1429,12 @@ PRBool CSSParserImpl::ProcessNameSpace(nsresult& aErrorCode, const nsString& aPr
NS_NewCSSNameSpaceRule(getter_AddRefs(rule), prefix, aURLSpec); NS_NewCSSNameSpaceRule(getter_AddRefs(rule), prefix, aURLSpec);
if (rule) { if (rule) {
(*aAppendFunc)(rule, aData); (*aAppendFunc)(rule, aData);
mSheet->GetNameSpace(*getter_AddRefs(mNameSpace));
// If this was the first namespace rule encountered, it will trigger
// creation of a namespace map.
if (!mNameSpaceMap) {
mNameSpaceMap = mSheet->GetNameSpaceMap();
}
} }
return result; return result;
@ -1903,12 +1908,9 @@ CSSParserImpl::ParseTypeOrUniversalSelector(PRInt32& aDataMask,
} }
else { // was universal element selector else { // was universal element selector
aSelector.SetNameSpace(kNameSpaceID_Unknown); // wildcard aSelector.SetNameSpace(kNameSpaceID_Unknown); // wildcard
if (mNameSpace) { // look for default namespace if (mNameSpaceMap) { // look for default namespace
nsCOMPtr<nsINameSpace> defaultNameSpace; PRInt32 defaultID = mNameSpaceMap->FindNameSpaceID(nsnull);
mNameSpace->FindNameSpace(nsnull, getter_AddRefs(defaultNameSpace)); if (defaultID != kNameSpaceID_None) {
if (defaultNameSpace) {
PRInt32 defaultID;
defaultNameSpace->GetNameSpaceID(&defaultID);
aSelector.SetNameSpace(defaultID); aSelector.SetNameSpace(defaultID);
} }
} }
@ -1925,10 +1927,10 @@ CSSParserImpl::ParseTypeOrUniversalSelector(PRInt32& aDataMask,
if (ExpectSymbol(aErrorCode, '|', PR_FALSE)) { // was namespace if (ExpectSymbol(aErrorCode, '|', PR_FALSE)) { // was namespace
aDataMask |= SEL_MASK_NSPACE; aDataMask |= SEL_MASK_NSPACE;
PRInt32 nameSpaceID = kNameSpaceID_Unknown; PRInt32 nameSpaceID = kNameSpaceID_Unknown;
if (mNameSpace) { if (mNameSpaceMap) {
ToLowerCase(buffer); // always case insensitive, since stays within CSS ToLowerCase(buffer); // always case insensitive, since stays within CSS
nsCOMPtr<nsIAtom> prefix = do_GetAtom(buffer); nsCOMPtr<nsIAtom> prefix = do_GetAtom(buffer);
mNameSpace->FindNameSpaceID(prefix, &nameSpaceID); nameSpaceID = mNameSpaceMap->FindNameSpaceID(prefix);
} // else, no declared namespaces } // else, no declared namespaces
if (kNameSpaceID_Unknown == nameSpaceID) { // unknown prefix, dump it if (kNameSpaceID_Unknown == nameSpaceID) { // unknown prefix, dump it
const PRUnichar *params[] = { const PRUnichar *params[] = {
@ -1965,12 +1967,9 @@ CSSParserImpl::ParseTypeOrUniversalSelector(PRInt32& aDataMask,
} }
else { // was element name else { // was element name
aSelector.SetNameSpace(kNameSpaceID_Unknown); // wildcard aSelector.SetNameSpace(kNameSpaceID_Unknown); // wildcard
if (mNameSpace) { // look for default namespace if (mNameSpaceMap) { // look for default namespace
nsCOMPtr<nsINameSpace> defaultNameSpace; PRInt32 defaultID = mNameSpaceMap->FindNameSpaceID(nsnull);
mNameSpace->FindNameSpace(nsnull, getter_AddRefs(defaultNameSpace)); if (defaultID != kNameSpaceID_None) {
if (defaultNameSpace) {
PRInt32 defaultID;
defaultNameSpace->GetNameSpaceID(&defaultID);
aSelector.SetNameSpace(defaultID); aSelector.SetNameSpace(defaultID);
} }
} }
@ -2023,12 +2022,9 @@ CSSParserImpl::ParseTypeOrUniversalSelector(PRInt32& aDataMask,
// no tag or namespace: implied universal selector // no tag or namespace: implied universal selector
// set namespace to unknown since it is not specified // set namespace to unknown since it is not specified
aSelector.SetNameSpace(kNameSpaceID_Unknown); // wildcard aSelector.SetNameSpace(kNameSpaceID_Unknown); // wildcard
if (mNameSpace) { // look for default namespace if (mNameSpaceMap) { // look for default namespace
nsCOMPtr<nsINameSpace> defaultNameSpace; PRInt32 defaultID = mNameSpaceMap->FindNameSpaceID(nsnull);
mNameSpace->FindNameSpace(nsnull, getter_AddRefs(defaultNameSpace)); if (defaultID != kNameSpaceID_None) {
if (defaultNameSpace) {
PRInt32 defaultID;
defaultNameSpace->GetNameSpaceID(&defaultID);
aSelector.SetNameSpace(defaultID); aSelector.SetNameSpace(defaultID);
} }
} }
@ -2096,10 +2092,10 @@ CSSParserImpl::ParseAttributeSelector(PRInt32& aDataMask,
attr = mToken.mIdent; // hang on to it attr = mToken.mIdent; // hang on to it
if (ExpectSymbol(aErrorCode, '|', PR_FALSE)) { // was a namespace if (ExpectSymbol(aErrorCode, '|', PR_FALSE)) { // was a namespace
nameSpaceID = kNameSpaceID_Unknown; nameSpaceID = kNameSpaceID_Unknown;
if (mNameSpace) { if (mNameSpaceMap) {
ToLowerCase(attr); // always case insensitive, since stays within CSS ToLowerCase(attr); // always case insensitive, since stays within CSS
nsCOMPtr<nsIAtom> prefix = do_GetAtom(attr); nsCOMPtr<nsIAtom> prefix = do_GetAtom(attr);
mNameSpace->FindNameSpaceID(prefix, &nameSpaceID); nameSpaceID = mNameSpaceMap->FindNameSpaceID(prefix);
} // else, no declared namespaces } // else, no declared namespaces
if (kNameSpaceID_Unknown == nameSpaceID) { // unknown prefix, dump it if (kNameSpaceID_Unknown == nameSpaceID) { // unknown prefix, dump it
const PRUnichar *params[] = { const PRUnichar *params[] = {
@ -3636,10 +3632,10 @@ PRBool CSSParserImpl::ParseAttr(nsresult& aErrorCode, nsCSSValue& aValue)
nsAutoString holdIdent(mToken.mIdent); nsAutoString holdIdent(mToken.mIdent);
if (ExpectSymbol(aErrorCode, '|', PR_FALSE)) { // namespace if (ExpectSymbol(aErrorCode, '|', PR_FALSE)) { // namespace
PRInt32 nameSpaceID = kNameSpaceID_Unknown; PRInt32 nameSpaceID = kNameSpaceID_Unknown;
if (mNameSpace) { if (mNameSpaceMap) {
ToLowerCase(holdIdent); // always case insensitive, since stays within CSS ToLowerCase(holdIdent); // always case insensitive, since stays within CSS
nsCOMPtr<nsIAtom> prefix = do_GetAtom(holdIdent); nsCOMPtr<nsIAtom> prefix = do_GetAtom(holdIdent);
mNameSpace->FindNameSpaceID(prefix, &nameSpaceID); nameSpaceID = mNameSpaceMap->FindNameSpaceID(prefix);
} // else, no declared namespaces } // else, no declared namespaces
if (kNameSpaceID_Unknown == nameSpaceID) { // unknown prefix, dump it if (kNameSpaceID_Unknown == nameSpaceID) { // unknown prefix, dump it
const PRUnichar *params[] = { const PRUnichar *params[] = {

19
layout/style/nsCSSStyleRule.cpp
View File

@ -61,7 +61,7 @@
#include "nsIDOMCSSStyleDeclaration.h" #include "nsIDOMCSSStyleDeclaration.h"
#include "nsDOMCSSDeclaration.h" #include "nsDOMCSSDeclaration.h"
#include "nsINameSpaceManager.h" #include "nsINameSpaceManager.h"
#include "nsINameSpace.h" #include "nsNameSpaceMap.h"
#include "nsILookAndFeel.h" #include "nsILookAndFeel.h"
#include "nsRuleNode.h" #include "nsRuleNode.h"
#include "nsUnicharUtils.h" #include "nsUnicharUtils.h"
@ -580,8 +580,7 @@ void nsCSSSelector::ToStringInternal(nsAString& aString,
// before it. // before it.
aString.Append(PRUnichar('|')); aString.Append(PRUnichar('|'));
} else { } else {
nsCOMPtr<nsINameSpace> sheetNS; nsNameSpaceMap *sheetNS = aSheet->GetNameSpaceMap();
aSheet->GetNameSpace(*getter_AddRefs(sheetNS));
// sheetNS is non-null if and only if we had an @namespace rule. If it's // sheetNS is non-null if and only if we had an @namespace rule. If it's
// null, that means that the only namespaces we could have are the // null, that means that the only namespaces we could have are the
@ -589,11 +588,11 @@ void nsCSSSelector::ToStringInternal(nsAString& aString,
// namespace, which we handled above. So no need to output anything when // namespace, which we handled above. So no need to output anything when
// sheetNS is null. // sheetNS is null.
if (sheetNS) { if (sheetNS) {
nsCOMPtr<nsIAtom> prefixAtom; nsIAtom *prefixAtom = nsnull;
// prefixAtom is non-null if and only if we have a prefix other than // prefixAtom is non-null if and only if we have a prefix other than
// '*' // '*'
if (mNameSpace != kNameSpaceID_Unknown) { if (mNameSpace != kNameSpaceID_Unknown) {
sheetNS->FindNameSpacePrefix(mNameSpace, getter_AddRefs(prefixAtom)); prefixAtom = sheetNS->FindPrefix(mNameSpace);
} }
if (prefixAtom) { if (prefixAtom) {
nsAutoString prefix; nsAutoString prefix;
@ -603,8 +602,7 @@ void nsCSSSelector::ToStringInternal(nsAString& aString,
} else if (mNameSpace == kNameSpaceID_Unknown) { } else if (mNameSpace == kNameSpaceID_Unknown) {
// explicit *| or only non-default namespace rules and we're not // explicit *| or only non-default namespace rules and we're not
// using any of those namespaces // using any of those namespaces
aString.Append(PRUnichar('*')); aString.AppendLiteral("*|");
aString.Append(PRUnichar('|'));
} }
// else we are in the default namespace and don't need to output // else we are in the default namespace and don't need to output
// anything // anything
@ -671,12 +669,9 @@ void nsCSSSelector::ToStringInternal(nsAString& aString,
aString.Append(PRUnichar('[')); aString.Append(PRUnichar('['));
// Append the namespace prefix // Append the namespace prefix
if (list->mNameSpace > 0) { if (list->mNameSpace > 0) {
nsCOMPtr<nsINameSpace> sheetNS; nsNameSpaceMap *sheetNS = aSheet->GetNameSpaceMap();
aSheet->GetNameSpace(*getter_AddRefs(sheetNS));
nsCOMPtr<nsIAtom> prefixAtom;
// will return null if namespace was the default // will return null if namespace was the default
sheetNS->FindNameSpacePrefix(list->mNameSpace, nsIAtom *prefixAtom = sheetNS->FindPrefix(list->mNameSpace);
getter_AddRefs(prefixAtom));
if (prefixAtom) { if (prefixAtom) {
nsAutoString prefix; nsAutoString prefix;
prefixAtom->ToString(prefix); prefixAtom->ToString(prefix);

85
layout/style/nsCSSStyleSheet.cpp
View File

@ -86,7 +86,7 @@
#include "nsRuleWalker.h" #include "nsRuleWalker.h"
#include "nsCSSPseudoClasses.h" #include "nsCSSPseudoClasses.h"
#include "nsINameSpaceManager.h" #include "nsINameSpaceManager.h"
#include "nsINameSpace.h" #include "nsNameSpaceMap.h"
#include "nsITextContent.h" #include "nsITextContent.h"
#include "prlog.h" #include "prlog.h"
#include "nsCOMPtr.h" #include "nsCOMPtr.h"
@ -1225,7 +1225,6 @@ static PRBool SetStyleSheetReference(nsISupports* aElement, void* aSheet)
nsCSSStyleSheetInner::nsCSSStyleSheetInner(nsICSSStyleSheet* aParentSheet) nsCSSStyleSheetInner::nsCSSStyleSheetInner(nsICSSStyleSheet* aParentSheet)
: mSheets(), : mSheets(),
mOrderedRules(nsnull), mOrderedRules(nsnull),
mNameSpace(nsnull),
mComplete(PR_FALSE) mComplete(PR_FALSE)
{ {
MOZ_COUNT_CTOR(nsCSSStyleSheetInner); MOZ_COUNT_CTOR(nsCSSStyleSheetInner);
@ -1251,7 +1250,6 @@ nsCSSStyleSheetInner::nsCSSStyleSheetInner(nsCSSStyleSheetInner& aCopy,
: mSheets(), : mSheets(),
mSheetURI(aCopy.mSheetURI), mSheetURI(aCopy.mSheetURI),
mBaseURI(aCopy.mBaseURI), mBaseURI(aCopy.mBaseURI),
mNameSpace(nsnull),
mComplete(aCopy.mComplete) mComplete(aCopy.mComplete)
{ {
MOZ_COUNT_CTOR(nsCSSStyleSheetInner); MOZ_COUNT_CTOR(nsCSSStyleSheetInner);
@ -1319,21 +1317,15 @@ CreateNameSpace(nsISupports* aRule, void* aNameSpacePtr)
rule->GetType(type); rule->GetType(type);
if (nsICSSRule::NAMESPACE_RULE == type) { if (nsICSSRule::NAMESPACE_RULE == type) {
nsICSSNameSpaceRule* nameSpaceRule = (nsICSSNameSpaceRule*)rule; nsICSSNameSpaceRule* nameSpaceRule = (nsICSSNameSpaceRule*)rule;
nsINameSpace** nameSpacePtr = (nsINameSpace**)aNameSpacePtr; nsNameSpaceMap *nameSpaceMap =
nsINameSpace* lastNameSpace = *nameSpacePtr; NS_STATIC_CAST(nsNameSpaceMap*, aNameSpacePtr);
nsINameSpace* newNameSpace;
nsIAtom* prefix = nsnull; nsIAtom* prefix = nsnull;
nsAutoString urlSpec; nsAutoString urlSpec;
nameSpaceRule->GetPrefix(prefix); nameSpaceRule->GetPrefix(prefix);
nameSpaceRule->GetURLSpec(urlSpec); nameSpaceRule->GetURLSpec(urlSpec);
lastNameSpace->CreateChildNameSpace(prefix, urlSpec, &newNameSpace);
NS_IF_RELEASE(prefix);
if (newNameSpace) {
NS_RELEASE(lastNameSpace);
(*nameSpacePtr) = newNameSpace; // takes ref
}
nameSpaceMap->AddPrefix(prefix, urlSpec);
return PR_TRUE; return PR_TRUE;
} }
// stop if not namespace, import or charset because namespace can't follow anything else // stop if not namespace, import or charset because namespace can't follow anything else
@ -1344,11 +1336,17 @@ CreateNameSpace(nsISupports* aRule, void* aNameSpacePtr)
void void
nsCSSStyleSheetInner::RebuildNameSpaces() nsCSSStyleSheetInner::RebuildNameSpaces()
{ {
nsContentUtils::GetNSManagerWeakRef()-> if (mNameSpaceMap) {
CreateRootNameSpace(getter_AddRefs(mNameSpace)); mNameSpaceMap->Clear();
} else {
mNameSpaceMap = nsNameSpaceMap::Create();
if (!mNameSpaceMap) {
return; // out of memory
}
}
if (mOrderedRules) { if (mOrderedRules) {
mOrderedRules->EnumerateForwards(CreateNameSpace, address_of(mNameSpace)); mOrderedRules->EnumerateForwards(CreateNameSpace, mNameSpaceMap);
} }
} }
@ -1871,28 +1869,20 @@ nsCSSStyleSheet::AppendStyleRule(nsICSSRule* aRule)
PRInt32 type = nsICSSRule::UNKNOWN_RULE; PRInt32 type = nsICSSRule::UNKNOWN_RULE;
aRule->GetType(type); aRule->GetType(type);
if (nsICSSRule::NAMESPACE_RULE == type) { if (nsICSSRule::NAMESPACE_RULE == type) {
if (! mInner->mNameSpace) { if (!mInner->mNameSpaceMap) {
nsContentUtils::GetNSManagerWeakRef()-> mInner->mNameSpaceMap = nsNameSpaceMap::Create();
CreateRootNameSpace(getter_AddRefs(mInner->mNameSpace)); NS_ENSURE_TRUE(mInner->mNameSpaceMap, NS_ERROR_OUT_OF_MEMORY);
} }
if (mInner->mNameSpace) { nsCOMPtr<nsICSSNameSpaceRule> nameSpaceRule(do_QueryInterface(aRule));
nsCOMPtr<nsICSSNameSpaceRule> nameSpaceRule(do_QueryInterface(aRule));
nsCOMPtr<nsINameSpace> newNameSpace;
nsCOMPtr<nsIAtom> prefix; nsCOMPtr<nsIAtom> prefix;
nsAutoString urlSpec; nsAutoString urlSpec;
nameSpaceRule->GetPrefix(*getter_AddRefs(prefix)); nameSpaceRule->GetPrefix(*getter_AddRefs(prefix));
nameSpaceRule->GetURLSpec(urlSpec); nameSpaceRule->GetURLSpec(urlSpec);
mInner->mNameSpace->
CreateChildNameSpace(prefix, urlSpec, mInner->mNameSpaceMap->AddPrefix(prefix, urlSpec);
getter_AddRefs(newNameSpace));
if (newNameSpace) {
mInner->mNameSpace = newNameSpace;
}
}
} }
} }
} }
return NS_OK; return NS_OK;
@ -1956,17 +1946,10 @@ nsCSSStyleSheet::GetStyleRuleAt(PRInt32 aIndex, nsICSSRule*& aRule) const
return result; return result;
} }
NS_IMETHODIMP nsNameSpaceMap*
nsCSSStyleSheet::GetNameSpace(nsINameSpace*& aNameSpace) const nsCSSStyleSheet::GetNameSpaceMap() const
{ {
if (mInner) { return mInner ? mInner->mNameSpaceMap : nsnull;
aNameSpace = mInner->mNameSpace;
NS_IF_ADDREF(aNameSpace);
}
else {
aNameSpace = nsnull;
}
return NS_OK;
} }
NS_IMETHODIMP NS_IMETHODIMP
@ -2499,25 +2482,19 @@ nsCSSStyleSheet::InsertRule(const nsAString& aRule,
PRInt32 type = nsICSSRule::UNKNOWN_RULE; PRInt32 type = nsICSSRule::UNKNOWN_RULE;
cssRule->GetType(type); cssRule->GetType(type);
if (type == nsICSSRule::NAMESPACE_RULE) { if (type == nsICSSRule::NAMESPACE_RULE) {
if (! mInner->mNameSpace) { if (!mInner->mNameSpaceMap) {
nsContentUtils::GetNSManagerWeakRef()-> mInner->mNameSpaceMap = nsNameSpaceMap::Create();
CreateRootNameSpace(getter_AddRefs(mInner->mNameSpace)); NS_ENSURE_TRUE(mInner->mNameSpaceMap, NS_ERROR_OUT_OF_MEMORY);
} }
NS_ENSURE_TRUE(mInner->mNameSpace, NS_ERROR_FAILURE);
nsCOMPtr<nsICSSNameSpaceRule> nameSpaceRule(do_QueryInterface(cssRule)); nsCOMPtr<nsICSSNameSpaceRule> nameSpaceRule(do_QueryInterface(cssRule));
nsCOMPtr<nsINameSpace> newNameSpace;
nsCOMPtr<nsIAtom> prefix; nsCOMPtr<nsIAtom> prefix;
nsAutoString urlSpec; nsAutoString urlSpec;
nameSpaceRule->GetPrefix(*getter_AddRefs(prefix)); nameSpaceRule->GetPrefix(*getter_AddRefs(prefix));
nameSpaceRule->GetURLSpec(urlSpec); nameSpaceRule->GetURLSpec(urlSpec);
mInner->mNameSpace->CreateChildNameSpace(prefix, urlSpec,
getter_AddRefs(newNameSpace)); mInner->mNameSpaceMap->AddPrefix(prefix, urlSpec);
if (newNameSpace) {
mInner->mNameSpace = newNameSpace;
}
} }
// We don't notify immediately for @import rules, but rather when // We don't notify immediately for @import rules, but rather when

6
layout/style/nsCSSStyleSheet.h
View File

@ -44,13 +44,13 @@
#include "nscore.h" #include "nscore.h"
#include "nsCOMPtr.h" #include "nsCOMPtr.h"
#include "nsAutoPtr.h"
#include "nsICSSStyleSheet.h" #include "nsICSSStyleSheet.h"
#include "nsIDOMCSSStyleSheet.h" #include "nsIDOMCSSStyleSheet.h"
#include "nsICSSLoaderObserver.h" #include "nsICSSLoaderObserver.h"
#include "nsVoidArray.h" #include "nsVoidArray.h"
class nsIURI; class nsIURI;
class nsINameSpace;
class nsISupportsArray; class nsISupportsArray;
// ------------------------------- // -------------------------------
@ -73,7 +73,7 @@ public:
nsCOMPtr<nsIURI> mSheetURI; // for error reports, etc. nsCOMPtr<nsIURI> mSheetURI; // for error reports, etc.
nsCOMPtr<nsIURI> mBaseURI; // for resolving relative URIs nsCOMPtr<nsIURI> mBaseURI; // for resolving relative URIs
nsISupportsArray* mOrderedRules; nsISupportsArray* mOrderedRules;
nsCOMPtr<nsINameSpace> mNameSpace; nsAutoPtr<nsNameSpaceMap> mNameSpaceMap;
PRPackedBool mComplete; PRPackedBool mComplete;
}; };
@ -138,7 +138,7 @@ public:
NS_IMETHOD SetOwningNode(nsIDOMNode* aOwningNode); NS_IMETHOD SetOwningNode(nsIDOMNode* aOwningNode);
NS_IMETHOD SetOwnerRule(nsICSSImportRule* aOwnerRule); NS_IMETHOD SetOwnerRule(nsICSSImportRule* aOwnerRule);
NS_IMETHOD GetOwnerRule(nsICSSImportRule** aOwnerRule); NS_IMETHOD GetOwnerRule(nsICSSImportRule** aOwnerRule);
NS_IMETHOD GetNameSpace(nsINameSpace*& aNameSpace) const; virtual NS_HIDDEN_(nsNameSpaceMap*) GetNameSpaceMap() const;
NS_IMETHOD Clone(nsICSSStyleSheet* aCloneParent, NS_IMETHOD Clone(nsICSSStyleSheet* aCloneParent,
nsICSSImportRule* aCloneOwnerRule, nsICSSImportRule* aCloneOwnerRule,
nsIDocument* aCloneDocument, nsIDocument* aCloneDocument,

10
layout/style/nsICSSStyleSheet.h
View File

@ -42,16 +42,16 @@
class nsICSSRule; class nsICSSRule;
class nsIDOMNode; class nsIDOMNode;
class nsINameSpace; class nsNameSpaceMap;
class nsCSSRuleProcessor; class nsCSSRuleProcessor;
class nsIMediaList; class nsIMediaList;
class nsICSSGroupRule; class nsICSSGroupRule;
class nsICSSImportRule; class nsICSSImportRule;
// IID for the nsICSSStyleSheet interface // IID for the nsICSSStyleSheet interface
// d148e93e-7f1d-4f95-853f-ac356eba3d70 // 37f9b0f0-5d00-4abc-9246-35473031ffd7
#define NS_ICSS_STYLE_SHEET_IID \ #define NS_ICSS_STYLE_SHEET_IID \
{0xd148e93e, 0x7f1d, 0x4f95, {0x85, 0x3f, 0xac, 0x35, 0x6e, 0xba, 0x3d, 0x70}} {0x37f9b0f0, 0x5d00, 0x4abc, {0x92, 0x46, 0x35, 0x47, 0x30, 0x31, 0xff, 0xd7}}
class nsICSSStyleSheet : public nsIStyleSheet { class nsICSSStyleSheet : public nsIStyleSheet {
public: public:
@ -91,8 +91,8 @@ public:
NS_IMETHOD SetOwnerRule(nsICSSImportRule* aOwnerRule) = 0; NS_IMETHOD SetOwnerRule(nsICSSImportRule* aOwnerRule) = 0;
NS_IMETHOD GetOwnerRule(nsICSSImportRule** aOwnerRule) = 0; NS_IMETHOD GetOwnerRule(nsICSSImportRule** aOwnerRule) = 0;
// get head of namespace chain for sheet // get namespace map for sheet
NS_IMETHOD GetNameSpace(nsINameSpace*& aNameSpace) const = 0; virtual NS_HIDDEN_(nsNameSpaceMap*) GetNameSpaceMap() const = 0;
NS_IMETHOD Clone(nsICSSStyleSheet* aCloneParent, NS_IMETHOD Clone(nsICSSStyleSheet* aCloneParent,
nsICSSImportRule* aCloneOwnerRule, nsICSSImportRule* aCloneOwnerRule,