Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-26 14:22:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Convert users of nsAReadable[C]String and nsAWritable[C]String typedefs to [const] nsA[C]String. b=131899 r=scc sr=jag a=asa

Browse Source
This commit is contained in:
dbaron%fas.harvard.edu 2002-03-23 22:46:13 +00:00
parent f6d744b58b
commit a4acc9eb7b
67 changed files with 501 additions and 501 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
content/xbl/public/nsIBindingManager.h
View File

@ -149,9 +149,9 @@ public:
NS_IMETHOD GetSingleInsertionPoint(nsIContent* aParent, nsIContent** aResult, PRUint32* aIndex,
PRBool* aMultipleInsertionPoints) = 0;
NS_IMETHOD AddLayeredBinding(nsIContent* aContent, const nsAReadableString& aURL) = 0;
NS_IMETHOD RemoveLayeredBinding(nsIContent* aContent, const nsAReadableString& aURL) = 0;
NS_IMETHOD LoadBindingDocument(nsIDocument* aDocument, const nsAReadableString& aURL,
NS_IMETHOD AddLayeredBinding(nsIContent* aContent, const nsAString& aURL) = 0;
NS_IMETHOD RemoveLayeredBinding(nsIContent* aContent, const nsAString& aURL) = 0;
NS_IMETHOD LoadBindingDocument(nsIDocument* aDocument, const nsAString& aURL,
nsIDocument** aResult) = 0;
NS_IMETHOD AddToAttachedQueue(nsIXBLBinding* aBinding)=0;

4
content/xbl/public/nsIXBLDocumentInfo.h
View File

@ -72,8 +72,8 @@ public:
NS_IMETHOD GetDocumentURI(nsCString& aDocURI)=0;
NS_IMETHOD GetPrototypeBinding(const nsAReadableCString& aRef, nsIXBLPrototypeBinding** aResult)=0;
NS_IMETHOD SetPrototypeBinding(const nsAReadableCString& aRef, nsIXBLPrototypeBinding* aBinding)=0;
NS_IMETHOD GetPrototypeBinding(const nsACString& aRef, nsIXBLPrototypeBinding** aResult)=0;
NS_IMETHOD SetPrototypeBinding(const nsACString& aRef, nsIXBLPrototypeBinding* aBinding)=0;
NS_IMETHOD FlushSkinStylesheets()=0;
};

6
content/xbl/public/nsIXBLPrototypeBinding.h
View File

@ -76,7 +76,7 @@ public:
NS_IMETHOD BindingDetached(nsIDOMEventReceiver* aReceiver)=0;
NS_IMETHOD LoadResources(PRBool* aLoaded)=0;
NS_IMETHOD AddResource(nsIAtom* aResourceType, const nsAReadableString& aSrc)=0;
NS_IMETHOD AddResource(nsIAtom* aResourceType, const nsAString& aSrc)=0;
NS_IMETHOD InheritsStyle(PRBool* aResult)=0;
@ -93,7 +93,7 @@ public:
NS_IMETHOD SetImplementation(nsXBLProtoImpl* aImpl)=0;
NS_IMETHOD InstallImplementation(nsIContent* aBoundElement)=0;
NS_IMETHOD ConstructInterfaceTable(const nsAReadableString& aImpls)=0;
NS_IMETHOD ConstructInterfaceTable(const nsAString& aImpls)=0;
NS_IMETHOD AttributeChanged(nsIAtom* aAttribute, PRInt32 aNameSpaceID, PRBool aRemoveFlag,
nsIContent* aChangedElement, nsIContent* aAnonymousContent)=0;
@ -139,7 +139,7 @@ public:
};
extern nsresult
NS_NewXBLPrototypeBinding(const nsAReadableCString& aRef,
NS_NewXBLPrototypeBinding(const nsACString& aRef,
nsIContent* aElement, nsIXBLDocumentInfo* aInfo,
nsIXBLPrototypeBinding** aResult);

4
content/xbl/public/nsIXBLPrototypeHandler.h
View File

@ -46,7 +46,7 @@
#ifndef nsIXBLPrototypeHandler_h__
#define nsIXBLPrototypeHandler_h__
#include "nsAReadableString.h"
#include "nsAString.h"
class nsIContent;
class nsIDOMEvent;
@ -69,7 +69,7 @@ public:
NS_IMETHOD KeyEventMatched(nsIAtom* aEventType, nsIDOMKeyEvent* aEvent, PRBool* aResult) = 0;
NS_IMETHOD GetHandlerElement(nsIContent** aResult) = 0;
NS_IMETHOD AppendHandlerText(const nsAReadableString& aText) = 0;
NS_IMETHOD AppendHandlerText(const nsAString& aText) = 0;
NS_IMETHOD GetPhase(PRUint8* aPhase) = 0;

2
content/xbl/public/nsIXBLService.h
View File

@ -68,7 +68,7 @@ public:
// This function loads a particular XBL file and installs all of the bindings
// onto the element.
NS_IMETHOD LoadBindings(nsIContent* aContent, const nsAReadableString& aURL, PRBool aAugmentFlag,
NS_IMETHOD LoadBindings(nsIContent* aContent, const nsAString& aURL, PRBool aAugmentFlag,
nsIXBLBinding** aBinding, PRBool* aResolveStyle) = 0;
// This function clears out the bindings on a given content node.

12
content/xbl/src/nsBindingManager.cpp
View File

@ -254,9 +254,9 @@ public:
NS_IMETHOD GetSingleInsertionPoint(nsIContent* aParent, nsIContent** aResult, PRUint32* aIndex,
PRBool* aMultipleInsertionPoints);
NS_IMETHOD AddLayeredBinding(nsIContent* aContent, const nsAReadableString& aURL);
NS_IMETHOD RemoveLayeredBinding(nsIContent* aContent, const nsAReadableString& aURL);
NS_IMETHOD LoadBindingDocument(nsIDocument* aBoundDoc, const nsAReadableString& aURL,
NS_IMETHOD AddLayeredBinding(nsIContent* aContent, const nsAString& aURL);
NS_IMETHOD RemoveLayeredBinding(nsIContent* aContent, const nsAString& aURL);
NS_IMETHOD LoadBindingDocument(nsIDocument* aBoundDoc, const nsAString& aURL,
nsIDocument** aResult);
NS_IMETHOD AddToAttachedQueue(nsIXBLBinding* aBinding);
@ -770,7 +770,7 @@ nsBindingManager::GetSingleInsertionPoint(nsIContent* aParent, nsIContent** aRes
}
NS_IMETHODIMP
nsBindingManager::AddLayeredBinding(nsIContent* aContent, const nsAReadableString& aURL)
nsBindingManager::AddLayeredBinding(nsIContent* aContent, const nsAString& aURL)
{
// First we need to load our binding.
nsresult rv;
@ -792,7 +792,7 @@ nsBindingManager::AddLayeredBinding(nsIContent* aContent, const nsAReadableStrin
}
NS_IMETHODIMP
nsBindingManager::RemoveLayeredBinding(nsIContent* aContent, const nsAReadableString& aURL)
nsBindingManager::RemoveLayeredBinding(nsIContent* aContent, const nsAString& aURL)
{
/*
nsCOMPtr<nsIXBLBinding> binding;
@ -829,7 +829,7 @@ nsBindingManager::RemoveLayeredBinding(nsIContent* aContent, const nsAReadableSt
}
NS_IMETHODIMP
nsBindingManager::LoadBindingDocument(nsIDocument* aBoundDoc, const nsAReadableString& aURL,
nsBindingManager::LoadBindingDocument(nsIDocument* aBoundDoc, const nsAString& aURL,
nsIDocument** aResult)
{
NS_ConvertUCS2toUTF8 url(aURL);

4
content/xbl/src/nsXBLDocumentInfo.cpp
View File

@ -350,7 +350,7 @@ nsXBLDocumentInfo::~nsXBLDocumentInfo()
}
NS_IMETHODIMP
nsXBLDocumentInfo::GetPrototypeBinding(const nsAReadableCString& aRef, nsIXBLPrototypeBinding** aResult)
nsXBLDocumentInfo::GetPrototypeBinding(const nsACString& aRef, nsIXBLPrototypeBinding** aResult)
{
*aResult = nsnull;
if (!mBindingTable)
@ -364,7 +364,7 @@ nsXBLDocumentInfo::GetPrototypeBinding(const nsAReadableCString& aRef, nsIXBLPro
}
NS_IMETHODIMP
nsXBLDocumentInfo::SetPrototypeBinding(const nsAReadableCString& aRef, nsIXBLPrototypeBinding* aBinding)
nsXBLDocumentInfo::SetPrototypeBinding(const nsACString& aRef, nsIXBLPrototypeBinding* aBinding)
{
if (!mBindingTable)
mBindingTable = new nsSupportsHashtable();

4
content/xbl/src/nsXBLDocumentInfo.h
View File

@ -22,8 +22,8 @@ public:
NS_IMETHOD GetDocumentURI(nsCString& aDocURI) { aDocURI = mDocURI; return NS_OK; };
NS_IMETHOD GetPrototypeBinding(const nsAReadableCString& aRef, nsIXBLPrototypeBinding** aResult);
NS_IMETHOD SetPrototypeBinding(const nsAReadableCString& aRef, nsIXBLPrototypeBinding* aBinding);
NS_IMETHOD GetPrototypeBinding(const nsACString& aRef, nsIXBLPrototypeBinding** aResult);
NS_IMETHOD SetPrototypeBinding(const nsACString& aRef, nsIXBLPrototypeBinding* aBinding);
NS_IMETHOD FlushSkinStylesheets();

2
content/xbl/src/nsXBLEventHandler.cpp
View File

@ -124,7 +124,7 @@ nsXBLEventHandler::RemoveEventHandlers()
/// Helpers that are relegated to the end of the file /////////////////////////////
nsresult
nsXBLEventHandler::GetTextData(nsIContent *aParent, nsAWritableString& aResult)
nsXBLEventHandler::GetTextData(nsIContent *aParent, nsAString& aResult)
{
aResult.Truncate(0);

2
content/xbl/src/nsXBLEventHandler.h
View File

@ -75,7 +75,7 @@ public:
if (mNextHandler) mNextHandler->MarkForDeath(); mProtoHandler = nsnull; mEventReceiver = nsnull;
}
static nsresult GetTextData(nsIContent *aParent, nsAWritableString& aResult);
static nsresult GetTextData(nsIContent *aParent, nsAString& aResult);
protected:
nsCOMPtr<nsIDOMEventReceiver> mEventReceiver;

2
content/xbl/src/nsXBLProtoImplField.cpp
View File

@ -76,7 +76,7 @@ nsXBLProtoImplField::Destroy(PRBool aIsCompiled)
}
void
nsXBLProtoImplField::AppendFieldText(const nsAReadableString& aText)
nsXBLProtoImplField::AppendFieldText(const nsAString& aText)
{
if (mFieldText) {
nsDependentString fieldTextStr(mFieldText, mFieldTextLength);

2
content/xbl/src/nsXBLProtoImplField.h
View File

@ -54,7 +54,7 @@ public:
virtual ~nsXBLProtoImplField();
virtual void Destroy(PRBool aIsCompiled);
void AppendFieldText(const nsAReadableString& aText);
void AppendFieldText(const nsAString& aText);
virtual nsresult InstallMember(nsIScriptContext* aContext, nsIContent* aBoundElement,
void* aScriptObject, void* aTargetClassObject);

4
content/xbl/src/nsXBLProtoImplMethod.cpp
View File

@ -126,7 +126,7 @@ nsXBLProtoImplMethod::Destroy(PRBool aIsCompiled)
}
void
nsXBLProtoImplMethod::AppendBodyText(const nsAReadableString& aText)
nsXBLProtoImplMethod::AppendBodyText(const nsAString& aText)
{
if (!mUncompiledMethod) {
mUncompiledMethod = new nsXBLUncompiledMethod();
@ -138,7 +138,7 @@ nsXBLProtoImplMethod::AppendBodyText(const nsAReadableString& aText)
}
void
nsXBLProtoImplMethod::AddParameter(const nsAReadableString& aText)
nsXBLProtoImplMethod::AddParameter(const nsAString& aText)
{
if (!mUncompiledMethod) {
mUncompiledMethod = new nsXBLUncompiledMethod();

10
content/xbl/src/nsXBLProtoImplMethod.h
View File

@ -53,7 +53,7 @@ struct nsXBLParameter {
nsXBLParameter* mNext;
char* mName;
nsXBLParameter(const nsAReadableString& aName) {
nsXBLParameter(const nsAString& aName) {
MOZ_COUNT_CTOR(nsXBLParameter);
mName = ToNewCString(aName);
mNext = nsnull;
@ -93,7 +93,7 @@ struct nsXBLUncompiledMethod {
return result;
}
void AppendBodyText(const nsAReadableString& aText) {
void AppendBodyText(const nsAString& aText) {
if (mBodyText) {
PRUnichar* temp = mBodyText;
mBodyText = ToNewUnicode(nsDependentString(temp) + aText);
@ -103,7 +103,7 @@ struct nsXBLUncompiledMethod {
mBodyText = ToNewUnicode(aText);
}
void AddParameter(const nsAReadableString& aText) {
void AddParameter(const nsAString& aText) {
nsXBLParameter* param = new nsXBLParameter(aText);
if (!param)
return;
@ -122,8 +122,8 @@ public:
virtual ~nsXBLProtoImplMethod();
virtual void Destroy(PRBool aIsCompiled);
void AppendBodyText(const nsAReadableString& aBody);
void AddParameter(const nsAReadableString& aName);
void AppendBodyText(const nsAString& aBody);
void AddParameter(const nsAString& aName);
virtual nsresult InstallMember(nsIScriptContext* aContext, nsIContent* aBoundElement,
void* aScriptObject, void* aTargetClassObject);

4
content/xbl/src/nsXBLProtoImplProperty.cpp
View File

@ -145,7 +145,7 @@ nsXBLProtoImplProperty::Destroy(PRBool aIsCompiled)
}
void
nsXBLProtoImplProperty::AppendGetterText(const nsAReadableString& aText)
nsXBLProtoImplProperty::AppendGetterText(const nsAString& aText)
{
if (mGetterText) {
PRUnichar* temp = mGetterText;
@ -157,7 +157,7 @@ nsXBLProtoImplProperty::AppendGetterText(const nsAReadableString& aText)
}
void
nsXBLProtoImplProperty::AppendSetterText(const nsAReadableString& aText)
nsXBLProtoImplProperty::AppendSetterText(const nsAString& aText)
{
if (mSetterText) {
PRUnichar* temp = mSetterText;

4
content/xbl/src/nsXBLProtoImplProperty.h
View File

@ -58,8 +58,8 @@ public:
virtual ~nsXBLProtoImplProperty();
virtual void Destroy(PRBool aIsCompiled);
void AppendGetterText(const nsAReadableString& aGetter);
void AppendSetterText(const nsAReadableString& aSetter);
void AppendGetterText(const nsAString& aGetter);
void AppendSetterText(const nsAString& aSetter);
virtual nsresult InstallMember(nsIScriptContext* aContext, nsIContent* aBoundElement,
void* aScriptObject, void* aTargetClassObject);

8
content/xbl/src/nsXBLPrototypeBinding.cpp
View File

@ -254,7 +254,7 @@ static const PRInt32 kInsInitialSize = (NS_SIZE_IN_HEAP(sizeof(nsXBLInsertionPoi
NS_IMPL_ISUPPORTS2(nsXBLPrototypeBinding, nsIXBLPrototypeBinding, nsISupportsWeakReference)
// Constructors/Destructors
nsXBLPrototypeBinding::nsXBLPrototypeBinding(const nsAReadableCString& aID, nsIXBLDocumentInfo* aInfo,
nsXBLPrototypeBinding::nsXBLPrototypeBinding(const nsACString& aID, nsIXBLDocumentInfo* aInfo,
nsIContent* aElement)
: mInheritStyle(PR_TRUE),
mHasBaseProto(PR_TRUE),
@ -412,7 +412,7 @@ nsXBLPrototypeBinding::LoadResources(PRBool* aResult)
}
NS_IMETHODIMP
nsXBLPrototypeBinding::AddResource(nsIAtom* aResourceType, const nsAReadableString& aSrc)
nsXBLPrototypeBinding::AddResource(nsIAtom* aResourceType, const nsAString& aSrc)
{
if (!mResources) {
mResources = new nsXBLPrototypeResources(this);
@ -1352,7 +1352,7 @@ nsXBLPrototypeBinding::ConstructInsertionTable(nsIContent* aContent)
}
NS_IMETHODIMP
nsXBLPrototypeBinding::ConstructInterfaceTable(const nsAReadableString& aImpls)
nsXBLPrototypeBinding::ConstructInterfaceTable(const nsAString& aImpls)
{
if (!aImpls.IsEmpty()) {
// Obtain the interface info manager that can tell us the IID
@ -1426,7 +1426,7 @@ nsXBLPrototypeBinding::AddResourceListener(nsIContent* aBoundElement)
// Creation Routine ///////////////////////////////////////////////////////////////////////
nsresult
NS_NewXBLPrototypeBinding(const nsAReadableCString& aRef, nsIContent* aElement,
NS_NewXBLPrototypeBinding(const nsACString& aRef, nsIContent* aElement,
nsIXBLDocumentInfo* aInfo, nsIXBLPrototypeBinding** aResult)
{
nsXBLPrototypeBinding * binding = new nsXBLPrototypeBinding(aRef, aInfo, aElement);

6
content/xbl/src/nsXBLPrototypeBinding.h
View File

@ -75,7 +75,7 @@ class nsXBLPrototypeBinding: public nsIXBLPrototypeBinding, public nsSupportsWea
NS_IMETHOD BindingDetached(nsIDOMEventReceiver* aRec);
NS_IMETHOD LoadResources(PRBool* aResult);
NS_IMETHOD AddResource(nsIAtom* aResourceType, const nsAReadableString& aSrc);
NS_IMETHOD AddResource(nsIAtom* aResourceType, const nsAString& aSrc);
NS_IMETHOD InheritsStyle(PRBool* aResult);
@ -89,7 +89,7 @@ class nsXBLPrototypeBinding: public nsIXBLPrototypeBinding, public nsSupportsWea
NS_IMETHOD InitClass(const nsCString& aClassName, nsIScriptContext * aContext, void * aScriptObject, void ** aClassObject);
NS_IMETHOD ConstructInterfaceTable(const nsAReadableString& aImpls);
NS_IMETHOD ConstructInterfaceTable(const nsAString& aImpls);
NS_IMETHOD SetImplementation(nsXBLProtoImpl* aImpl) { mImplementation = aImpl; return NS_OK; };
NS_IMETHOD InstallImplementation(nsIContent* aBoundElement);
@ -139,7 +139,7 @@ class nsXBLPrototypeBinding: public nsIXBLPrototypeBinding, public nsSupportsWea
NS_IMETHOD Initialize();
public:
nsXBLPrototypeBinding(const nsAReadableCString& aRef, nsIXBLDocumentInfo* aInfo, nsIContent* aElement);
nsXBLPrototypeBinding(const nsACString& aRef, nsIXBLDocumentInfo* aInfo, nsIContent* aElement);
virtual ~nsXBLPrototypeBinding();

6
content/xbl/src/nsXBLPrototypeHandler.cpp
View File

@ -145,7 +145,7 @@ nsXBLPrototypeHandler::GetHandlerElement(nsIContent** aResult)
}
NS_IMETHODIMP
nsXBLPrototypeHandler::AppendHandlerText(const nsAReadableString& aText)
nsXBLPrototypeHandler::AppendHandlerText(const nsAString& aText)
{
if (mHandlerText) {
// Append our text to the existing text.
@ -771,7 +771,7 @@ static const keyCodeData gKeyCodes[] = {
};
PRInt32 nsXBLPrototypeHandler::GetMatchingKeyCode(const nsAReadableString& aKeyName)
PRInt32 nsXBLPrototypeHandler::GetMatchingKeyCode(const nsAString& aKeyName)
{
nsCAutoString keyName;
keyName.AssignWithConversion(aKeyName);
@ -808,7 +808,7 @@ PRInt32 nsXBLPrototypeHandler::KeyToMask(PRInt32 key)
}
void
nsXBLPrototypeHandler::GetEventType(nsAWritableString& aEvent)
nsXBLPrototypeHandler::GetEventType(nsAString& aEvent)
{
mHandlerElement->GetAttr(kNameSpaceID_None, nsXBLAtoms::event, aEvent);

6
content/xbl/src/nsXBLPrototypeHandler.h
View File

@ -81,7 +81,7 @@ public:
NS_IMETHOD GetHandlerElement(nsIContent** aResult);
NS_IMETHOD AppendHandlerText(const nsAReadableString& aText);
NS_IMETHOD AppendHandlerText(const nsAString& aText);
NS_IMETHOD GetPhase(PRUint8* aResult) { *aResult = mPhase; return NS_OK; };
@ -104,7 +104,7 @@ public:
protected:
NS_IMETHOD GetController(nsIDOMEventReceiver* aReceiver, nsIController** aResult);
inline PRInt32 GetMatchingKeyCode(const nsAReadableString& aKeyName);
inline PRInt32 GetMatchingKeyCode(const nsAString& aKeyName);
void ConstructPrototype(nsIContent* aKeyElement,
const PRUnichar* aEvent=nsnull, const PRUnichar* aPhase=nsnull,
const PRUnichar* aAction=nsnull, const PRUnichar* aCommand=nsnull,
@ -112,7 +112,7 @@ protected:
const PRUnichar* aModifiers=nsnull, const PRUnichar* aButton=nsnull,
const PRUnichar* aClickCount=nsnull);
void GetEventType(nsAWritableString& type);
void GetEventType(nsAString& type);
PRBool ModifiersMatchMask(nsIDOMUIEvent* aEvent);
inline PRBool KeyEventMatched(nsIDOMKeyEvent* aKeyEvent);

2
content/xbl/src/nsXBLPrototypeResources.cpp
View File

@ -71,7 +71,7 @@ nsXBLPrototypeResources::~nsXBLPrototypeResources()
}
void
nsXBLPrototypeResources::AddResource(nsIAtom* aResourceType, const nsAReadableString& aSrc)
nsXBLPrototypeResources::AddResource(nsIAtom* aResourceType, const nsAString& aSrc)
{
if (mLoader)
mLoader->AddResource(aResourceType, aSrc);

2
content/xbl/src/nsXBLPrototypeResources.h
View File

@ -56,7 +56,7 @@ class nsXBLPrototypeResources
{
public:
void LoadResources(PRBool* aResult);
void AddResource(nsIAtom* aResourceType, const nsAReadableString& aSrc);
void AddResource(nsIAtom* aResourceType, const nsAString& aSrc);
void AddResourceListener(nsIContent* aElement);
nsresult FlushSkinSheets();

2
content/xbl/src/nsXBLResourceLoader.cpp
View File

@ -209,7 +209,7 @@ nsXBLResourceLoader::StyleSheetLoaded(nsICSSStyleSheet* aSheet, PRBool aNotify)
}
void
nsXBLResourceLoader::AddResource(nsIAtom* aResourceType, const nsAReadableString& aSrc)
nsXBLResourceLoader::AddResource(nsIAtom* aResourceType, const nsAString& aSrc)
{
nsXBLResource* res = new nsXBLResource(aResourceType, aSrc);
if (!res)

4
content/xbl/src/nsXBLResourceLoader.h
View File

@ -59,7 +59,7 @@ struct nsXBLResource {
nsIAtom* mType;
nsString mSrc;
nsXBLResource(nsIAtom* aType, const nsAReadableString& aSrc) {
nsXBLResource(nsIAtom* aType, const nsAString& aSrc) {
MOZ_COUNT_CTOR(nsXBLResource);
mNext = nsnull;
mType = aType;
@ -81,7 +81,7 @@ public:
NS_IMETHOD StyleSheetLoaded(nsICSSStyleSheet* aSheet, PRBool aNotify);
void LoadResources(PRBool* aResult);
void AddResource(nsIAtom* aResourceType, const nsAReadableString& aSrc);
void AddResource(nsIAtom* aResourceType, const nsAString& aSrc);
void AddResourceListener(nsIContent* aElement);
nsXBLResourceLoader(nsIXBLPrototypeBinding* aBinding, nsXBLPrototypeResources* aResources);

2
content/xbl/src/nsXBLService.cpp
View File

@ -606,7 +606,7 @@ nsXBLService::~nsXBLService(void)
// This function loads a particular XBL file and installs all of the bindings
// onto the element.
NS_IMETHODIMP
nsXBLService::LoadBindings(nsIContent* aContent, const nsAReadableString& aURL, PRBool aAugmentFlag,
nsXBLService::LoadBindings(nsIContent* aContent, const nsAString& aURL, PRBool aAugmentFlag,
nsIXBLBinding** aBinding, PRBool* aResolveStyle)
{
*aBinding = nsnull;

2
content/xbl/src/nsXBLService.h
View File

@ -69,7 +69,7 @@ class nsXBLService : public nsIXBLService, public nsIObserver, public nsSupports
// This function loads a particular XBL file and installs all of the bindings
// onto the element.
NS_IMETHOD LoadBindings(nsIContent* aContent, const nsAReadableString& aURL, PRBool aAugmentFlag,
NS_IMETHOD LoadBindings(nsIContent* aContent, const nsAString& aURL, PRBool aAugmentFlag,
nsIXBLBinding** aBinding, PRBool* aResolveStyle);
// This method loads a binding doc and then builds the specific binding required.

4
content/xbl/src/nsXBLWindowHandler.cpp
View File

@ -93,7 +93,7 @@ public:
nsIXBLPrototypeHandler** platformHandler,
nsIXBLPrototypeHandler** userHandler);
void GetHandlers(nsIXBLDocumentInfo* aInfo,
const nsAReadableCString& aRef,
const nsACString& aRef,
nsIXBLPrototypeHandler** aResult);
nsXBLSpecialDocInfo() : mInitialized(PR_FALSE) {};
@ -145,7 +145,7 @@ void nsXBLSpecialDocInfo::LoadDocInfo()
//
void
nsXBLSpecialDocInfo::GetHandlers(nsIXBLDocumentInfo* aInfo,
const nsAReadableCString& aRef,
const nsACString& aRef,
nsIXBLPrototypeHandler** aResult)
{
nsCOMPtr<nsIXBLPrototypeBinding> binding;

2
content/xbl/src/nsXBLWindowHandler.h
View File

@ -83,7 +83,7 @@ protected:
// create the event handler list from the given document/URI
void GetHandlers(nsIXBLDocumentInfo* aInfo,
const nsAReadableCString& aRef,
const nsACString& aRef,
nsIXBLPrototypeHandler** aResult) ;
// does the handler care about the particular event?

18
content/xml/content/public/nsIXMLContent.h
View File

@ -89,21 +89,21 @@ NS_NewXMLElement(nsIContent** aResult, nsINodeInfo* aNodeInfo);
// XXX These belongs elsewhere
extern nsresult
NS_NewXMLProcessingInstruction(nsIContent** aInstancePtrResult,
const nsAReadableString& aTarget,
const nsAReadableString& aData);
const nsAString& aTarget,
const nsAString& aData);
extern nsresult
NS_NewXMLEntity(nsIContent** aInstancePtrResult,
const nsAReadableString& aName,
const nsAReadableString& aPublicId,
const nsAReadableString& aSystemId,
const nsAReadableString& aNotationName);
const nsAString& aName,
const nsAString& aPublicId,
const nsAString& aSystemId,
const nsAString& aNotationName);
extern nsresult
NS_NewXMLNotation(nsIContent** aInstancePtrResult,
const nsAReadableString& aName,
const nsAReadableString& aPublicId,
const nsAReadableString& aSystemId);
const nsAString& aName,
const nsAString& aPublicId,
const nsAString& aSystemId);
class nsIDOMNamedNodeMap;

2
content/xml/content/src/nsXMLCDATASection.cpp
View File

@ -121,7 +121,7 @@ nsXMLCDATASection::GetTag(nsIAtom*& aResult) const
}
NS_IMETHODIMP
nsXMLCDATASection::GetNodeName(nsAWritableString& aNodeName)
nsXMLCDATASection::GetNodeName(nsAString& aNodeName)
{
aNodeName.Assign(NS_LITERAL_STRING("#cdata-section"));
return NS_OK;

6
content/xml/content/src/nsXMLElement.cpp
View File

@ -263,7 +263,7 @@ nsXMLElement::GetXMLBaseURI(nsIURI **aURI)
NS_IMETHODIMP
nsXMLElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
const nsAReadableString& aValue,
const nsAString& aValue,
PRBool aNotify)
{
return nsGenericContainerElement::SetAttr(aNameSpaceID, aName, aValue,
@ -272,7 +272,7 @@ nsXMLElement::SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
NS_IMETHODIMP
nsXMLElement::SetAttr(nsINodeInfo *aNodeInfo,
const nsAReadableString& aValue,
const nsAString& aValue,
PRBool aNotify)
{
NS_ENSURE_ARG_POINTER(aNodeInfo);
@ -310,7 +310,7 @@ static nsresult WebShellToPresContext(nsIWebShell *aShell,
}
static nsresult CheckLoadURI(nsIURI *aBaseURI, const nsAReadableString& aURI,
static nsresult CheckLoadURI(nsIURI *aBaseURI, const nsAString& aURI,
nsIURI **aAbsURI)
{
NS_ConvertUCS2toUTF8 str(aURI);

4
content/xml/content/src/nsXMLElement.h
View File

@ -77,10 +77,10 @@ public:
// nsIContent
NS_IMETHOD SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName,
const nsAReadableString& aValue,
const nsAString& aValue,
PRBool aNotify);
NS_IMETHOD SetAttr(nsINodeInfo *aNodeInfo,
const nsAReadableString& aValue,
const nsAString& aValue,
PRBool aNotify);
NS_IMETHOD HandleDOMEvent(nsIPresContext* aPresContext,
nsEvent* aEvent,

32
content/xml/content/src/nsXMLEntity.cpp
View File

@ -46,10 +46,10 @@ class nsXMLEntity : public nsGenericDOMDataNode,
public nsIDOMEntity
{
public:
nsXMLEntity(const nsAReadableString& aName,
const nsAReadableString& aPublicId,
const nsAReadableString& aSystemId,
const nsAReadableString& aNotationName);
nsXMLEntity(const nsAString& aName,
const nsAString& aPublicId,
const nsAString& aSystemId,
const nsAString& aNotationName);
virtual ~nsXMLEntity();
// nsISupports
@ -82,10 +82,10 @@ protected:
nsresult
NS_NewXMLEntity(nsIContent** aInstancePtrResult,
const nsAReadableString& aName,
const nsAReadableString& aPublicId,
const nsAReadableString& aSystemId,
const nsAReadableString& aNotationName)
const nsAString& aName,
const nsAString& aPublicId,
const nsAString& aSystemId,
const nsAString& aNotationName)
{
*aInstancePtrResult = new nsXMLEntity(aName, aPublicId, aSystemId,
aNotationName);
@ -96,10 +96,10 @@ NS_NewXMLEntity(nsIContent** aInstancePtrResult,
return NS_OK;
}
nsXMLEntity::nsXMLEntity(const nsAReadableString& aName,
const nsAReadableString& aPublicId,
const nsAReadableString& aSystemId,
const nsAReadableString& aNotationName) :
nsXMLEntity::nsXMLEntity(const nsAString& aName,
const nsAString& aPublicId,
const nsAString& aSystemId,
const nsAString& aNotationName) :
mName(aName), mPublicId(aPublicId), mSystemId(aSystemId),
mNotationName(aNotationName)
{
@ -123,7 +123,7 @@ NS_IMPL_RELEASE_INHERITED(nsXMLEntity, nsGenericDOMDataNode)
NS_IMETHODIMP
nsXMLEntity::GetPublicId(nsAWritableString& aPublicId)
nsXMLEntity::GetPublicId(nsAString& aPublicId)
{
aPublicId.Assign(mPublicId);
@ -131,7 +131,7 @@ nsXMLEntity::GetPublicId(nsAWritableString& aPublicId)
}
NS_IMETHODIMP
nsXMLEntity::GetSystemId(nsAWritableString& aSystemId)
nsXMLEntity::GetSystemId(nsAString& aSystemId)
{
aSystemId.Assign(mSystemId);
@ -139,7 +139,7 @@ nsXMLEntity::GetSystemId(nsAWritableString& aSystemId)
}
NS_IMETHODIMP
nsXMLEntity::GetNotationName(nsAWritableString& aNotationName)
nsXMLEntity::GetNotationName(nsAString& aNotationName)
{
aNotationName.Assign(mNotationName);
@ -158,7 +158,7 @@ nsXMLEntity::GetTag(nsIAtom*& aResult) const
}
NS_IMETHODIMP
nsXMLEntity::GetNodeName(nsAWritableString& aNodeName)
nsXMLEntity::GetNodeName(nsAString& aNodeName)
{
aNodeName.Assign(mName);
return NS_OK;

24
content/xml/content/src/nsXMLNamedNodeMap.cpp
View File

@ -56,18 +56,18 @@ public:
// nsIDOMNamedNodeMap
NS_IMETHOD GetLength(PRUint32* aLength);
NS_IMETHOD GetNamedItem(const nsAReadableString& aName,
NS_IMETHOD GetNamedItem(const nsAString& aName,
nsIDOMNode** aReturn);
NS_IMETHOD SetNamedItem(nsIDOMNode* aArg, nsIDOMNode** aReturn);
NS_IMETHOD RemoveNamedItem(const nsAReadableString& aName,
NS_IMETHOD RemoveNamedItem(const nsAString& aName,
nsIDOMNode** aReturn);
NS_IMETHOD Item(PRUint32 aIndex, nsIDOMNode** aReturn);
NS_IMETHOD GetNamedItemNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aLocalName,
NS_IMETHOD GetNamedItemNS(const nsAString& aNamespaceURI,
const nsAString& aLocalName,
nsIDOMNode** aReturn);
NS_IMETHOD SetNamedItemNS(nsIDOMNode* aArg, nsIDOMNode** aReturn);
NS_IMETHOD RemoveNamedItemNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString&aLocalName,
NS_IMETHOD RemoveNamedItemNS(const nsAString& aNamespaceURI,
const nsAString&aLocalName,
nsIDOMNode** aReturn);
protected:
@ -128,7 +128,7 @@ nsXMLNamedNodeMap::GetLength(PRUint32* aLength)
}
NS_IMETHODIMP
nsXMLNamedNodeMap::GetNamedItem(const nsAReadableString& aName,
nsXMLNamedNodeMap::GetNamedItem(const nsAString& aName,
nsIDOMNode** aReturn)
{
if (!aReturn)
@ -213,7 +213,7 @@ nsXMLNamedNodeMap::SetNamedItem(nsIDOMNode* aArg, nsIDOMNode** aReturn)
}
NS_IMETHODIMP
nsXMLNamedNodeMap::RemoveNamedItem(const nsAReadableString& aName,
nsXMLNamedNodeMap::RemoveNamedItem(const nsAString& aName,
nsIDOMNode** aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
@ -272,8 +272,8 @@ nsXMLNamedNodeMap::Item(PRUint32 aIndex, nsIDOMNode** aReturn)
}
nsresult
nsXMLNamedNodeMap::GetNamedItemNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aLocalName,
nsXMLNamedNodeMap::GetNamedItemNS(const nsAString& aNamespaceURI,
const nsAString& aLocalName,
nsIDOMNode** aReturn)
{
return NS_ERROR_NOT_IMPLEMENTED;
@ -286,8 +286,8 @@ nsXMLNamedNodeMap::SetNamedItemNS(nsIDOMNode* aArg, nsIDOMNode** aReturn)
}
nsresult
nsXMLNamedNodeMap::RemoveNamedItemNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString&aLocalName,
nsXMLNamedNodeMap::RemoveNamedItemNS(const nsAString& aNamespaceURI,
const nsAString&aLocalName,
nsIDOMNode** aReturn)
{
return NS_ERROR_NOT_IMPLEMENTED;

24
content/xml/content/src/nsXMLNotation.cpp
View File

@ -50,9 +50,9 @@ class nsXMLNotation : public nsGenericDOMDataNode,
public nsIDOMNotation
{
public:
nsXMLNotation(const nsAReadableString& aName,
const nsAReadableString& aPublicId,
const nsAReadableString& aSystemId);
nsXMLNotation(const nsAString& aName,
const nsAString& aPublicId,
const nsAString& aSystemId);
virtual ~nsXMLNotation();
// nsISupports
@ -81,9 +81,9 @@ protected:
nsresult
NS_NewXMLNotation(nsIContent** aInstancePtrResult,
const nsAReadableString& aName,
const nsAReadableString& aPublicId,
const nsAReadableString& aSystemId)
const nsAString& aName,
const nsAString& aPublicId,
const nsAString& aSystemId)
{
*aInstancePtrResult = new nsXMLNotation(aName, aPublicId, aSystemId);
NS_ENSURE_TRUE(*aInstancePtrResult, NS_ERROR_OUT_OF_MEMORY);
@ -93,9 +93,9 @@ NS_NewXMLNotation(nsIContent** aInstancePtrResult,
return NS_OK;
}
nsXMLNotation::nsXMLNotation(const nsAReadableString& aName,
const nsAReadableString& aPublicId,
const nsAReadableString& aSystemId) :
nsXMLNotation::nsXMLNotation(const nsAString& aName,
const nsAString& aPublicId,
const nsAString& aSystemId) :
mName(aName), mPublicId(aPublicId), mSystemId(aSystemId)
{
}
@ -118,7 +118,7 @@ NS_IMPL_RELEASE_INHERITED(nsXMLNotation, nsGenericDOMDataNode)
NS_IMETHODIMP
nsXMLNotation::GetPublicId(nsAWritableString& aPublicId)
nsXMLNotation::GetPublicId(nsAString& aPublicId)
{
aPublicId.Assign(mPublicId);
@ -126,7 +126,7 @@ nsXMLNotation::GetPublicId(nsAWritableString& aPublicId)
}
NS_IMETHODIMP
nsXMLNotation::GetSystemId(nsAWritableString& aSystemId)
nsXMLNotation::GetSystemId(nsAString& aSystemId)
{
aSystemId.Assign(mSystemId);
@ -145,7 +145,7 @@ nsXMLNotation::GetTag(nsIAtom*& aResult) const
}
NS_IMETHODIMP
nsXMLNotation::GetNodeName(nsAWritableString& aNodeName)
nsXMLNotation::GetNodeName(nsAString& aNodeName)
{
aNodeName.Assign(mName);
return NS_OK;

68
content/xml/content/src/nsXMLProcessingInstruction.cpp
View File

@ -60,22 +60,22 @@ class nsXMLProcessingInstruction : public nsGenericDOMDataNode,
public nsStyleLinkElement
{
public:
nsXMLProcessingInstruction(const nsAReadableString& aTarget,
const nsAReadableString& aData);
nsXMLProcessingInstruction(const nsAString& aTarget,
const nsAString& aData);
virtual ~nsXMLProcessingInstruction();
// nsISupports
NS_DECL_ISUPPORTS_INHERITED
// nsIDOMNode
NS_IMETHOD GetNodeName(nsAWritableString& aNodeName);
NS_IMETHOD GetLocalName(nsAWritableString& aLocalName) {
NS_IMETHOD GetNodeName(nsAString& aNodeName);
NS_IMETHOD GetLocalName(nsAString& aLocalName) {
return nsGenericDOMDataNode::GetLocalName(aLocalName);
}
NS_IMETHOD GetNodeValue(nsAWritableString& aNodeValue) {
NS_IMETHOD GetNodeValue(nsAString& aNodeValue) {
return nsGenericDOMDataNode::GetNodeValue(aNodeValue);
}
NS_IMETHOD SetNodeValue(const nsAReadableString& aNodeValue) {
NS_IMETHOD SetNodeValue(const nsAString& aNodeValue) {
nsresult rv = nsGenericDOMDataNode::SetNodeValue(aNodeValue);
UpdateStyleSheet(PR_TRUE);
return rv;
@ -125,32 +125,32 @@ public:
NS_IMETHOD GetOwnerDocument(nsIDOMDocument** aOwnerDocument) {
return nsGenericDOMDataNode::GetOwnerDocument(aOwnerDocument);
}
NS_IMETHOD GetNamespaceURI(nsAWritableString& aNamespaceURI) {
NS_IMETHOD GetNamespaceURI(nsAString& aNamespaceURI) {
return nsGenericDOMDataNode::GetNamespaceURI(aNamespaceURI);
}
NS_IMETHOD GetPrefix(nsAWritableString& aPrefix) {
NS_IMETHOD GetPrefix(nsAString& aPrefix) {
return nsGenericDOMDataNode::GetPrefix(aPrefix);
}
NS_IMETHOD SetPrefix(const nsAReadableString& aPrefix) {
NS_IMETHOD SetPrefix(const nsAString& aPrefix) {
return nsGenericDOMDataNode::SetPrefix(aPrefix);
}
NS_IMETHOD Normalize() {
return NS_OK;
}
NS_IMETHOD IsSupported(const nsAReadableString& aFeature,
const nsAReadableString& aVersion,
NS_IMETHOD IsSupported(const nsAString& aFeature,
const nsAString& aVersion,
PRBool* aReturn) {
return nsGenericDOMDataNode::IsSupported(aFeature, aVersion, aReturn);
}
NS_IMETHOD GetBaseURI(nsAWritableString& aURI) {
NS_IMETHOD GetBaseURI(nsAString& aURI) {
return nsGenericDOMDataNode::GetBaseURI(aURI);
}
NS_IMETHOD LookupNamespacePrefix(const nsAReadableString& aNamespaceURI,
nsAWritableString& aPrefix) {
NS_IMETHOD LookupNamespacePrefix(const nsAString& aNamespaceURI,
nsAString& aPrefix) {
return nsGenericDOMDataNode::LookupNamespacePrefix(aNamespaceURI, aPrefix);
}
NS_IMETHOD LookupNamespaceURI(const nsAReadableString& aNamespacePrefix,
nsAWritableString& aNamespaceURI) {
NS_IMETHOD LookupNamespaceURI(const nsAString& aNamespacePrefix,
nsAString& aNamespaceURI) {
return nsGenericDOMDataNode::LookupNamespaceURI(aNamespacePrefix,
aNamespaceURI);
}
@ -179,13 +179,13 @@ public:
#endif
// nsStyleLinkElement
NS_IMETHOD GetCharset(nsAWritableString& aCharset);
NS_IMETHOD GetCharset(nsAString& aCharset);
protected:
void GetStyleSheetInfo(nsAWritableString& aUrl,
nsAWritableString& aTitle,
nsAWritableString& aType,
nsAWritableString& aMedia,
void GetStyleSheetInfo(nsAString& aUrl,
nsAString& aTitle,
nsAString& aType,
nsAString& aMedia,
PRBool* aIsAlternate);
PRBool GetAttrValue(const nsAString& aAttr, nsAString& aValue);
@ -195,8 +195,8 @@ protected:
nsresult
NS_NewXMLProcessingInstruction(nsIContent** aInstancePtrResult,
const nsAReadableString& aTarget,
const nsAReadableString& aData)
const nsAString& aTarget,
const nsAString& aData)
{
*aInstancePtrResult = new nsXMLProcessingInstruction(aTarget, aData);
NS_ENSURE_TRUE(*aInstancePtrResult, NS_ERROR_OUT_OF_MEMORY);
@ -206,8 +206,8 @@ NS_NewXMLProcessingInstruction(nsIContent** aInstancePtrResult,
return NS_OK;
}
nsXMLProcessingInstruction::nsXMLProcessingInstruction(const nsAReadableString& aTarget,
const nsAReadableString& aData) :
nsXMLProcessingInstruction::nsXMLProcessingInstruction(const nsAString& aTarget,
const nsAString& aData) :
mTarget(aTarget)
{
nsGenericDOMDataNode::SetData(aData);
@ -233,7 +233,7 @@ NS_IMPL_RELEASE_INHERITED(nsXMLProcessingInstruction, nsGenericDOMDataNode)
NS_IMETHODIMP
nsXMLProcessingInstruction::GetTarget(nsAWritableString& aTarget)
nsXMLProcessingInstruction::GetTarget(nsAString& aTarget)
{
aTarget.Assign(mTarget);
@ -241,7 +241,7 @@ nsXMLProcessingInstruction::GetTarget(nsAWritableString& aTarget)
}
NS_IMETHODIMP
nsXMLProcessingInstruction::SetData(const nsAReadableString& aData)
nsXMLProcessingInstruction::SetData(const nsAString& aData)
{
nsresult rv = nsGenericDOMDataNode::SetData(aData);
UpdateStyleSheet(PR_TRUE);
@ -249,7 +249,7 @@ nsXMLProcessingInstruction::SetData(const nsAReadableString& aData)
}
NS_IMETHODIMP
nsXMLProcessingInstruction::GetData(nsAWritableString& aData)
nsXMLProcessingInstruction::GetData(nsAString& aData)
{
return nsGenericDOMDataNode::GetData(aData);
}
@ -326,7 +326,7 @@ nsXMLProcessingInstruction::GetTag(nsIAtom*& aResult) const
}
NS_IMETHODIMP
nsXMLProcessingInstruction::GetNodeName(nsAWritableString& aNodeName)
nsXMLProcessingInstruction::GetNodeName(nsAString& aNodeName)
{
aNodeName.Assign(mTarget);
return NS_OK;
@ -431,7 +431,7 @@ static PRBool InProlog(nsIDOMNode *aThis)
}
NS_IMETHODIMP
nsXMLProcessingInstruction::GetCharset(nsAWritableString& aCharset)
nsXMLProcessingInstruction::GetCharset(nsAString& aCharset)
{
if (!GetAttrValue(NS_LITERAL_STRING("charset"), aCharset)) {
return NS_ERROR_FAILURE;
@ -441,10 +441,10 @@ nsXMLProcessingInstruction::GetCharset(nsAWritableString& aCharset)
}
void
nsXMLProcessingInstruction::GetStyleSheetInfo(nsAWritableString& aUrl,
nsAWritableString& aTitle,
nsAWritableString& aType,
nsAWritableString& aMedia,
nsXMLProcessingInstruction::GetStyleSheetInfo(nsAString& aUrl,
nsAString& aTitle,
nsAString& aType,
nsAString& aMedia,
PRBool* aIsAlternate)
{
nsresult rv = NS_OK;

8
content/xml/document/src/nsXMLContentSink.cpp
View File

@ -539,7 +539,7 @@ nsXMLContentSink::SetParser(nsIParser* aParser)
// static
void
nsXMLContentSink::SplitXMLName(nsAReadableString& aString, nsIAtom **aPrefix,
nsXMLContentSink::SplitXMLName(const nsAString& aString, nsIAtom **aPrefix,
nsIAtom **aLocalName)
{
nsReadingIterator<PRUnichar> iter, end;
@ -764,7 +764,7 @@ nsXMLContentSink::ProcessBASETag()
}
nsresult
nsXMLContentSink::ProcessHeaderData(nsIAtom* aHeader,const nsAReadableString& aValue,nsIHTMLContent* aContent)
nsXMLContentSink::ProcessHeaderData(nsIAtom* aHeader,const nsAString& aValue,nsIHTMLContent* aContent)
{
nsresult rv=NS_OK;
// XXX necko isn't going to process headers coming in from the parser
@ -812,7 +812,7 @@ nsXMLContentSink::ProcessMETATag()
}
NS_IMETHODIMP
nsXMLContentSink::SetDocumentCharset(nsAWritableString& aCharset)
nsXMLContentSink::SetDocumentCharset(nsAString& aCharset)
{
if (mDocument) {
return mDocument->SetDocumentCharacterSet(aCharset);
@ -1819,7 +1819,7 @@ nsXMLContentSink::AddText(const PRUnichar* aText,
mTextSize = NS_ACCUMULATION_BUFFER_SIZE;
}
const nsAReadableString& str = Substring(aText, aText+aLength);
const nsAString& str = Substring(aText, aText+aLength);
// Copy data from string into our buffer; flush buffer when it fills up
PRInt32 offset = 0;

6
content/xml/document/src/nsXMLContentSink.h
View File

@ -108,7 +108,7 @@ public:
NS_IMETHOD WillResume(void);
NS_IMETHOD SetParser(nsIParser* aParser);
NS_IMETHOD FlushPendingNotifications() { return NS_OK; }
NS_IMETHOD SetDocumentCharset(nsAWritableString& aCharset);
NS_IMETHOD SetDocumentCharset(nsAString& aCharset);
// nsICSSLoaderObserver
NS_IMETHOD StyleSheetLoaded(nsICSSStyleSheet*aSheet, PRBool aNotify);
@ -143,7 +143,7 @@ protected:
nsresult AddContentAsLeaf(nsIContent *aContent);
static void SplitXMLName(nsAReadableString& aString, nsIAtom **aPrefix,
static void SplitXMLName(const nsAString& aString, nsIAtom **aPrefix,
nsIAtom **aTagName);
PRInt32 GetNameSpaceId(nsIAtom* aPrefix);
nsINameSpace* PopNameSpaces();
@ -157,7 +157,7 @@ protected:
nsresult ProcessBASETag();
nsresult ProcessMETATag();
nsresult ProcessLINKTag();
nsresult ProcessHeaderData(nsIAtom* aHeader,const nsAReadableString& aValue,nsIHTMLContent* aContent);
nsresult ProcessHeaderData(nsIAtom* aHeader,const nsAString& aValue,nsIHTMLContent* aContent);
nsresult RefreshIfEnabled(nsIViewManager* vm);

34
content/xml/document/src/nsXMLDocument.cpp
View File

@ -143,8 +143,8 @@ MyPrefChangedCallback(const char*aPrefName, void* instance_data)
NS_EXPORT nsresult
NS_NewDOMDocument(nsIDOMDocument** aInstancePtrResult,
const nsAReadableString& aNamespaceURI,
const nsAReadableString& aQualifiedName,
const nsAString& aNamespaceURI,
const nsAString& aQualifiedName,
nsIDOMDocumentType* aDoctype,
nsIURI* aBaseURI)
{
@ -326,13 +326,13 @@ nsXMLDocument::OnRedirect(nsIHttpChannel *aHttpChannel, nsIChannel *aNewChannel)
}
NS_IMETHODIMP
nsXMLDocument::EvaluateFIXptr(const nsAReadableString& aExpression, nsIDOMRange **aRange)
nsXMLDocument::EvaluateFIXptr(const nsAString& aExpression, nsIDOMRange **aRange)
{
return nsFIXptr::Evaluate(this, aExpression, aRange);
}
NS_IMETHODIMP
nsXMLDocument::Load(const nsAReadableString& aUrl)
nsXMLDocument::Load(const nsAString& aUrl)
{
nsCOMPtr<nsIChannel> channel;
nsCOMPtr<nsIURI> uri;
@ -740,7 +740,7 @@ nsXMLDocument::GetDoctype(nsIDOMDocumentType** aDocumentType)
}
NS_IMETHODIMP
nsXMLDocument::CreateCDATASection(const nsAReadableString& aData, nsIDOMCDATASection** aReturn)
nsXMLDocument::CreateCDATASection(const nsAString& aData, nsIDOMCDATASection** aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
*aReturn = nsnull;
@ -765,7 +765,7 @@ nsXMLDocument::CreateCDATASection(const nsAReadableString& aData, nsIDOMCDATASec
}
NS_IMETHODIMP
nsXMLDocument::CreateEntityReference(const nsAReadableString& aName, nsIDOMEntityReference** aReturn)
nsXMLDocument::CreateEntityReference(const nsAString& aName, nsIDOMEntityReference** aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
@ -774,8 +774,8 @@ nsXMLDocument::CreateEntityReference(const nsAReadableString& aName, nsIDOMEntit
}
NS_IMETHODIMP
nsXMLDocument::CreateProcessingInstruction(const nsAReadableString& aTarget,
const nsAReadableString& aData,
nsXMLDocument::CreateProcessingInstruction(const nsAString& aTarget,
const nsAString& aData,
nsIDOMProcessingInstruction** aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
@ -795,7 +795,7 @@ nsXMLDocument::CreateProcessingInstruction(const nsAReadableString& aTarget,
}
NS_IMETHODIMP
nsXMLDocument::CreateElement(const nsAReadableString& aTagName,
nsXMLDocument::CreateElement(const nsAString& aTagName,
nsIDOMElement** aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
@ -890,8 +890,8 @@ nsXMLDocument::ImportNode(nsIDOMNode* aImportedNode,
}
NS_IMETHODIMP
nsXMLDocument::CreateAttributeNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aQualifiedName,
nsXMLDocument::CreateAttributeNS(const nsAString& aNamespaceURI,
const nsAString& aQualifiedName,
nsIDOMAttr** aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
@ -912,8 +912,8 @@ nsXMLDocument::CreateAttributeNS(const nsAReadableString& aNamespaceURI,
}
NS_IMETHODIMP
nsXMLDocument::CreateElementNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aQualifiedName,
nsXMLDocument::CreateElementNS(const nsAString& aNamespaceURI,
const nsAString& aQualifiedName,
nsIDOMElement** aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
@ -930,7 +930,7 @@ nsXMLDocument::CreateElementNS(const nsAReadableString& aNamespaceURI,
}
static nsIContent *
MatchId(nsIContent *aContent, const nsAReadableString& aName)
MatchId(nsIContent *aContent, const nsAString& aName)
{
nsAutoString value;
nsIContent *result = nsnull;
@ -968,7 +968,7 @@ MatchId(nsIContent *aContent, const nsAReadableString& aName)
}
NS_IMETHODIMP
nsXMLDocument::GetElementById(const nsAReadableString& aElementId,
nsXMLDocument::GetElementById(const nsAString& aElementId,
nsIDOMElement** aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
@ -1024,14 +1024,14 @@ nsXMLDocument::SetDefaultStylesheets(nsIURI* aUrl)
}
NS_IMETHODIMP
nsXMLDocument::SetBaseTarget(const nsAReadableString &aBaseTarget)
nsXMLDocument::SetBaseTarget(const nsAString &aBaseTarget)
{
mBaseTarget.Assign(aBaseTarget);
return NS_OK;
}
NS_IMETHODIMP
nsXMLDocument::GetBaseTarget(nsAWritableString &aBaseTarget)
nsXMLDocument::GetBaseTarget(nsAString &aBaseTarget)
{
aBaseTarget.Assign(mBaseTarget);
return NS_OK;

22
content/xml/document/src/nsXMLDocument.h
View File

@ -79,29 +79,29 @@ public:
NS_IMETHOD EndLoad();
NS_IMETHOD GetBaseTarget(nsAWritableString &aBaseTarget);
NS_IMETHOD SetBaseTarget(const nsAReadableString &aBaseTarget);
NS_IMETHOD GetBaseTarget(nsAString &aBaseTarget);
NS_IMETHOD SetBaseTarget(const nsAString &aBaseTarget);
// nsIDOMNode interface
NS_IMETHOD CloneNode(PRBool aDeep, nsIDOMNode** aReturn);
// nsIDOMDocument interface
NS_IMETHOD GetDoctype(nsIDOMDocumentType** aDocumentType);
NS_IMETHOD CreateCDATASection(const nsAReadableString& aData, nsIDOMCDATASection** aReturn);
NS_IMETHOD CreateEntityReference(const nsAReadableString& aName, nsIDOMEntityReference** aReturn);
NS_IMETHOD CreateProcessingInstruction(const nsAReadableString& aTarget, const nsAReadableString& aData, nsIDOMProcessingInstruction** aReturn);
NS_IMETHOD CreateElement(const nsAReadableString& aTagName,
NS_IMETHOD CreateCDATASection(const nsAString& aData, nsIDOMCDATASection** aReturn);
NS_IMETHOD CreateEntityReference(const nsAString& aName, nsIDOMEntityReference** aReturn);
NS_IMETHOD CreateProcessingInstruction(const nsAString& aTarget, const nsAString& aData, nsIDOMProcessingInstruction** aReturn);
NS_IMETHOD CreateElement(const nsAString& aTagName,
nsIDOMElement** aReturn);
NS_IMETHOD ImportNode(nsIDOMNode* aImportedNode,
PRBool aDeep,
nsIDOMNode** aReturn);
NS_IMETHOD CreateElementNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aQualifiedName,
NS_IMETHOD CreateElementNS(const nsAString& aNamespaceURI,
const nsAString& aQualifiedName,
nsIDOMElement** aReturn);
NS_IMETHOD CreateAttributeNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aQualifiedName,
NS_IMETHOD CreateAttributeNS(const nsAString& aNamespaceURI,
const nsAString& aQualifiedName,
nsIDOMAttr** aReturn);
NS_IMETHOD GetElementById(const nsAReadableString& aElementId,
NS_IMETHOD GetElementById(const nsAString& aElementId,
nsIDOMElement** aReturn);
// nsIXMLDocument interface

2
content/xsl/document/src/nsXSLContentSink.cpp
View File

@ -43,7 +43,7 @@
#include "nsITransformMediator.h"
#include "nsIParser.h"
#include "nsIURL.h"
#include "nsString2.h"
#include "nsString.h"
#include "nsEscape.h"
nsresult

2
content/xul/content/public/nsIXULContent.h
View File

@ -114,7 +114,7 @@ public:
/**
* Add a script event listener to the element.
*/
NS_IMETHOD AddScriptEventListener(nsIAtom* aName, const nsAReadableString& aValue) = 0;
NS_IMETHOD AddScriptEventListener(nsIAtom* aName, const nsAString& aValue) = 0;
};
#endif // nsIXULContent_h__

4
content/xul/content/src/nsXULAttributeValue.cpp
View File

@ -61,7 +61,7 @@ nsXULAttributeValue::~nsXULAttributeValue()
nsresult nsXULAttributeValue::GetValue( nsAWritableString& aResult )
nsresult nsXULAttributeValue::GetValue( nsAString& aResult )
{
nsresult rv = NS_OK;
if (! mValue) {
@ -80,7 +80,7 @@ nsresult nsXULAttributeValue::GetValue( nsAWritableString& aResult )
}
nsresult nsXULAttributeValue::SetValue(const nsAReadableString& aValue,
nsresult nsXULAttributeValue::SetValue(const nsAString& aValue,
PRBool forceAtom)
{
nsCOMPtr<nsIAtom> newAtom;

4
content/xul/content/src/nsXULAttributeValue.h
View File

@ -64,9 +64,9 @@ public:
void ReleaseValue();
nsresult GetValue(nsAWritableString& aResult);
nsresult GetValue(nsAString& aResult);
nsresult SetValue(const nsAReadableString& aValue, PRBool forceAtom=PR_FALSE);
nsresult SetValue(const nsAString& aValue, PRBool forceAtom=PR_FALSE);
nsresult GetValueAsAtom(nsIAtom** aResult);
};

60
content/xul/content/src/nsXULAttributes.cpp
View File

@ -106,7 +106,7 @@ nsClassList::GetClasses(nsClassList* aList, nsVoidArray& aArray)
nsresult
nsClassList::ParseClasses(nsClassList** aList, const nsAReadableString& aClassString)
nsClassList::ParseClasses(nsClassList** aList, const nsAString& aClassString)
{
static const PRUnichar kNullCh = PRUnichar('\0');
@ -153,7 +153,7 @@ nsClassList::ParseClasses(nsClassList** aList, const nsAReadableString& aClassSt
nsXULAttribute::nsXULAttribute(nsIContent* aContent,
nsINodeInfo* aNodeInfo,
const nsAReadableString& aValue)
const nsAString& aValue)
: mContent(aContent),
mNodeInfo(aNodeInfo)
{
@ -171,7 +171,7 @@ nsXULAttribute::~nsXULAttribute()
nsresult
nsXULAttribute::Create(nsIContent* aContent,
nsINodeInfo* aNodeInfo,
const nsAReadableString& aValue,
const nsAString& aValue,
nsXULAttribute** aResult)
{
NS_ENSURE_ARG_POINTER(aNodeInfo);
@ -205,20 +205,20 @@ NS_IMPL_RELEASE(nsXULAttribute);
// nsIDOMNode interface
NS_IMETHODIMP
nsXULAttribute::GetNodeName(nsAWritableString& aNodeName)
nsXULAttribute::GetNodeName(nsAString& aNodeName)
{
GetQualifiedName(aNodeName);
return NS_OK;
}
NS_IMETHODIMP
nsXULAttribute::GetNodeValue(nsAWritableString& aNodeValue)
nsXULAttribute::GetNodeValue(nsAString& aNodeValue)
{
return mValue.GetValue(aNodeValue);
}
NS_IMETHODIMP
nsXULAttribute::SetNodeValue(const nsAReadableString& aNodeValue)
nsXULAttribute::SetNodeValue(const nsAString& aNodeValue)
{
return SetValue(aNodeValue);
}
@ -287,19 +287,19 @@ nsXULAttribute::GetOwnerDocument(nsIDOMDocument** aOwnerDocument)
}
NS_IMETHODIMP
nsXULAttribute::GetNamespaceURI(nsAWritableString& aNamespaceURI)
nsXULAttribute::GetNamespaceURI(nsAString& aNamespaceURI)
{
return mNodeInfo->GetNamespaceURI(aNamespaceURI);
}
NS_IMETHODIMP
nsXULAttribute::GetPrefix(nsAWritableString& aPrefix)
nsXULAttribute::GetPrefix(nsAString& aPrefix)
{
return mNodeInfo->GetPrefix(aPrefix);
}
NS_IMETHODIMP
nsXULAttribute::SetPrefix(const nsAReadableString& aPrefix)
nsXULAttribute::SetPrefix(const nsAString& aPrefix)
{
// XXX: Validate the prefix string!
@ -321,7 +321,7 @@ nsXULAttribute::SetPrefix(const nsAReadableString& aPrefix)
}
NS_IMETHODIMP
nsXULAttribute::GetLocalName(nsAWritableString& aLocalName)
nsXULAttribute::GetLocalName(nsAString& aLocalName)
{
return mNodeInfo->GetLocalName(aLocalName);
}
@ -380,8 +380,8 @@ nsXULAttribute::Normalize()
}
NS_IMETHODIMP
nsXULAttribute::IsSupported(const nsAReadableString& aFeature,
const nsAReadableString& aVersion,
nsXULAttribute::IsSupported(const nsAString& aFeature,
const nsAString& aVersion,
PRBool* aReturn)
{
NS_NOTYETIMPLEMENTED("write me");
@ -389,23 +389,23 @@ nsXULAttribute::IsSupported(const nsAReadableString& aFeature,
}
NS_IMETHODIMP
nsXULAttribute::GetBaseURI(nsAWritableString &aURI)
nsXULAttribute::GetBaseURI(nsAString &aURI)
{
NS_NOTYETIMPLEMENTED("write me");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsXULAttribute::LookupNamespacePrefix(const nsAReadableString& aNamespaceURI,
nsAWritableString& aPrefix)
nsXULAttribute::LookupNamespacePrefix(const nsAString& aNamespaceURI,
nsAString& aPrefix)
{
NS_NOTYETIMPLEMENTED("write me");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsXULAttribute::LookupNamespaceURI(const nsAReadableString& aNamespacePrefix,
nsAWritableString& aNamespaceURI)
nsXULAttribute::LookupNamespaceURI(const nsAString& aNamespacePrefix,
nsAString& aNamespaceURI)
{
NS_NOTYETIMPLEMENTED("write me");
return NS_ERROR_NOT_IMPLEMENTED;
@ -415,7 +415,7 @@ nsXULAttribute::LookupNamespaceURI(const nsAReadableString& aNamespacePrefix,
// nsIDOMAttr interface
NS_IMETHODIMP
nsXULAttribute::GetName(nsAWritableString& aName)
nsXULAttribute::GetName(nsAString& aName)
{
GetQualifiedName(aName);
return NS_OK;
@ -430,13 +430,13 @@ nsXULAttribute::GetSpecified(PRBool* aSpecified)
}
NS_IMETHODIMP
nsXULAttribute::GetValue(nsAWritableString& aValue)
nsXULAttribute::GetValue(nsAString& aValue)
{
return mValue.GetValue(aValue);
}
NS_IMETHODIMP
nsXULAttribute::SetValue(const nsAReadableString& aValue)
nsXULAttribute::SetValue(const nsAString& aValue)
{
// We call back to the content node's SetValue() method so we can
// share all of the work that it does.
@ -456,7 +456,7 @@ nsXULAttribute::GetOwnerElement(nsIDOMElement** aOwnerElement)
// Implementation methods
void
nsXULAttribute::GetQualifiedName(nsAWritableString& aQualifiedName)
nsXULAttribute::GetQualifiedName(nsAString& aQualifiedName)
{
mNodeInfo->GetQualifiedName(aQualifiedName);
}
@ -464,7 +464,7 @@ nsXULAttribute::GetQualifiedName(nsAWritableString& aQualifiedName)
nsresult
nsXULAttribute::SetValueInternal(const nsAReadableString& aValue)
nsXULAttribute::SetValueInternal(const nsAString& aValue)
{
return mValue.SetValue( aValue, mNodeInfo->Equals(nsXULAtoms::id) );
}
@ -544,7 +544,7 @@ nsXULAttributes::GetLength(PRUint32* aLength)
}
NS_IMETHODIMP
nsXULAttributes::GetNamedItem(const nsAReadableString& aName,
nsXULAttributes::GetNamedItem(const nsAString& aName,
nsIDOMNode** aReturn)
{
NS_PRECONDITION(aReturn != nsnull, "null ptr");
@ -591,7 +591,7 @@ nsXULAttributes::SetNamedItem(nsIDOMNode* aArg, nsIDOMNode** aReturn)
}
NS_IMETHODIMP
nsXULAttributes::RemoveNamedItem(const nsAReadableString& aName,
nsXULAttributes::RemoveNamedItem(const nsAString& aName,
nsIDOMNode** aReturn)
{
nsCOMPtr<nsIDOMElement> element( do_QueryInterface(mContent) );
@ -614,8 +614,8 @@ nsXULAttributes::Item(PRUint32 aIndex, nsIDOMNode** aReturn)
}
nsresult
nsXULAttributes::GetNamedItemNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aLocalName,
nsXULAttributes::GetNamedItemNS(const nsAString& aNamespaceURI,
const nsAString& aLocalName,
nsIDOMNode** aReturn)
{
NS_NOTYETIMPLEMENTED("write me");
@ -630,8 +630,8 @@ nsXULAttributes::SetNamedItemNS(nsIDOMNode* aArg, nsIDOMNode** aReturn)
}
nsresult
nsXULAttributes::RemoveNamedItemNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aLocalName,
nsXULAttributes::RemoveNamedItemNS(const nsAString& aNamespaceURI,
const nsAString& aLocalName,
nsIDOMNode** aReturn)
{
NS_NOTYETIMPLEMENTED("write me");
@ -665,12 +665,12 @@ nsresult nsXULAttributes::SetClassList(nsClassList* aClassList)
return NS_OK;
}
nsresult nsXULAttributes::UpdateClassList(const nsAReadableString& aValue)
nsresult nsXULAttributes::UpdateClassList(const nsAString& aValue)
{
return nsClassList::ParseClasses(&mClassList, aValue);
}
nsresult nsXULAttributes::UpdateStyleRule(nsIURI* aDocURL, const nsAReadableString& aValue)
nsresult nsXULAttributes::UpdateStyleRule(nsIURI* aDocURL, const nsAString& aValue)
{
if (aValue.IsEmpty())
{

14
content/xul/content/src/nsXULAttributes.h
View File

@ -105,7 +105,7 @@ public:
GetClasses(nsClassList* aList, nsVoidArray& aArray);
static nsresult
ParseClasses(nsClassList** aList, const nsAReadableString& aValue);
ParseClasses(nsClassList** aList, const nsAString& aValue);
};
////////////////////////////////////////////////////////////////////////
@ -116,7 +116,7 @@ class nsXULAttribute : public nsIDOMAttr,
protected:
nsXULAttribute(nsIContent* aContent,
nsINodeInfo* aNodeInfo,
const nsAReadableString& aValue);
const nsAString& aValue);
virtual ~nsXULAttribute();
@ -124,7 +124,7 @@ public:
static nsresult
Create(nsIContent* aContent,
nsINodeInfo* aNodeInfo,
const nsAReadableString& aValue,
const nsAString& aValue,
nsXULAttribute** aResult);
// nsISupports interface
@ -140,10 +140,10 @@ public:
NS_DECL_NSIDOMATTR
// Implementation methods
void GetQualifiedName(nsAWritableString& aAttributeName);
void GetQualifiedName(nsAString& aAttributeName);
nsINodeInfo* GetNodeInfo() const { return mNodeInfo; }
nsresult SetValueInternal(const nsAReadableString& aValue);
nsresult SetValueInternal(const nsAString& aValue);
nsresult GetValueAsAtom(nsIAtom** aResult);
protected:
@ -184,8 +184,8 @@ public:
nsresult HasClass(nsIAtom* aClass) const;
nsresult SetClassList(nsClassList* aClassList);
nsresult UpdateClassList(const nsAReadableString& aValue);
nsresult UpdateStyleRule(nsIURI* aDocURL, const nsAReadableString& aValue);
nsresult UpdateClassList(const nsAString& aValue);
nsresult UpdateStyleRule(nsIURI* aDocURL, const nsAString& aValue);
nsresult SetInlineStyleRule(nsIStyleRule* aRule);
nsresult GetInlineStyleRule(nsIStyleRule*& aRule);

200
content/xul/content/src/nsXULElement.cpp
View File

@ -710,21 +710,21 @@ nsXULElement::QueryInterface(REFNSIID iid, void** result)
// nsIDOMNode interface
NS_IMETHODIMP
nsXULElement::GetNodeName(nsAWritableString& aNodeName)
nsXULElement::GetNodeName(nsAString& aNodeName)
{
return NodeInfo()->GetQualifiedName(aNodeName);
}
NS_IMETHODIMP
nsXULElement::GetNodeValue(nsAWritableString& aNodeValue)
nsXULElement::GetNodeValue(nsAString& aNodeValue)
{
aNodeValue.Truncate();
return NS_OK;
}
NS_IMETHODIMP
nsXULElement::SetNodeValue(const nsAReadableString& aNodeValue)
nsXULElement::SetNodeValue(const nsAString& aNodeValue)
{
return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
}
@ -945,21 +945,21 @@ nsXULElement::GetOwnerDocument(nsIDOMDocument** aOwnerDocument)
NS_IMETHODIMP
nsXULElement::GetNamespaceURI(nsAWritableString& aNamespaceURI)
nsXULElement::GetNamespaceURI(nsAString& aNamespaceURI)
{
return NodeInfo()->GetNamespaceURI(aNamespaceURI);
}
NS_IMETHODIMP
nsXULElement::GetPrefix(nsAWritableString& aPrefix)
nsXULElement::GetPrefix(nsAString& aPrefix)
{
return NodeInfo()->GetPrefix(aPrefix);
}
NS_IMETHODIMP
nsXULElement::SetPrefix(const nsAReadableString& aPrefix)
nsXULElement::SetPrefix(const nsAString& aPrefix)
{
// XXX: Validate the prefix string!
@ -985,7 +985,7 @@ nsXULElement::SetPrefix(const nsAReadableString& aPrefix)
NS_IMETHODIMP
nsXULElement::GetLocalName(nsAWritableString& aLocalName)
nsXULElement::GetLocalName(nsAString& aLocalName)
{
return NodeInfo()->GetLocalName(aLocalName);
}
@ -1264,8 +1264,8 @@ nsXULElement::Normalize()
NS_IMETHODIMP
nsXULElement::IsSupported(const nsAReadableString& aFeature,
const nsAReadableString& aVersion,
nsXULElement::IsSupported(const nsAString& aFeature,
const nsAString& aVersion,
PRBool* aReturn)
{
NS_NOTYETIMPLEMENTED("write me!");
@ -1277,7 +1277,7 @@ nsXULElement::IsSupported(const nsAReadableString& aFeature,
// nsIDOMElement interface
NS_IMETHODIMP
nsXULElement::GetTagName(nsAWritableString& aTagName)
nsXULElement::GetTagName(nsAString& aTagName)
{
return NodeInfo()->GetQualifiedName(aTagName);
}
@ -1292,8 +1292,8 @@ nsXULElement::GetNodeInfo(nsINodeInfo*& aResult) const
}
NS_IMETHODIMP
nsXULElement::GetAttribute(const nsAReadableString& aName,
nsAWritableString& aReturn)
nsXULElement::GetAttribute(const nsAString& aName,
nsAString& aReturn)
{
nsresult rv;
PRInt32 nameSpaceID;
@ -1315,8 +1315,8 @@ nsXULElement::GetAttribute(const nsAReadableString& aName,
NS_IMETHODIMP
nsXULElement::SetAttribute(const nsAReadableString& aName,
const nsAReadableString& aValue)
nsXULElement::SetAttribute(const nsAString& aName,
const nsAString& aValue)
{
nsresult rv;
@ -1335,7 +1335,7 @@ nsXULElement::SetAttribute(const nsAReadableString& aName,
NS_IMETHODIMP
nsXULElement::RemoveAttribute(const nsAReadableString& aName)
nsXULElement::RemoveAttribute(const nsAString& aName)
{
nsresult rv;
@ -1359,7 +1359,7 @@ nsXULElement::RemoveAttribute(const nsAReadableString& aName)
NS_IMETHODIMP
nsXULElement::GetAttributeNode(const nsAReadableString& aName,
nsXULElement::GetAttributeNode(const nsAString& aName,
nsIDOMAttr** aReturn)
{
NS_PRECONDITION(aReturn != nsnull, "null ptr");
@ -1419,7 +1419,7 @@ nsXULElement::RemoveAttributeNode(nsIDOMAttr* aOldAttr, nsIDOMAttr** aReturn)
NS_IMETHODIMP
nsXULElement::GetElementsByTagName(const nsAReadableString& aName,
nsXULElement::GetElementsByTagName(const nsAString& aName,
nsIDOMNodeList** aReturn)
{
nsresult rv;
@ -1441,9 +1441,9 @@ nsXULElement::GetElementsByTagName(const nsAReadableString& aName,
}
NS_IMETHODIMP
nsXULElement::GetAttributeNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aLocalName,
nsAWritableString& aReturn)
nsXULElement::GetAttributeNS(const nsAString& aNamespaceURI,
const nsAString& aLocalName,
nsAString& aReturn)
{
nsCOMPtr<nsIAtom> name(dont_AddRef(NS_NewAtom(aLocalName)));
PRInt32 nsid;
@ -1463,9 +1463,9 @@ nsXULElement::GetAttributeNS(const nsAReadableString& aNamespaceURI,
}
NS_IMETHODIMP
nsXULElement::SetAttributeNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aQualifiedName,
const nsAReadableString& aValue)
nsXULElement::SetAttributeNS(const nsAString& aNamespaceURI,
const nsAString& aQualifiedName,
const nsAString& aValue)
{
nsCOMPtr<nsINodeInfoManager> nimgr;
nsresult rv = NodeInfo()->GetNodeInfoManager(*getter_AddRefs(nimgr));
@ -1479,8 +1479,8 @@ nsXULElement::SetAttributeNS(const nsAReadableString& aNamespaceURI,
}
NS_IMETHODIMP
nsXULElement::RemoveAttributeNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aLocalName)
nsXULElement::RemoveAttributeNS(const nsAString& aNamespaceURI,
const nsAString& aLocalName)
{
PRInt32 nameSpaceId;
nsCOMPtr<nsIAtom> tag = dont_AddRef(NS_NewAtom(aLocalName));
@ -1491,8 +1491,8 @@ nsXULElement::RemoveAttributeNS(const nsAReadableString& aNamespaceURI,
}
NS_IMETHODIMP
nsXULElement::GetAttributeNodeNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aLocalName,
nsXULElement::GetAttributeNodeNS(const nsAString& aNamespaceURI,
const nsAString& aLocalName,
nsIDOMAttr** aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
@ -1527,8 +1527,8 @@ nsXULElement::SetAttributeNodeNS(nsIDOMAttr* aNewAttr,
}
NS_IMETHODIMP
nsXULElement::GetElementsByTagNameNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aLocalName,
nsXULElement::GetElementsByTagNameNS(const nsAString& aNamespaceURI,
const nsAString& aLocalName,
nsIDOMNodeList** aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
@ -1567,7 +1567,7 @@ nsXULElement::GetElementsByTagNameNS(const nsAReadableString& aNamespaceURI,
}
NS_IMETHODIMP
nsXULElement::HasAttribute(const nsAReadableString& aName, PRBool* aReturn)
nsXULElement::HasAttribute(const nsAString& aName, PRBool* aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
@ -1586,8 +1586,8 @@ nsXULElement::HasAttribute(const nsAReadableString& aName, PRBool* aReturn)
}
NS_IMETHODIMP
nsXULElement::HasAttributeNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aLocalName,
nsXULElement::HasAttributeNS(const nsAString& aNamespaceURI,
const nsAString& aLocalName,
PRBool* aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
@ -1608,8 +1608,8 @@ nsXULElement::HasAttributeNS(const nsAReadableString& aNamespaceURI,
}
NS_IMETHODIMP
nsXULElement::GetElementsByAttribute(const nsAReadableString& aAttribute,
const nsAReadableString& aValue,
nsXULElement::GetElementsByAttribute(const nsAString& aAttribute,
const nsAString& aValue,
nsIDOMNodeList** aReturn)
{
nsresult rv;
@ -1655,7 +1655,7 @@ nsXULElement::GetXMLBaseURI(nsIURI **aURI)
#if 0
NS_IMETHODIMP
nsXULElement::GetBaseURI(nsAWritableString &aURI)
nsXULElement::GetBaseURI(nsAString &aURI)
{
// XXX TODO, should share the impl with nsXMLElement
aURI.Truncate();
@ -1720,7 +1720,7 @@ nsXULElement::GetLazyState(LazyState aFlag, PRBool& aResult)
NS_IMETHODIMP
nsXULElement::AddScriptEventListener(nsIAtom* aName,
const nsAReadableString& aValue)
const nsAString& aValue)
{
if (! mDocument)
return NS_OK; // XXX
@ -1797,7 +1797,7 @@ nsXULElement::RemoveEventListenerByIID(nsIDOMEventListener *aListener, const nsI
}
NS_IMETHODIMP
nsXULElement::AddEventListener(const nsAReadableString& aType,
nsXULElement::AddEventListener(const nsAString& aType,
nsIDOMEventListener* aListener,
PRBool aUseCapture)
{
@ -1814,7 +1814,7 @@ nsXULElement::AddEventListener(const nsAReadableString& aType,
}
NS_IMETHODIMP
nsXULElement::RemoveEventListener(const nsAReadableString& aType,
nsXULElement::RemoveEventListener(const nsAString& aType,
nsIDOMEventListener* aListener,
PRBool aUseCapture)
{
@ -1907,7 +1907,7 @@ NS_IMETHODIMP
nsXULElement::CompileEventHandler(nsIScriptContext* aContext,
void* aTarget,
nsIAtom *aName,
const nsAReadableString& aBody,
const nsAString& aBody,
void** aHandler)
{
nsresult rv;
@ -2496,7 +2496,7 @@ nsXULElement::GetTag(nsIAtom*& aResult) const
}
NS_IMETHODIMP
nsXULElement::NormalizeAttrString(const nsAReadableString& aStr,
nsXULElement::NormalizeAttrString(const nsAString& aStr,
nsINodeInfo*& aNodeInfo)
{
PRInt32 i, count = Attributes() ? Attributes()->Count() : 0;
@ -2577,7 +2577,7 @@ nsXULElement::UnregisterAccessKey(const nsAString& aOldValue)
// needed to maintain attribute namespace ID as well as ordering
NS_IMETHODIMP
nsXULElement::SetAttr(nsINodeInfo* aNodeInfo,
const nsAReadableString& aValue,
const nsAString& aValue,
PRBool aNotify)
{
NS_ASSERTION(nsnull != aNodeInfo, "must have attribute nodeinfo");
@ -2742,7 +2742,7 @@ nsXULElement::SetAttr(nsINodeInfo* aNodeInfo,
NS_IMETHODIMP
nsXULElement::SetAttr(PRInt32 aNameSpaceID,
nsIAtom* aName,
const nsAReadableString& aValue,
const nsAString& aValue,
PRBool aNotify)
{
nsCOMPtr<nsINodeInfoManager> nimgr;
@ -2759,7 +2759,7 @@ nsXULElement::SetAttr(PRInt32 aNameSpaceID,
NS_IMETHODIMP
nsXULElement::GetAttr(PRInt32 aNameSpaceID,
nsIAtom* aName,
nsAWritableString& aResult) const
nsAString& aResult) const
{
nsCOMPtr<nsIAtom> prefix;
return GetAttr(aNameSpaceID, aName, *getter_AddRefs(prefix), aResult);
@ -2769,7 +2769,7 @@ NS_IMETHODIMP
nsXULElement::GetAttr(PRInt32 aNameSpaceID,
nsIAtom* aName,
nsIAtom*& aPrefix,
nsAWritableString& aResult) const
nsAString& aResult) const
{
NS_ASSERTION(nsnull != aName, "must have attribute name");
if (nsnull == aName) {
@ -3666,7 +3666,7 @@ nsXULElement::EnsureContentsGenerated(void) const
nsresult
nsXULElement::GetElementsByTagName(nsIDOMNode* aNode,
const nsAReadableString& aTagName,
const nsAString& aTagName,
nsRDFDOMNodeList* aElements)
{
nsresult rv;
@ -3732,8 +3732,8 @@ nsXULElement::GetElementsByTagName(nsIDOMNode* aNode,
nsresult
nsXULElement::GetElementsByAttribute(nsIDOMNode* aNode,
const nsAReadableString& aAttribute,
const nsAReadableString& aValue,
const nsAString& aAttribute,
const nsAString& aValue,
nsRDFDOMNodeList* aElements)
{
nsresult rv;
@ -3982,126 +3982,126 @@ nsXULElement::GetBoxObject(nsIBoxObject** aResult)
// Methods for setting/getting attributes from nsIDOMXULElement
nsresult
nsXULElement::GetId(nsAWritableString& aId)
nsXULElement::GetId(nsAString& aId)
{
GetAttribute(NS_LITERAL_STRING("id"), aId);
return NS_OK;
}
nsresult
nsXULElement::SetId(const nsAReadableString& aId)
nsXULElement::SetId(const nsAString& aId)
{
SetAttribute(NS_LITERAL_STRING("id"), aId);
return NS_OK;
}
nsresult
nsXULElement::GetClassName(nsAWritableString& aClassName)
nsXULElement::GetClassName(nsAString& aClassName)
{
GetAttribute(NS_LITERAL_STRING("class"), aClassName);
return NS_OK;
}
nsresult
nsXULElement::SetClassName(const nsAReadableString& aClassName)
nsXULElement::SetClassName(const nsAString& aClassName)
{
SetAttribute(NS_LITERAL_STRING("class"), aClassName);
return NS_OK;
}
nsresult
nsXULElement::GetAlign(nsAWritableString& aAttr)
nsXULElement::GetAlign(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("align"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetAlign(const nsAReadableString& aAttr)
nsXULElement::SetAlign(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("align"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetDir(nsAWritableString& aAttr)
nsXULElement::GetDir(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("dir"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetDir(const nsAReadableString& aAttr)
nsXULElement::SetDir(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("dir"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetFlex(nsAWritableString& aAttr)
nsXULElement::GetFlex(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("flex"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetFlex(const nsAReadableString& aAttr)
nsXULElement::SetFlex(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("flex"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetFlexGroup(nsAWritableString& aAttr)
nsXULElement::GetFlexGroup(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("flexgroup"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetFlexGroup(const nsAReadableString& aAttr)
nsXULElement::SetFlexGroup(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("flexgroup"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetOrdinal(nsAWritableString& aAttr)
nsXULElement::GetOrdinal(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("ordinal"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetOrdinal(const nsAReadableString& aAttr)
nsXULElement::SetOrdinal(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("ordinal"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetOrient(nsAWritableString& aAttr)
nsXULElement::GetOrient(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("orient"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetOrient(const nsAReadableString& aAttr)
nsXULElement::SetOrient(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("orient"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetPack(nsAWritableString& aAttr)
nsXULElement::GetPack(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("pack"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetPack(const nsAReadableString& aAttr)
nsXULElement::SetPack(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("pack"), aAttr);
return NS_OK;
@ -4171,238 +4171,238 @@ nsXULElement::SetAllowEvents(PRBool aAttr)
}
nsresult
nsXULElement::GetObserves(nsAWritableString& aAttr)
nsXULElement::GetObserves(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("observes"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetObserves(const nsAReadableString& aAttr)
nsXULElement::SetObserves(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("observes"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetMenu(nsAWritableString& aAttr)
nsXULElement::GetMenu(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("menu"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetMenu(const nsAReadableString& aAttr)
nsXULElement::SetMenu(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("menu"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetContextMenu(nsAWritableString& aAttr)
nsXULElement::GetContextMenu(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("contextmenu"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetContextMenu(const nsAReadableString& aAttr)
nsXULElement::SetContextMenu(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("contextmenu"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetTooltip(nsAWritableString& aAttr)
nsXULElement::GetTooltip(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("tooltip"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetTooltip(const nsAReadableString& aAttr)
nsXULElement::SetTooltip(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("tooltip"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetWidth(nsAWritableString& aAttr)
nsXULElement::GetWidth(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("width"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetWidth(const nsAReadableString& aAttr)
nsXULElement::SetWidth(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("width"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetHeight(nsAWritableString& aAttr)
nsXULElement::GetHeight(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("height"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetHeight(const nsAReadableString& aAttr)
nsXULElement::SetHeight(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("height"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetMinWidth(nsAWritableString& aAttr)
nsXULElement::GetMinWidth(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("minwidth"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetMinWidth(const nsAReadableString& aAttr)
nsXULElement::SetMinWidth(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("minwidth"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetMinHeight(nsAWritableString& aAttr)
nsXULElement::GetMinHeight(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("minheight"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetMinHeight(const nsAReadableString& aAttr)
nsXULElement::SetMinHeight(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("minheight"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetMaxWidth(nsAWritableString& aAttr)
nsXULElement::GetMaxWidth(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("maxwidth"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetMaxWidth(const nsAReadableString& aAttr)
nsXULElement::SetMaxWidth(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("maxwidth"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetMaxHeight(nsAWritableString& aAttr)
nsXULElement::GetMaxHeight(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("maxheight"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetMaxHeight(const nsAReadableString& aAttr)
nsXULElement::SetMaxHeight(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("maxheight"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetPersist(nsAWritableString& aAttr)
nsXULElement::GetPersist(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("persist"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetPersist(const nsAReadableString& aAttr)
nsXULElement::SetPersist(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("maxheight"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetLeft(nsAWritableString& aAttr)
nsXULElement::GetLeft(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("left"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetLeft(const nsAReadableString& aAttr)
nsXULElement::SetLeft(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("left"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetTop(nsAWritableString& aAttr)
nsXULElement::GetTop(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("top"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetTop(const nsAReadableString& aAttr)
nsXULElement::SetTop(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("top"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetDatasources(nsAWritableString& aAttr)
nsXULElement::GetDatasources(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("datasources"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetDatasources(const nsAReadableString& aAttr)
nsXULElement::SetDatasources(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("datasources"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetRef(nsAWritableString& aAttr)
nsXULElement::GetRef(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("ref"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetRef(const nsAReadableString& aAttr)
nsXULElement::SetRef(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("ref"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetTooltipText(nsAWritableString& aAttr)
nsXULElement::GetTooltipText(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("tooltiptext"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetTooltipText(const nsAReadableString& aAttr)
nsXULElement::SetTooltipText(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("tooltiptext"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::GetStatusText(nsAWritableString& aAttr)
nsXULElement::GetStatusText(nsAString& aAttr)
{
GetAttribute(NS_LITERAL_STRING("statustext"), aAttr);
return NS_OK;
}
nsresult
nsXULElement::SetStatusText(const nsAReadableString& aAttr)
nsXULElement::SetStatusText(const nsAString& aAttr)
{
SetAttribute(NS_LITERAL_STRING("statustext"), aAttr);
return NS_OK;
@ -4964,7 +4964,7 @@ nsXULPrototypeElement::Deserialize(nsIObjectInputStream* aStream,
nsresult
nsXULPrototypeElement::GetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, nsAWritableString& aValue)
nsXULPrototypeElement::GetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, nsAString& aValue)
{
for (PRInt32 i = 0; i < mNumAttributes; ++i) {
if (mAttributes[i].mNodeInfo->Equals(aName, aNameSpaceID)) {

28
content/xul/content/src/nsXULElement.h
View File

@ -262,7 +262,7 @@ public:
nsCOMPtr<nsIStyleRule> mInlineStyleRule; // [OWNER]
nsClassList* mClassList;
nsresult GetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, nsAWritableString& aValue);
nsresult GetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, nsAString& aValue);
};
struct JSRuntime;
@ -369,11 +369,11 @@ public:
NS_IMETHOD GetNameSpaceID(PRInt32& aNameSpeceID) const;
NS_IMETHOD GetTag(nsIAtom*& aResult) const;
NS_IMETHOD GetNodeInfo(nsINodeInfo*& aResult) const;
NS_IMETHOD NormalizeAttrString(const nsAReadableString& aStr, nsINodeInfo*& aNodeInfo);
NS_IMETHOD SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, const nsAReadableString& aValue, PRBool aNotify);
NS_IMETHOD SetAttr(nsINodeInfo *aNodeInfo, const nsAReadableString& aValue, PRBool aNotify);
NS_IMETHOD GetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, nsAWritableString& aResult) const;
NS_IMETHOD GetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, nsIAtom*& aPrefix, nsAWritableString& aResult) const;
NS_IMETHOD NormalizeAttrString(const nsAString& aStr, nsINodeInfo*& aNodeInfo);
NS_IMETHOD SetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, const nsAString& aValue, PRBool aNotify);
NS_IMETHOD SetAttr(nsINodeInfo *aNodeInfo, const nsAString& aValue, PRBool aNotify);
NS_IMETHOD GetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, nsAString& aResult) const;
NS_IMETHOD GetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, nsIAtom*& aPrefix, nsAString& aResult) const;
NS_IMETHOD_(PRBool) HasAttr(PRInt32 aNameSpaceID, nsIAtom* aName) const;
NS_IMETHOD UnsetAttr(PRInt32 aNameSpaceID, nsIAtom* aName, PRBool aNotify);
NS_IMETHOD GetAttrNameAt(PRInt32 aIndex, PRInt32& aNameSpaceID,
@ -423,7 +423,7 @@ public:
NS_IMETHOD SetLazyState(LazyState aFlags);
NS_IMETHOD ClearLazyState(LazyState aFlags);
NS_IMETHOD GetLazyState(LazyState aFlag, PRBool& aValue);
NS_IMETHOD AddScriptEventListener(nsIAtom* aName, const nsAReadableString& aValue);
NS_IMETHOD AddScriptEventListener(nsIAtom* aName, const nsAString& aValue);
// nsIDOMNode (from nsIDOMElement)
NS_DECL_NSIDOMNODE
@ -435,9 +435,9 @@ public:
NS_DECL_NSIDOMXULELEMENT
// nsIDOMEventTarget interface (from nsIDOMEventReceiver)
NS_IMETHOD AddEventListener(const nsAReadableString& aType, nsIDOMEventListener* aListener,
NS_IMETHOD AddEventListener(const nsAString& aType, nsIDOMEventListener* aListener,
PRBool aUseCapture);
NS_IMETHOD RemoveEventListener(const nsAReadableString& aType, nsIDOMEventListener* aListener,
NS_IMETHOD RemoveEventListener(const nsAString& aType, nsIDOMEventListener* aListener,
PRBool aUseCapture);
NS_IMETHOD DispatchEvent(nsIDOMEvent* aEvent, PRBool* _retval);
@ -451,7 +451,7 @@ public:
NS_IMETHOD CompileEventHandler(nsIScriptContext* aContext,
void* aTarget,
nsIAtom *aName,
const nsAReadableString& aBody,
const nsAString& aBody,
void** aHandler);
NS_IMETHOD GetCompiledEventHandler(nsIAtom *aName, void** aHandler);
@ -472,7 +472,7 @@ protected:
// Implementation methods
nsresult EnsureContentsGenerated(void) const;
nsresult ExecuteOnBroadcastHandler(nsIDOMElement* anElement, const nsAReadableString& attrName);
nsresult ExecuteOnBroadcastHandler(nsIDOMElement* anElement, const nsAString& attrName);
static nsresult
ExecuteJSCode(nsIDOMElement* anElement, nsEvent* aEvent);
@ -480,13 +480,13 @@ protected:
// Static helpers
static nsresult
GetElementsByTagName(nsIDOMNode* aNode,
const nsAReadableString& aTagName,
const nsAString& aTagName,
nsRDFDOMNodeList* aElements);
static nsresult
GetElementsByAttribute(nsIDOMNode* aNode,
const nsAReadableString& aAttributeName,
const nsAReadableString& aAttributeValue,
const nsAString& aAttributeName,
const nsAString& aAttributeValue,
nsRDFDOMNodeList* aElements);
static PRBool IsAncestor(nsIDOMNode* aParentNode, nsIDOMNode* aChildNode);

6
content/xul/document/public/nsIXULDocument.h
View File

@ -86,19 +86,19 @@ public:
/**
* Add an entry to the ID-to-element map.
*/
NS_IMETHOD AddElementForID(const nsAReadableString& aID, nsIContent* aElement) = 0;
NS_IMETHOD AddElementForID(const nsAString& aID, nsIContent* aElement) = 0;
/**
* Remove an entry from the ID-to-element map.
*/
NS_IMETHOD RemoveElementForID(const nsAReadableString& aID, nsIContent* aElement) = 0;
NS_IMETHOD RemoveElementForID(const nsAString& aID, nsIContent* aElement) = 0;
/**
* Get the elements for a particular resource in the resource-to-element
* map. The nsISupportsArray will be truncated and filled in with
* nsIContent pointers.
*/
NS_IMETHOD GetElementsForID(const nsAReadableString& aID, nsISupportsArray* aElements) = 0;
NS_IMETHOD GetElementsForID(const nsAString& aID, nsISupportsArray* aElements) = 0;
/**
* Add a "forward declaration" of a XUL observer. Such declarations

6
content/xul/document/public/nsIXULPrototypeDocument.h
View File

@ -46,7 +46,7 @@
#define nsIXULPrototypeDocument_h__
#include "nsISerializable.h"
#include "nsAWritableString.h"
#include "nsAString.h"
class nsIAtom;
class nsIPrincipal;
@ -85,8 +85,8 @@ public:
NS_IMETHOD AddOverlayReference(nsIURI* aURI) = 0;
NS_IMETHOD GetOverlayReferences(nsISupportsArray** aResult) = 0;
NS_IMETHOD GetHeaderData(nsIAtom* aField, nsAWritableString& aData) const = 0;
NS_IMETHOD SetHeaderData(nsIAtom* aField, const nsAReadableString& aData) = 0;
NS_IMETHOD GetHeaderData(nsIAtom* aField, nsAString& aData) const = 0;
NS_IMETHOD SetHeaderData(nsIAtom* aField, const nsAString& aData) = 0;
NS_IMETHOD GetDocumentPrincipal(nsIPrincipal** aResult) = 0;
NS_IMETHOD SetDocumentPrincipal(nsIPrincipal* aPrincipal) = 0;

14
content/xul/document/src/nsControllerCommandManager.cpp
View File

@ -64,7 +64,7 @@ NS_IMPL_ISUPPORTS2(nsControllerCommandManager, nsIControllerCommandManager, nsIS
NS_IMETHODIMP
nsControllerCommandManager::RegisterCommand(const nsAReadableString & aCommandName, nsIControllerCommand *aCommand)
nsControllerCommandManager::RegisterCommand(const nsAString & aCommandName, nsIControllerCommand *aCommand)
{
nsStringKey commandKey(aCommandName);
@ -81,7 +81,7 @@ nsControllerCommandManager::RegisterCommand(const nsAReadableString & aCommandNa
NS_IMETHODIMP
nsControllerCommandManager::UnregisterCommand(const nsAReadableString & aCommandName, nsIControllerCommand *aCommand)
nsControllerCommandManager::UnregisterCommand(const nsAString & aCommandName, nsIControllerCommand *aCommand)
{
nsStringKey commandKey(aCommandName);
@ -91,7 +91,7 @@ nsControllerCommandManager::UnregisterCommand(const nsAReadableString & aCommand
NS_IMETHODIMP
nsControllerCommandManager::FindCommandHandler(const nsAReadableString & aCommandName, nsIControllerCommand **outCommand)
nsControllerCommandManager::FindCommandHandler(const nsAString & aCommandName, nsIControllerCommand **outCommand)
{
NS_ENSURE_ARG_POINTER(outCommand);
@ -109,7 +109,7 @@ nsControllerCommandManager::FindCommandHandler(const nsAReadableString & aComman
/* boolean isCommandEnabled (in wstring command); */
NS_IMETHODIMP
nsControllerCommandManager::IsCommandEnabled(const nsAReadableString & aCommandName, nsISupports *aCommandRefCon, PRBool *aResult)
nsControllerCommandManager::IsCommandEnabled(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
@ -133,7 +133,7 @@ nsControllerCommandManager::IsCommandEnabled(const nsAReadableString & aCommandN
NS_IMETHODIMP
nsControllerCommandManager::UpdateCommandState(const nsAReadableString & aCommandName, nsISupports *aCommandRefCon)
nsControllerCommandManager::UpdateCommandState(const nsAString & aCommandName, nsISupports *aCommandRefCon)
{
// find the command
nsCOMPtr<nsIControllerCommand> commandHandler;
@ -163,7 +163,7 @@ nsControllerCommandManager::UpdateCommandState(const nsAReadableString & aComman
}
NS_IMETHODIMP
nsControllerCommandManager::SupportsCommand(const nsAReadableString & aCommandName, nsISupports *aCommandRefCon, PRBool *aResult)
nsControllerCommandManager::SupportsCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon, PRBool *aResult)
{
NS_ENSURE_ARG_POINTER(aResult);
@ -181,7 +181,7 @@ nsControllerCommandManager::SupportsCommand(const nsAReadableString & aCommandNa
/* void doCommand (in wstring command); */
NS_IMETHODIMP
nsControllerCommandManager::DoCommand(const nsAReadableString & aCommandName, nsISupports *aCommandRefCon)
nsControllerCommandManager::DoCommand(const nsAString & aCommandName, nsISupports *aCommandRefCon)
{
// find the command
nsCOMPtr<nsIControllerCommand> commandHandler;

8
content/xul/document/src/nsElementMap.cpp
View File

@ -163,7 +163,7 @@ nsElementMap::ReleaseContentList(PLHashEntry* aHashEntry, PRIntn aIndex, void* a
nsresult
nsElementMap::Add(const nsAReadableString& aID, nsIContent* aContent)
nsElementMap::Add(const nsAString& aID, nsIContent* aContent)
{
NS_PRECONDITION(mMap != nsnull, "not initialized");
if (! mMap)
@ -262,7 +262,7 @@ nsElementMap::Add(const nsAReadableString& aID, nsIContent* aContent)
nsresult
nsElementMap::Remove(const nsAReadableString& aID, nsIContent* aContent)
nsElementMap::Remove(const nsAString& aID, nsIContent* aContent)
{
NS_PRECONDITION(mMap != nsnull, "not initialized");
if (! mMap)
@ -340,7 +340,7 @@ nsElementMap::Remove(const nsAReadableString& aID, nsIContent* aContent)
nsresult
nsElementMap::Find(const nsAReadableString& aID, nsISupportsArray* aResults)
nsElementMap::Find(const nsAString& aID, nsISupportsArray* aResults)
{
NS_PRECONDITION(mMap != nsnull, "not initialized");
if (! mMap)
@ -359,7 +359,7 @@ nsElementMap::Find(const nsAReadableString& aID, nsISupportsArray* aResults)
nsresult
nsElementMap::FindFirst(const nsAReadableString& aID, nsIContent** aResult)
nsElementMap::FindFirst(const nsAString& aID, nsIContent** aResult)
{
NS_PRECONDITION(mMap != nsnull, "not initialized");
if (! mMap)

8
content/xul/document/src/nsElementMap.h
View File

@ -106,16 +106,16 @@ public:
virtual ~nsElementMap();
nsresult
Add(const nsAReadableString& aID, nsIContent* aContent);
Add(const nsAString& aID, nsIContent* aContent);
nsresult
Remove(const nsAReadableString& aID, nsIContent* aContent);
Remove(const nsAString& aID, nsIContent* aContent);
nsresult
Find(const nsAReadableString& aID, nsISupportsArray* aResults);
Find(const nsAString& aID, nsISupportsArray* aResults);
nsresult
FindFirst(const nsAReadableString& aID, nsIContent** aContent);
FindFirst(const nsAString& aID, nsIContent** aContent);
typedef PRIntn (*nsElementMapEnumerator)(const PRUnichar* aID,
nsIContent* aElement,

10
content/xul/document/src/nsXULCommandDispatcher.cpp
View File

@ -208,8 +208,8 @@ nsXULCommandDispatcher::AdvanceFocusIntoSubtree(nsIDOMElement* aElt)
NS_IMETHODIMP
nsXULCommandDispatcher::AddCommandUpdater(nsIDOMElement* aElement,
const nsAReadableString& aEvents,
const nsAReadableString& aTargets)
const nsAString& aEvents,
const nsAString& aTargets)
{
NS_PRECONDITION(aElement != nsnull, "null ptr");
if (! aElement)
@ -305,7 +305,7 @@ nsXULCommandDispatcher::RemoveCommandUpdater(nsIDOMElement* aElement)
}
NS_IMETHODIMP
nsXULCommandDispatcher::UpdateCommands(const nsAReadableString& aEventName)
nsXULCommandDispatcher::UpdateCommands(const nsAString& aEventName)
{
nsresult rv;
@ -385,7 +385,7 @@ nsXULCommandDispatcher::UpdateCommands(const nsAReadableString& aEventName)
PRBool
nsXULCommandDispatcher::Matches(const nsString& aList,
const nsAReadableString& aElement)
const nsAString& aElement)
{
if (aList.Equals(NS_LITERAL_STRING("*")))
return PR_TRUE; // match _everything_!
@ -419,7 +419,7 @@ nsXULCommandDispatcher::GetControllers(nsIControllers** aResult)
}
NS_IMETHODIMP
nsXULCommandDispatcher::GetControllerForCommand(const nsAReadableString& aCommand, nsIController** _retval)
nsXULCommandDispatcher::GetControllerForCommand(const nsAString& aCommand, nsIController** _retval)
{
EnsureFocusController();
return mFocusController->GetControllerForCommand(aCommand, _retval);

6
content/xul/document/src/nsXULCommandDispatcher.h
View File

@ -85,8 +85,8 @@ protected:
class Updater {
public:
Updater(nsIDOMElement* aElement,
const nsAReadableString& aEvents,
const nsAReadableString& aTargets)
const nsAString& aEvents,
const nsAString& aTargets)
: mElement(aElement),
mEvents(aEvents),
mTargets(aTargets),
@ -102,7 +102,7 @@ protected:
Updater* mUpdaters;
PRBool Matches(const nsString& aList,
const nsAReadableString& aElement);
const nsAString& aElement);
};
#endif // nsXULCommandDispatcher_h__

4
content/xul/document/src/nsXULContentSink.cpp
View File

@ -144,7 +144,7 @@ public:
NS_IMETHOD WillResume(void);
NS_IMETHOD SetParser(nsIParser* aParser);
NS_IMETHOD FlushPendingNotifications() { return NS_OK; }
NS_IMETHOD SetDocumentCharset(nsAWritableString& aCharset);
NS_IMETHOD SetDocumentCharset(nsAString& aCharset);
// nsIXULContentSink
NS_IMETHOD Init(nsIDocument* aDocument, nsIXULPrototypeDocument* aPrototype);
@ -658,7 +658,7 @@ XULContentSinkImpl::ProcessStyleLink(nsIContent* aElement,
}
NS_IMETHODIMP
XULContentSinkImpl::SetDocumentCharset(nsAWritableString& aCharset)
XULContentSinkImpl::SetDocumentCharset(nsAString& aCharset)
{
nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocument);
if (doc) {

2
content/xul/document/src/nsXULControllers.cpp
View File

@ -130,7 +130,7 @@ nsXULControllers::SetCommandDispatcher(nsIDOMXULCommandDispatcher* aCommandDispa
}
NS_IMETHODIMP
nsXULControllers::GetControllerForCommand(const nsAReadableString& aCommand, nsIController** _retval)
nsXULControllers::GetControllerForCommand(const nsAString& aCommand, nsIController** _retval)
{
NS_ENSURE_ARG_POINTER(_retval);
*_retval = nsnull;

132
content/xul/document/src/nsXULDocument.cpp
View File

@ -638,14 +638,14 @@ nsXULDocument::GetArena(nsIArena** aArena)
// "cached XUL" type which is completely internal and may confuse
// people
NS_IMETHODIMP
nsXULDocument::GetContentType(nsAWritableString& aContentType)
nsXULDocument::GetContentType(nsAString& aContentType)
{
aContentType.Assign(NS_LITERAL_STRING("application/vnd.mozilla.xul+xml"));
return NS_OK;
}
NS_IMETHODIMP
nsXULDocument::GetContentLanguage(nsAWritableString& aContentLanguage) const
nsXULDocument::GetContentLanguage(nsAString& aContentLanguage) const
{
aContentLanguage.Truncate();
return NS_OK;
@ -891,14 +891,14 @@ nsXULDocument::SetBaseURL(nsIURI* aURL)
}
NS_IMETHODIMP
nsXULDocument::GetBaseTarget(nsAWritableString &aBaseTarget)
nsXULDocument::GetBaseTarget(nsAString &aBaseTarget)
{
aBaseTarget.Truncate();
return NS_OK;
}
NS_IMETHODIMP
nsXULDocument::SetBaseTarget(const nsAReadableString &aBaseTarget)
nsXULDocument::SetBaseTarget(const nsAString &aBaseTarget)
{
return NS_OK;
}
@ -920,14 +920,14 @@ nsXULDocument::GetStyleSheets(nsIDOMStyleSheetList** aStyleSheets)
}
NS_IMETHODIMP
nsXULDocument::GetDocumentCharacterSet(nsAWritableString& oCharSetID)
nsXULDocument::GetDocumentCharacterSet(nsAString& oCharSetID)
{
oCharSetID.Assign(mCharSetID);
return NS_OK;
}
NS_IMETHODIMP
nsXULDocument::SetDocumentCharacterSet(const nsAReadableString& aCharSetID)
nsXULDocument::SetDocumentCharacterSet(const nsAString& aCharSetID)
{
if (!mCharSetID.Equals(aCharSetID)) {
mCharSetID.Assign(aCharSetID);
@ -1039,7 +1039,7 @@ nsXULDocument::SetWordBreaker(nsIWordBreaker* aWordBreaker)
NS_IMETHODIMP
nsXULDocument::GetHeaderData(nsIAtom* aHeaderField,
nsAWritableString& aData) const
nsAString& aData) const
{
aData.Truncate();
return NS_OK;
@ -1047,7 +1047,7 @@ nsXULDocument::GetHeaderData(nsIAtom* aHeaderField,
NS_IMETHODIMP
nsXULDocument:: SetHeaderData(nsIAtom* aHeaderField,
const nsAReadableString& aData)
const nsAString& aData)
{
return NS_OK;
}
@ -2329,7 +2329,7 @@ nsXULDocument::SelectAll()
}
NS_IMETHODIMP
nsXULDocument::FindNext(const nsAReadableString &aSearchStr,
nsXULDocument::FindNext(const nsAString &aSearchStr,
PRBool aMatchCase, PRBool aSearchDown,
PRBool &aIsFound)
{
@ -2511,7 +2511,7 @@ nsXULDocument::SetTitle(const PRUnichar *aTitle)
//
NS_IMETHODIMP
nsXULDocument::AddElementForID(const nsAReadableString& aID, nsIContent* aElement)
nsXULDocument::AddElementForID(const nsAString& aID, nsIContent* aElement)
{
NS_PRECONDITION(aElement != nsnull, "null ptr");
if (! aElement)
@ -2523,7 +2523,7 @@ nsXULDocument::AddElementForID(const nsAReadableString& aID, nsIContent* aElemen
NS_IMETHODIMP
nsXULDocument::RemoveElementForID(const nsAReadableString& aID, nsIContent* aElement)
nsXULDocument::RemoveElementForID(const nsAString& aID, nsIContent* aElement)
{
NS_PRECONDITION(aElement != nsnull, "null ptr");
if (! aElement)
@ -2534,7 +2534,7 @@ nsXULDocument::RemoveElementForID(const nsAReadableString& aID, nsIContent* aEle
}
NS_IMETHODIMP
nsXULDocument::GetElementsForID(const nsAReadableString& aID, nsISupportsArray* aElements)
nsXULDocument::GetElementsForID(const nsAString& aID, nsISupportsArray* aElements)
{
NS_PRECONDITION(aElements != nsnull, "null ptr");
if (! aElements)
@ -2681,7 +2681,7 @@ nsXULDocument::GetDocumentElement(nsIDOMElement** aDocumentElement)
NS_IMETHODIMP
nsXULDocument::CreateElement(const nsAReadableString& aTagName,
nsXULDocument::CreateElement(const nsAString& aTagName,
nsIDOMElement** aReturn)
{
NS_PRECONDITION(aReturn != nsnull, "null ptr");
@ -2736,7 +2736,7 @@ nsXULDocument::CreateDocumentFragment(nsIDOMDocumentFragment** aReturn)
NS_IMETHODIMP
nsXULDocument::CreateTextNode(const nsAReadableString& aData,
nsXULDocument::CreateTextNode(const nsAString& aData,
nsIDOMText** aReturn)
{
NS_PRECONDITION(aReturn != nsnull, "null ptr");
@ -2761,7 +2761,7 @@ nsXULDocument::CreateTextNode(const nsAReadableString& aData,
NS_IMETHODIMP
nsXULDocument::CreateComment(const nsAReadableString& aData,
nsXULDocument::CreateComment(const nsAString& aData,
nsIDOMComment** aReturn)
{
nsCOMPtr<nsIContent> comment;
@ -2778,7 +2778,7 @@ nsXULDocument::CreateComment(const nsAReadableString& aData,
NS_IMETHODIMP
nsXULDocument::CreateCDATASection(const nsAReadableString& aData,
nsXULDocument::CreateCDATASection(const nsAString& aData,
nsIDOMCDATASection** aReturn)
{
NS_NOTREACHED("nsXULDocument::CreateCDATASection");
@ -2787,8 +2787,8 @@ nsXULDocument::CreateCDATASection(const nsAReadableString& aData,
NS_IMETHODIMP
nsXULDocument::CreateProcessingInstruction(const nsAReadableString& aTarget,
const nsAReadableString& aData,
nsXULDocument::CreateProcessingInstruction(const nsAString& aTarget,
const nsAString& aData,
nsIDOMProcessingInstruction** aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
@ -2807,7 +2807,7 @@ nsXULDocument::CreateProcessingInstruction(const nsAReadableString& aTarget,
NS_IMETHODIMP
nsXULDocument::CreateAttribute(const nsAReadableString& aName,
nsXULDocument::CreateAttribute(const nsAString& aName,
nsIDOMAttr** aReturn)
{
NS_NOTREACHED("nsXULDocument::CreateAttribute");
@ -2816,7 +2816,7 @@ nsXULDocument::CreateAttribute(const nsAReadableString& aName,
NS_IMETHODIMP
nsXULDocument::CreateEntityReference(const nsAReadableString& aName,
nsXULDocument::CreateEntityReference(const nsAString& aName,
nsIDOMEntityReference** aReturn)
{
NS_NOTREACHED("nsXULDocument::CreateEntityReference");
@ -2825,7 +2825,7 @@ nsXULDocument::CreateEntityReference(const nsAReadableString& aName,
NS_IMETHODIMP
nsXULDocument::GetElementsByTagName(const nsAReadableString& aTagName,
nsXULDocument::GetElementsByTagName(const nsAString& aTagName,
nsIDOMNodeList** aReturn)
{
nsresult rv;
@ -2851,8 +2851,8 @@ nsXULDocument::GetElementsByTagName(const nsAReadableString& aTagName,
}
NS_IMETHODIMP
nsXULDocument::GetElementsByAttribute(const nsAReadableString& aAttribute,
const nsAReadableString& aValue,
nsXULDocument::GetElementsByAttribute(const nsAString& aAttribute,
const nsAString& aValue,
nsIDOMNodeList** aReturn)
{
nsresult rv;
@ -2881,8 +2881,8 @@ nsXULDocument::GetElementsByAttribute(const nsAReadableString& aAttribute,
NS_IMETHODIMP
nsXULDocument::Persist(const nsAReadableString& aID,
const nsAReadableString& aAttr)
nsXULDocument::Persist(const nsAString& aID,
const nsAString& aAttr)
{
// If we're currently reading persisted attributes out of the
// localstore, _don't_ re-enter and try to set them again!
@ -3031,7 +3031,7 @@ nsXULDocument::DestroyForwardReferences()
//
NS_IMETHODIMP
nsXULDocument::GetCharacterSet(nsAWritableString& aCharacterSet)
nsXULDocument::GetCharacterSet(nsAString& aCharacterSet)
{
return GetDocumentCharacterSet(aCharacterSet);
}
@ -3214,7 +3214,7 @@ nsXULDocument::GetHeight(PRInt32* aHeight)
NS_IMETHODIMP
nsXULDocument::AddBinding(nsIDOMElement* aContent,
const nsAReadableString& aURL)
const nsAString& aURL)
{
nsCOMPtr<nsIBindingManager> bm;
GetBindingManager(getter_AddRefs(bm));
@ -3225,7 +3225,7 @@ nsXULDocument::AddBinding(nsIDOMElement* aContent,
NS_IMETHODIMP
nsXULDocument::RemoveBinding(nsIDOMElement* aContent,
const nsAReadableString& aURL)
const nsAString& aURL)
{
if (mBindingManager) {
nsCOMPtr<nsIContent> content(do_QueryInterface(aContent));
@ -3236,7 +3236,7 @@ nsXULDocument::RemoveBinding(nsIDOMElement* aContent,
}
NS_IMETHODIMP
nsXULDocument::LoadBindingDocument(const nsAReadableString& aURL, nsIDOMDocument** aResult)
nsXULDocument::LoadBindingDocument(const nsAString& aURL, nsIDOMDocument** aResult)
{
if (mBindingManager) {
nsCOMPtr<nsIDocument> doc;
@ -3269,7 +3269,7 @@ nsXULDocument::GetBindingParent(nsIDOMNode* aNode, nsIDOMElement** aResult)
static nsresult
GetElementByAttribute(nsIContent* aContent,
nsIAtom* aAttrName,
const nsAReadableString& aAttrValue,
const nsAString& aAttrValue,
PRBool aUniversalMatch,
nsIDOMElement** aResult)
{
@ -3300,8 +3300,8 @@ GetElementByAttribute(nsIContent* aContent,
NS_IMETHODIMP
nsXULDocument::GetAnonymousElementByAttribute(nsIDOMElement* aElement,
const nsAReadableString& aAttrName,
const nsAReadableString& aAttrValue,
const nsAString& aAttrName,
const nsAString& aAttrValue,
nsIDOMElement** aResult)
{
*aResult = nsnull;
@ -3358,7 +3358,7 @@ nsXULDocument::GetLocation(nsIDOMLocation** aLocation)
}
NS_IMETHODIMP
nsXULDocument::GetTitle(nsAWritableString& aTitle)
nsXULDocument::GetTitle(nsAString& aTitle)
{
aTitle.Assign(mDocumentTitle);
@ -3366,7 +3366,7 @@ nsXULDocument::GetTitle(nsAWritableString& aTitle)
}
NS_IMETHODIMP
nsXULDocument::SetTitle(const nsAReadableString& aTitle)
nsXULDocument::SetTitle(const nsAString& aTitle)
{
for (PRInt32 i = mPresShells.Count() - 1; i >= 0; --i) {
nsIPresShell* shell = NS_STATIC_CAST(nsIPresShell*, mPresShells[i]);
@ -3405,14 +3405,14 @@ nsXULDocument::SetTitle(const nsAReadableString& aTitle)
}
NS_IMETHODIMP
nsXULDocument::GetDir(nsAWritableString& aDirection)
nsXULDocument::GetDir(nsAString& aDirection)
{
aDirection.Assign(NS_LITERAL_STRING("ltr"));
return NS_OK;
}
NS_IMETHODIMP
nsXULDocument::SetDir(const nsAReadableString& aDirection)
nsXULDocument::SetDir(const nsAString& aDirection)
{
return NS_OK;
}
@ -3488,8 +3488,8 @@ nsXULDocument::ImportNode(nsIDOMNode* aImportedNode,
}
NS_IMETHODIMP
nsXULDocument::CreateElementNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aQualifiedName,
nsXULDocument::CreateElementNS(const nsAString& aNamespaceURI,
const nsAString& aQualifiedName,
nsIDOMElement** aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
@ -3547,8 +3547,8 @@ nsXULDocument::CreateElementNS(const nsAReadableString& aNamespaceURI,
}
NS_IMETHODIMP
nsXULDocument::CreateAttributeNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aQualifiedName,
nsXULDocument::CreateAttributeNS(const nsAString& aNamespaceURI,
const nsAString& aQualifiedName,
nsIDOMAttr** aReturn)
{
NS_NOTYETIMPLEMENTED("write me");
@ -3556,7 +3556,7 @@ nsXULDocument::CreateAttributeNS(const nsAReadableString& aNamespaceURI,
}
NS_IMETHODIMP
nsXULDocument::GetElementById(const nsAReadableString& aId,
nsXULDocument::GetElementById(const nsAString& aId,
nsIDOMElement** aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
@ -3583,8 +3583,8 @@ nsXULDocument::GetElementById(const nsAReadableString& aId,
}
NS_IMETHODIMP
nsXULDocument::GetElementsByTagNameNS(const nsAReadableString& aNamespaceURI,
const nsAReadableString& aLocalName,
nsXULDocument::GetElementsByTagNameNS(const nsAString& aNamespaceURI,
const nsAString& aLocalName,
nsIDOMNodeList** aReturn)
{
nsresult rv;
@ -3854,7 +3854,7 @@ nsXULDocument::RemoveElementsFromMapByContent(const PRUnichar* aID,
//
NS_IMETHODIMP
nsXULDocument::GetNodeName(nsAWritableString& aNodeName)
nsXULDocument::GetNodeName(nsAString& aNodeName)
{
aNodeName.Assign(NS_LITERAL_STRING("#document"));
return NS_OK;
@ -3862,7 +3862,7 @@ nsXULDocument::GetNodeName(nsAWritableString& aNodeName)
NS_IMETHODIMP
nsXULDocument::GetNodeValue(nsAWritableString& aNodeValue)
nsXULDocument::GetNodeValue(nsAString& aNodeValue)
{
SetDOMStringToNull(aNodeValue);
@ -3871,7 +3871,7 @@ nsXULDocument::GetNodeValue(nsAWritableString& aNodeValue)
NS_IMETHODIMP
nsXULDocument::SetNodeValue(const nsAReadableString& aNodeValue)
nsXULDocument::SetNodeValue(const nsAString& aNodeValue)
{
return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
}
@ -4044,7 +4044,7 @@ nsXULDocument::GetOwnerDocument(nsIDOMDocument** aOwnerDocument)
NS_IMETHODIMP
nsXULDocument::GetNamespaceURI(nsAWritableString& aNamespaceURI)
nsXULDocument::GetNamespaceURI(nsAString& aNamespaceURI)
{
SetDOMStringToNull(aNamespaceURI);
@ -4053,7 +4053,7 @@ nsXULDocument::GetNamespaceURI(nsAWritableString& aNamespaceURI)
NS_IMETHODIMP
nsXULDocument::GetPrefix(nsAWritableString& aPrefix)
nsXULDocument::GetPrefix(nsAString& aPrefix)
{
SetDOMStringToNull(aPrefix);
@ -4062,14 +4062,14 @@ nsXULDocument::GetPrefix(nsAWritableString& aPrefix)
NS_IMETHODIMP
nsXULDocument::SetPrefix(const nsAReadableString& aPrefix)
nsXULDocument::SetPrefix(const nsAString& aPrefix)
{
return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
}
NS_IMETHODIMP
nsXULDocument::GetLocalName(nsAWritableString& aLocalName)
nsXULDocument::GetLocalName(nsAString& aLocalName)
{
SetDOMStringToNull(aLocalName);
@ -4129,8 +4129,8 @@ nsXULDocument::Normalize()
NS_IMETHODIMP
nsXULDocument::IsSupported(const nsAReadableString& aFeature,
const nsAReadableString& aVersion,
nsXULDocument::IsSupported(const nsAString& aFeature,
const nsAString& aVersion,
PRBool* aReturn)
{
NS_NOTYETIMPLEMENTED("write me");
@ -4138,7 +4138,7 @@ nsXULDocument::IsSupported(const nsAReadableString& aFeature,
}
NS_IMETHODIMP
nsXULDocument::GetBaseURI(nsAWritableString &aURI)
nsXULDocument::GetBaseURI(nsAString &aURI)
{
aURI.Truncate();
if (mDocumentBaseURL) {
@ -4151,16 +4151,16 @@ nsXULDocument::GetBaseURI(nsAWritableString &aURI)
NS_IMETHODIMP
nsXULDocument::LookupNamespacePrefix(const nsAReadableString& aNamespaceURI,
nsAWritableString& aPrefix)
nsXULDocument::LookupNamespacePrefix(const nsAString& aNamespaceURI,
nsAString& aPrefix)
{
NS_NOTYETIMPLEMENTED("write me");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsXULDocument::LookupNamespaceURI(const nsAReadableString& aNamespacePrefix,
nsAWritableString& aNamespaceURI)
nsXULDocument::LookupNamespaceURI(const nsAString& aNamespacePrefix,
nsAString& aNamespaceURI)
{
NS_NOTYETIMPLEMENTED("write me");
return NS_ERROR_NOT_IMPLEMENTED;
@ -4408,7 +4408,7 @@ nsXULDocument::StartLayout(void)
nsresult
nsXULDocument::GetElementsByTagName(nsIContent *aContent,
const nsAReadableString& aName,
const nsAString& aName,
PRInt32 aNamespaceID,
nsRDFDOMNodeList* aElements)
{
@ -4470,8 +4470,8 @@ nsXULDocument::GetElementsByTagName(nsIContent *aContent,
nsresult
nsXULDocument::GetElementsByAttribute(nsIDOMNode* aNode,
const nsAReadableString& aAttribute,
const nsAReadableString& aValue,
const nsAString& aAttribute,
const nsAString& aValue,
nsRDFDOMNodeList* aElements)
{
nsresult rv;
@ -4529,7 +4529,7 @@ nsXULDocument::GetElementsByAttribute(nsIDOMNode* aNode,
nsresult
nsXULDocument::ParseTagString(const nsAReadableString& aTagName, nsIAtom*& aName,
nsXULDocument::ParseTagString(const nsAString& aTagName, nsIAtom*& aName,
nsIAtom*& aPrefix)
{
// Parse the tag into a name and prefix
@ -4579,7 +4579,7 @@ nsXULDocument::RemoveEventListenerByIID(nsIDOMEventListener *aListener, const ns
}
NS_IMETHODIMP
nsXULDocument::AddEventListener(const nsAReadableString& aType,
nsXULDocument::AddEventListener(const nsAString& aType,
nsIDOMEventListener* aListener,
PRBool aUseCapture)
{
@ -4596,7 +4596,7 @@ nsXULDocument::AddEventListener(const nsAReadableString& aType,
}
NS_IMETHODIMP
nsXULDocument::RemoveEventListener(const nsAReadableString& aType,
nsXULDocument::RemoveEventListener(const nsAString& aType,
nsIDOMEventListener* aListener,
PRBool aUseCapture)
{
@ -4636,7 +4636,7 @@ nsXULDocument::DispatchEvent(nsIDOMEvent* aEvent, PRBool *_retval)
}
NS_IMETHODIMP
nsXULDocument::CreateEvent(const nsAReadableString& aEventType,
nsXULDocument::CreateEvent(const nsAString& aEventType,
nsIDOMEvent** aReturn)
{
// Obtain a presentation context
@ -4690,7 +4690,7 @@ nsXULDocument::HandleEvent(nsIDOMEvent *aEvent)
}
nsresult
nsXULDocument::CaptureEvent(const nsAReadableString& aType)
nsXULDocument::CaptureEvent(const nsAString& aType)
{
nsIEventListenerManager *mManager;
@ -4703,7 +4703,7 @@ nsXULDocument::CaptureEvent(const nsAReadableString& aType)
}
nsresult
nsXULDocument::ReleaseEvent(const nsAReadableString& aType)
nsXULDocument::ReleaseEvent(const nsAString& aType)
{
if (mListenerManager) {
//mListenerManager->ReleaseEvent(aListener);

38
content/xul/document/src/nsXULDocument.h
View File

@ -169,21 +169,21 @@ public:
NS_IMETHOD SetBaseURL(nsIURI *aURI);
NS_IMETHOD GetBaseTarget(nsAWritableString &aBaseTarget);
NS_IMETHOD GetBaseTarget(nsAString &aBaseTarget);
NS_IMETHOD SetBaseTarget(const nsAReadableString &aBaseTarget);
NS_IMETHOD SetBaseTarget(const nsAString &aBaseTarget);
NS_IMETHOD GetStyleSheets(nsIDOMStyleSheetList** aStyleSheets);
NS_IMETHOD GetDocumentCharacterSet(nsAWritableString& oCharSetID);
NS_IMETHOD GetDocumentCharacterSet(nsAString& oCharSetID);
NS_IMETHOD SetDocumentCharacterSet(const nsAReadableString& aCharSetID);
NS_IMETHOD SetDocumentCharacterSet(const nsAString& aCharSetID);
NS_IMETHOD GetDocumentCharacterSetSource(PRInt32* aCharsetSource);
NS_IMETHOD SetDocumentCharacterSetSource(PRInt32 aCharsetSource);
NS_IMETHOD GetContentLanguage(nsAWritableString& aContentLanguage) const;
NS_IMETHOD GetContentLanguage(nsAString& aContentLanguage) const;
#ifdef IBMBIDI
/**
@ -203,9 +203,9 @@ public:
NS_IMETHOD SetWordBreaker(nsIWordBreaker* aWordBreaker) ;
NS_IMETHOD GetHeaderData(nsIAtom* aHeaderField,
nsAWritableString& aData) const;
nsAString& aData) const;
NS_IMETHOD SetHeaderData(nsIAtom* aheaderField,
const nsAReadableString& aData);
const nsAString& aData);
NS_IMETHOD CreateShell(nsIPresContext* aContext,
nsIViewManager* aViewManager,
@ -321,7 +321,7 @@ public:
NS_IMETHOD SelectAll();
NS_IMETHOD FindNext(const nsAReadableString &aSearchStr, PRBool aMatchCase, PRBool aSearchDown, PRBool &aIsFound);
NS_IMETHOD FindNext(const nsAString &aSearchStr, PRBool aMatchCase, PRBool aSearchDown, PRBool &aIsFound);
NS_IMETHOD FlushPendingNotifications(PRBool aFlushReflows = PR_TRUE, PRBool aUpdateViews = PR_FALSE);
@ -350,9 +350,9 @@ public:
NS_IMETHOD SetTitle(const PRUnichar *aTitle);
// nsIXULDocument interface
NS_IMETHOD AddElementForID(const nsAReadableString& aID, nsIContent* aElement);
NS_IMETHOD RemoveElementForID(const nsAReadableString& aID, nsIContent* aElement);
NS_IMETHOD GetElementsForID(const nsAReadableString& aID, nsISupportsArray* aElements);
NS_IMETHOD AddElementForID(const nsAString& aID, nsIContent* aElement);
NS_IMETHOD RemoveElementForID(const nsAString& aID, nsIContent* aElement);
NS_IMETHOD GetElementsForID(const nsAString& aID, nsISupportsArray* aElements);
NS_IMETHOD AddForwardReference(nsForwardReference* aRef);
NS_IMETHOD ResolveForwardReferences();
NS_IMETHOD SetMasterPrototype(nsIXULPrototypeDocument* aDocument);
@ -368,8 +368,8 @@ public:
NS_IMETHOD OnResumeContentSink();
// nsIDOMEventCapturer interface
NS_IMETHOD CaptureEvent(const nsAReadableString& aType);
NS_IMETHOD ReleaseEvent(const nsAReadableString& aType);
NS_IMETHOD CaptureEvent(const nsAString& aType);
NS_IMETHOD ReleaseEvent(const nsAString& aType);
// nsIDOMEventReceiver interface (yuck. inherited from nsIDOMEventCapturer)
NS_IMETHOD AddEventListenerByIID(nsIDOMEventListener *aListener, const nsIID& aIID);
@ -378,10 +378,10 @@ public:
NS_IMETHOD HandleEvent(nsIDOMEvent *aEvent);
// nsIDOMEventTarget interface
NS_IMETHOD AddEventListener(const nsAReadableString& aType,
NS_IMETHOD AddEventListener(const nsAString& aType,
nsIDOMEventListener* aListener,
PRBool aUseCapture);
NS_IMETHOD RemoveEventListener(const nsAReadableString& aType,
NS_IMETHOD RemoveEventListener(const nsAString& aType,
nsIDOMEventListener* aListener,
PRBool aUseCapture);
NS_IMETHOD DispatchEvent(nsIDOMEvent* aEvent, PRBool *_retval);
@ -422,7 +422,7 @@ public:
static nsresult
GetElementsByTagName(nsIContent* aContent,
const nsAReadableString& aTagName,
const nsAString& aTagName,
PRInt32 aNamespaceID,
nsRDFDOMNodeList* aElements);
@ -460,12 +460,12 @@ protected:
static nsresult
GetElementsByAttribute(nsIDOMNode* aNode,
const nsAReadableString& aAttribute,
const nsAReadableString& aValue,
const nsAString& aAttribute,
const nsAString& aValue,
nsRDFDOMNodeList* aElements);
nsresult
ParseTagString(const nsAReadableString& aTagName, nsIAtom*& aName,
ParseTagString(const nsAString& aTagName, nsIAtom*& aName,
nsIAtom*& aPrefix);
void SetIsPopup(PRBool isPopup) { mIsPopup = isPopup; };

8
content/xul/document/src/nsXULPrototypeDocument.cpp
View File

@ -140,8 +140,8 @@ public:
NS_IMETHOD AddOverlayReference(nsIURI* aURI);
NS_IMETHOD GetOverlayReferences(nsISupportsArray** aResult);
NS_IMETHOD GetHeaderData(nsIAtom* aField, nsAWritableString& aData) const;
NS_IMETHOD SetHeaderData(nsIAtom* aField, const nsAReadableString& aData);
NS_IMETHOD GetHeaderData(nsIAtom* aField, nsAString& aData) const;
NS_IMETHOD SetHeaderData(nsIAtom* aField, const nsAString& aData);
NS_IMETHOD GetDocumentPrincipal(nsIPrincipal** aResult);
NS_IMETHOD SetDocumentPrincipal(nsIPrincipal* aPrincipal);
@ -420,7 +420,7 @@ nsXULPrototypeDocument::GetOverlayReferences(nsISupportsArray** aResult)
NS_IMETHODIMP
nsXULPrototypeDocument::GetHeaderData(nsIAtom* aField, nsAWritableString& aData) const
nsXULPrototypeDocument::GetHeaderData(nsIAtom* aField, nsAString& aData) const
{
// XXX Not implemented
aData.Truncate();
@ -429,7 +429,7 @@ nsXULPrototypeDocument::GetHeaderData(nsIAtom* aField, nsAWritableString& aData)
NS_IMETHODIMP
nsXULPrototypeDocument::SetHeaderData(nsIAtom* aField, const nsAReadableString& aData)
nsXULPrototypeDocument::SetHeaderData(nsIAtom* aField, const nsAString& aData)
{
// XXX Not implemented
return NS_OK;

10
content/xul/templates/src/nsXULContentBuilder.cpp
View File

@ -262,7 +262,7 @@ protected:
virtual PRBool
CompileSimpleAttributeCondition(PRInt32 aNameSpaceID,
nsIAtom* aAttribute,
const nsAReadableString& aValue,
const nsAString& aValue,
InnerNode* aParentNode,
TestNode** aResult);
/**
@ -655,7 +655,7 @@ nsXULContentBuilder::BuildContentFromTemplate(nsIContent *aTemplateNode,
// XXX because gcc-2.7.2.3 is too dumb to keep a
// compiler-generated temporary around.
NS_ConvertUTF8toUCS2 x(uri);
const nsAReadableString& id = x;
const nsAString& id = x;
rv = realKid->SetAttr(kNameSpaceID_None, nsXULAtoms::id, id, PR_FALSE);
NS_ASSERTION(NS_SUCCEEDED(rv), "unable to set id attribute");
if (NS_FAILED(rv)) return rv;
@ -1636,7 +1636,7 @@ nsXULContentBuilder::SetContainerAttrs(nsIContent *aElement, const nsTemplateMat
NS_NAMED_LITERAL_STRING(true_, "true");
NS_NAMED_LITERAL_STRING(false_, "false");
const nsAReadableString& newcontainer =
const nsAString& newcontainer =
iscontainer ? true_ : false_;
if (oldcontainer != newcontainer) {
@ -1648,7 +1648,7 @@ nsXULContentBuilder::SetContainerAttrs(nsIContent *aElement, const nsTemplateMat
nsAutoString oldempty;
aElement->GetAttr(kNameSpaceID_None, nsXULAtoms::empty, oldempty);
const nsAReadableString& newempty =
const nsAString& newempty =
(iscontainer && isempty) ? true_ : false_;
if (oldempty != newempty) {
@ -2232,7 +2232,7 @@ nsXULContentBuilder::CompileContentCondition(nsTemplateRule* aRule,
PRBool
nsXULContentBuilder::CompileSimpleAttributeCondition(PRInt32 aNameSpaceID,
nsIAtom* aAttribute,
const nsAReadableString& aValue,
const nsAString& aValue,
InnerNode* aParentNode,
TestNode** aResult)
{

10
content/xul/templates/src/nsXULContentUtils.cpp
View File

@ -284,7 +284,7 @@ nsXULContentUtils::GetElementRefResource(nsIContent* aElement, nsIRDFResource**
*/
nsresult
nsXULContentUtils::GetTextForNode(nsIRDFNode* aNode, nsAWritableString& aResult)
nsXULContentUtils::GetTextForNode(nsIRDFNode* aNode, nsAString& aResult)
{
if (! aNode) {
aResult.Truncate();
@ -351,7 +351,7 @@ nsXULContentUtils::GetTextForNode(nsIRDFNode* aNode, nsAWritableString& aResult)
}
nsresult
nsXULContentUtils::MakeElementURI(nsIDocument* aDocument, const nsAReadableString& aElementID, nsCString& aURI)
nsXULContentUtils::MakeElementURI(nsIDocument* aDocument, const nsAString& aElementID, nsCString& aURI)
{
// Convert an element's ID to a URI that can be used to refer to
// the element in the XUL graph.
@ -397,7 +397,7 @@ nsXULContentUtils::MakeElementURI(nsIDocument* aDocument, const nsAReadableStrin
nsresult
nsXULContentUtils::MakeElementResource(nsIDocument* aDocument, const nsAReadableString& aID, nsIRDFResource** aResult)
nsXULContentUtils::MakeElementResource(nsIDocument* aDocument, const nsAString& aID, nsIRDFResource** aResult)
{
nsresult rv;
@ -416,7 +416,7 @@ nsXULContentUtils::MakeElementResource(nsIDocument* aDocument, const nsAReadable
nsresult
nsXULContentUtils::MakeElementID(nsIDocument* aDocument, const nsAReadableString& aURI, nsAWritableString& aElementID)
nsXULContentUtils::MakeElementID(nsIDocument* aDocument, const nsAString& aURI, nsAString& aElementID)
{
// Convert a URI into an element ID that can be accessed from the
// DOM APIs.
@ -466,7 +466,7 @@ nsXULContentUtils::GetResource(PRInt32 aNameSpaceID, nsIAtom* aAttribute, nsIRDF
nsresult
nsXULContentUtils::GetResource(PRInt32 aNameSpaceID, const nsAReadableString& aAttribute, nsIRDFResource** aResult)
nsXULContentUtils::GetResource(PRInt32 aNameSpaceID, const nsAString& aAttribute, nsIRDFResource** aResult)
{
// construct a fully-qualified URI from the namespace/tag pair.

10
content/xul/templates/src/nsXULContentUtils.h
View File

@ -99,22 +99,22 @@ public:
GetElementRefResource(nsIContent* aElement, nsIRDFResource** aResult);
static nsresult
GetTextForNode(nsIRDFNode* aNode, nsAWritableString& aResult);
GetTextForNode(nsIRDFNode* aNode, nsAString& aResult);
static nsresult
MakeElementURI(nsIDocument* aDocument, const nsAReadableString& aElementID, nsCString& aURI);
MakeElementURI(nsIDocument* aDocument, const nsAString& aElementID, nsCString& aURI);
static nsresult
MakeElementResource(nsIDocument* aDocument, const nsAReadableString& aElementID, nsIRDFResource** aResult);
MakeElementResource(nsIDocument* aDocument, const nsAString& aElementID, nsIRDFResource** aResult);
static nsresult
MakeElementID(nsIDocument* aDocument, const nsAReadableString& aURI, nsAWritableString& aElementID);
MakeElementID(nsIDocument* aDocument, const nsAString& aURI, nsAString& aElementID);
static nsresult
GetResource(PRInt32 aNameSpaceID, nsIAtom* aAttribute, nsIRDFResource** aResult);
static nsresult
GetResource(PRInt32 aNameSpaceID, const nsAReadableString& aAttribute, nsIRDFResource** aResult);
GetResource(PRInt32 aNameSpaceID, const nsAString& aAttribute, nsIRDFResource** aResult);
static nsresult
SetCommandUpdater(nsIDocument* aDocument, nsIContent* aElement);

4
content/xul/templates/src/nsXULOutlinerBuilder.cpp
View File

@ -155,7 +155,7 @@ protected:
* of atoms.
*/
nsresult
TokenizeProperties(const nsAReadableString& aString, nsISupportsArray* aProprerties);
TokenizeProperties(const nsAString& aString, nsISupportsArray* aProprerties);
/**
* Return the resource corresponding to a row in the outliner. The
@ -1416,7 +1416,7 @@ nsXULOutlinerBuilder::GetTemplateActionCellFor(PRInt32 aRow,
}
nsresult
nsXULOutlinerBuilder::TokenizeProperties(const nsAReadableString& aString,
nsXULOutlinerBuilder::TokenizeProperties(const nsAString& aString,
nsISupportsArray* aProperties)
{
NS_PRECONDITION(aProperties != nsnull, "null ptr");

22
content/xul/templates/src/nsXULTemplateBuilder.cpp
View File

@ -1005,9 +1005,9 @@ nsXULTemplateBuilder::InitHTMLTemplateRoot()
}
void
nsXULTemplateBuilder::ParseAttribute(const nsAReadableString& aAttributeValue,
void (*aVariableCallback)(nsXULTemplateBuilder*, const nsAReadableString&, void*),
void (*aTextCallback)(nsXULTemplateBuilder*, const nsAReadableString&, void*),
nsXULTemplateBuilder::ParseAttribute(const nsAString& aAttributeValue,
void (*aVariableCallback)(nsXULTemplateBuilder*, const nsAString&, void*),
void (*aTextCallback)(nsXULTemplateBuilder*, const nsAString&, void*),
void* aClosure)
{
nsAString::const_iterator done_parsing;
@ -1094,7 +1094,7 @@ struct SubstituteTextClosure {
nsresult
nsXULTemplateBuilder::SubstituteText(nsTemplateMatch& aMatch,
const nsAReadableString& aAttributeValue,
const nsAString& aAttributeValue,
nsAString& aResult)
{
// See if it's the special value "..."
@ -1128,7 +1128,7 @@ nsXULTemplateBuilder::SubstituteText(nsTemplateMatch& aMatch,
void
nsXULTemplateBuilder::SubstituteTextAppendText(nsXULTemplateBuilder* aThis,
const nsAReadableString& aText,
const nsAString& aText,
void* aClosure)
{
// Append aString to the closure's result
@ -1138,7 +1138,7 @@ nsXULTemplateBuilder::SubstituteTextAppendText(nsXULTemplateBuilder* aThis,
void
nsXULTemplateBuilder::SubstituteTextReplaceVariable(nsXULTemplateBuilder* aThis,
const nsAReadableString& aVariable,
const nsAString& aVariable,
void* aClosure)
{
// Substitute the value for the variable and append to the
@ -1208,7 +1208,7 @@ struct IsVarInSetClosure {
void
nsXULTemplateBuilder::IsVarInSet(nsXULTemplateBuilder* aThis,
const nsAReadableString& aVariable,
const nsAString& aVariable,
void* aClosure)
{
IsVarInSetClosure* c = NS_STATIC_CAST(IsVarInSetClosure*, aClosure);
@ -1229,7 +1229,7 @@ nsXULTemplateBuilder::IsVarInSet(nsXULTemplateBuilder* aThis,
PRBool
nsXULTemplateBuilder::IsAttrImpactedByVars(nsTemplateMatch& aMatch,
const nsAReadableString& aAttributeValue,
const nsAString& aAttributeValue,
const VariableSet& aModifiedVars)
{
// XXX at some point, it might be good to remember what attributes
@ -2307,7 +2307,7 @@ nsXULTemplateBuilder::CompileSimpleRule(nsIContent* aRuleElement,
PRBool
nsXULTemplateBuilder::CompileSimpleAttributeCondition(PRInt32 aNameSpaceID,
nsIAtom* aAttribute,
const nsAReadableString& aValue,
const nsAString& aValue,
InnerNode* aParentNode,
TestNode** aResult)
{
@ -2365,7 +2365,7 @@ nsXULTemplateBuilder::AddSimpleRuleBindings(nsTemplateRule* aRule, nsIContent* a
void
nsXULTemplateBuilder::AddBindingsFor(nsXULTemplateBuilder* aThis,
const nsAReadableString& aVariable,
const nsAString& aVariable,
void* aClosure)
{
// We should *only* be recieving "rdf:"-style variables. Make
@ -2380,7 +2380,7 @@ nsXULTemplateBuilder::AddBindingsFor(nsXULTemplateBuilder* aThis,
// Strip it down to the raw RDF property by clobbering the "rdf:"
// prefix
const nsAReadableString& propertyStr = Substring(aVariable, PRUint32(4), aVariable.Length() - 4);
const nsAString& propertyStr = Substring(aVariable, PRUint32(4), aVariable.Length() - 4);
nsCOMPtr<nsIRDFResource> property;
gRDFService->GetUnicodeResource(nsAutoString(propertyStr).get(), getter_AddRefs(property));

20
content/xul/templates/src/nsXULTemplateBuilder.h
View File

@ -281,7 +281,7 @@ public:
virtual PRBool
CompileSimpleAttributeCondition(PRInt32 aNameSpaceID,
nsIAtom* aAttribute,
const nsAReadableString& aValue,
const nsAString& aValue,
InnerNode* aParentNode,
TestNode** aResult);
/**
@ -292,16 +292,16 @@ public:
static void
AddBindingsFor(nsXULTemplateBuilder* aSelf,
const nsAReadableString& aVariable,
const nsAString& aVariable,
void* aClosure);
// XXX sigh, the string template foo doesn't mix with
// operator->*() on egcs-1.1.2, so we'll need to explicitly pass
// "this" and use good ol' fashioned static callbacks.
void
ParseAttribute(const nsAReadableString& aAttributeValue,
void (*aVariableCallback)(nsXULTemplateBuilder* aThis, const nsAReadableString&, void*),
void (*aTextCallback)(nsXULTemplateBuilder* aThis, const nsAReadableString&, void*),
ParseAttribute(const nsAString& aAttributeValue,
void (*aVariableCallback)(nsXULTemplateBuilder* aThis, const nsAString&, void*),
void (*aTextCallback)(nsXULTemplateBuilder* aThis, const nsAString&, void*),
void* aClosure);
nsresult
@ -312,22 +312,22 @@ public:
nsresult
SubstituteText(nsTemplateMatch& aMatch,
const nsAReadableString& aAttributeValue,
const nsAString& aAttributeValue,
nsAString& aResult);
static void
SubstituteTextAppendText(nsXULTemplateBuilder* aThis, const nsAReadableString& aText, void* aClosure);
SubstituteTextAppendText(nsXULTemplateBuilder* aThis, const nsAString& aText, void* aClosure);
static void
SubstituteTextReplaceVariable(nsXULTemplateBuilder* aThis, const nsAReadableString& aVariable, void* aClosure);
SubstituteTextReplaceVariable(nsXULTemplateBuilder* aThis, const nsAString& aVariable, void* aClosure);
PRBool
IsAttrImpactedByVars(nsTemplateMatch& aMatch,
const nsAReadableString& aAttributeValue,
const nsAString& aAttributeValue,
const VariableSet& aModifiedVars);
static void
IsVarInSet(nsXULTemplateBuilder* aThis, const nsAReadableString& aVariable, void* aClosure);
IsVarInSet(nsXULTemplateBuilder* aThis, const nsAString& aVariable, void* aClosure);
nsresult
SynchronizeAll(nsIRDFResource* aSource,

4
content/xul/templates/src/nsXULTreeBuilder.cpp
View File

@ -155,7 +155,7 @@ protected:
* of atoms.
*/
nsresult
TokenizeProperties(const nsAReadableString& aString, nsISupportsArray* aProprerties);
TokenizeProperties(const nsAString& aString, nsISupportsArray* aProprerties);
/**
* Return the resource corresponding to a row in the outliner. The
@ -1416,7 +1416,7 @@ nsXULOutlinerBuilder::GetTemplateActionCellFor(PRInt32 aRow,
}
nsresult
nsXULOutlinerBuilder::TokenizeProperties(const nsAReadableString& aString,
nsXULOutlinerBuilder::TokenizeProperties(const nsAString& aString,
nsISupportsArray* aProperties)
{
NS_PRECONDITION(aProperties != nsnull, "null ptr");