--- a/accessible/src/base/nsAccessNode.h
+++ b/accessible/src/base/nsAccessNode.h
@@ -97,17 +97,17 @@ class nsAccessNode: public nsIAccessNode
// Static methods for handling per-document cache
static void PutCacheEntry(nsAccessNodeHashtable& aCache,
void* aUniqueID, nsIAccessNode *aAccessNode);
static void GetCacheEntry(nsAccessNodeHashtable& aCache,
void* aUniqueID, nsIAccessNode **aAccessNode);
static void ClearCache(nsAccessNodeHashtable& aCache);
- static PLDHashOperator PR_CALLBACK ClearCacheEntry(const void* aKey, nsCOMPtr<nsIAccessNode>& aAccessNode, void* aUserArg);
+ static PLDHashOperator ClearCacheEntry(const void* aKey, nsCOMPtr<nsIAccessNode>& aAccessNode, void* aUserArg);
// Static cache methods for global document cache
static already_AddRefed<nsIAccessibleDocument> GetDocAccessibleFor(nsIDocument *aDocument);
static already_AddRefed<nsIAccessibleDocument> GetDocAccessibleFor(nsIWeakReference *aWeakShell);
static already_AddRefed<nsIAccessibleDocument> GetDocAccessibleFor(nsIDocShellTreeItem *aContainer, PRBool aCanCreate = PR_FALSE);
static already_AddRefed<nsIAccessibleDocument> GetDocAccessibleFor(nsIDOMNode *aNode);
static already_AddRefed<nsIDOMNode> GetDOMNodeForContainer(nsISupports *aContainer);
--- a/accessible/src/base/nsDocAccessible.cpp
+++ b/accessible/src/base/nsDocAccessible.cpp
@@ -133,17 +133,17 @@ nsDocAccessible::nsDocAccessible(nsIDOMN
//-----------------------------------------------------
nsDocAccessible::~nsDocAccessible()
{
}
////////////////////////////////////////////////////////////////////////////////
// nsDocAccessible. nsISupports
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
ElementTraverser(const void *aKey, nsIAccessNode *aAccessNode,
void *aUserArg)
{
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(aUserArg);
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mAccessNodeCache entry");
cb->NoteXPCOMChild(aAccessNode);
--- a/caps/include/nsScriptSecurityManager.h
+++ b/caps/include/nsScriptSecurityManager.h
@@ -175,29 +175,29 @@ union SecurityLevel
struct PropertyPolicy : public PLDHashEntryHdr
{
jsval key; // property name as jsval
SecurityLevel mGet;
SecurityLevel mSet;
};
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
InitPropertyPolicyEntry(PLDHashTable *table,
PLDHashEntryHdr *entry,
const void *key)
{
PropertyPolicy* pp = (PropertyPolicy*)entry;
pp->key = (jsval)key;
pp->mGet.level = SCRIPT_SECURITY_UNDEFINED_ACCESS;
pp->mSet.level = SCRIPT_SECURITY_UNDEFINED_ACCESS;
return PR_TRUE;
}
-PR_STATIC_CALLBACK(void)
+static void
ClearPropertyPolicyEntry(PLDHashTable *table, PLDHashEntryHdr *entry)
{
PropertyPolicy* pp = (PropertyPolicy*)entry;
pp->key = JSVAL_VOID;
}
// Class Policy
#define NO_POLICY_FOR_CLASS (ClassPolicy*)1
@@ -207,36 +207,36 @@ struct ClassPolicy : public PLDHashEntry
char* key;
PLDHashTable* mPolicy;
// Note: the DomainPolicy owns us, so if if dies we will too. Hence no
// need to refcount it here (and in fact, we'd probably leak if we tried).
DomainPolicy* mDomainWeAreWildcardFor;
};
-PR_STATIC_CALLBACK(void)
+static void
ClearClassPolicyEntry(PLDHashTable *table, PLDHashEntryHdr *entry)
{
ClassPolicy* cp = (ClassPolicy *)entry;
if (cp->key)
{
PL_strfree(cp->key);
cp->key = nsnull;
}
PL_DHashTableDestroy(cp->mPolicy);
}
// Note: actual impl is going to be after the DomainPolicy class definition,
// since we need to access members of DomainPolicy in the impl
-PR_STATIC_CALLBACK(void)
+static void
MoveClassPolicyEntry(PLDHashTable *table,
const PLDHashEntryHdr *from,
PLDHashEntryHdr *to);
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
InitClassPolicyEntry(PLDHashTable *table,
PLDHashEntryHdr *entry,
const void *key)
{
static PLDHashTableOps classPolicyOps =
{
PL_DHashAllocTable,
PL_DHashFreeTable,
@@ -339,17 +339,17 @@ private:
#ifdef DEBUG_CAPS_DomainPolicyLifeCycle
static PRUint32 sObjects;
static void _printPopulationInfo();
#endif
};
-PR_STATIC_CALLBACK(void)
+static void
MoveClassPolicyEntry(PLDHashTable *table,
const PLDHashEntryHdr *from,
PLDHashEntryHdr *to)
{
memcpy(to, from, table->entrySize);
// Now update the mDefaultPolicy pointer that points to us, if any.
ClassPolicy* cp = static_cast<ClassPolicy*>(to);
--- a/caps/src/nsPrincipal.cpp
+++ b/caps/src/nsPrincipal.cpp
@@ -839,17 +839,17 @@ nsPrincipal::EnsureCertData(const nsACSt
}
struct CapabilityList
{
nsCString* granted;
nsCString* denied;
};
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
AppendCapability(nsHashKey *aKey, void *aData, void *capListPtr)
{
CapabilityList* capList = (CapabilityList*)capListPtr;
PRInt16 value = (PRInt16)NS_PTR_TO_INT32(aData);
nsCStringKey* key = (nsCStringKey *)aKey;
if (value == nsIPrincipal::ENABLE_GRANTED) {
capList->granted->Append(key->GetString(), key->GetStringLength());
capList->granted->Append(' ');
@@ -966,17 +966,17 @@ nsPrincipal::GetPreferences(char** aPref
*aID = id;
*aSubjectName = subjectName;
*aGrantedList = granted;
*aDeniedList = denied;
return NS_OK;
}
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
ReadAnnotationEntry(nsIObjectInputStream* aStream, nsHashKey** aKey,
void** aData)
{
nsresult rv;
nsCStringKey* key = new nsCStringKey(aStream, &rv);
if (NS_FAILED(rv)) {
return rv;
}
@@ -988,17 +988,17 @@ ReadAnnotationEntry(nsIObjectInputStream
return rv;
}
*aKey = key;
*aData = (void*) value;
return NS_OK;
}
-PR_STATIC_CALLBACK(void)
+static void
FreeAnnotationEntry(nsIObjectInputStream* aStream, nsHashKey* aKey,
void* aData)
{
delete aKey;
}
NS_IMETHODIMP
nsPrincipal::Read(nsIObjectInputStream* aStream)
@@ -1080,17 +1080,17 @@ nsPrincipal::Read(nsIObjectInputStream*
rv = aStream->Read8(&mTrusted);
if (NS_FAILED(rv)) {
return rv;
}
return NS_OK;
}
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
WriteScalarValue(nsIObjectOutputStream* aStream, void* aData)
{
PRUint32 value = NS_PTR_TO_INT32(aData);
return aStream->Write32(value);
}
NS_IMETHODIMP
--- a/caps/src/nsScriptSecurityManager.cpp
+++ b/caps/src/nsScriptSecurityManager.cpp
@@ -394,17 +394,17 @@ nsScriptSecurityManager::GetCxSubjectPri
return principal;
}
////////////////////
// Policy Storage //
////////////////////
// Table of security levels
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
DeleteCapability(nsHashKey *aKey, void *aData, void* closure)
{
NS_Free(aData);
return PR_TRUE;
}
//-- Per-Domain Policy - applies to one or more protocols or hosts
struct DomainEntry
@@ -444,17 +444,17 @@ struct DomainEntry
nsCString mOrigin;
DomainPolicy* mDomainPolicy;
DomainEntry* mNext;
#if defined(DEBUG) || defined(DEBUG_CAPS_HACKER)
nsCString mPolicyName_DEBUG;
#endif
};
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
DeleteDomainEntry(nsHashKey *aKey, void *aData, void* closure)
{
DomainEntry *entry = (DomainEntry*) aData;
do
{
DomainEntry *next = entry->mNext;
delete entry;
entry = next;
@@ -3892,19 +3892,19 @@ nsScriptSecurityManager::InitPrefs()
return NS_OK;
}
///////////////////////////////////////////////////////////////////////////////
// The following code prints the contents of the policy DB to the console.
#ifdef DEBUG_CAPS_HACKER
//typedef PLDHashOperator
-//(* PR_CALLBACK PLDHashEnumerator)(PLDHashTable *table, PLDHashEntryHdr *hdr,
-// PRUint32 number, void *arg);
-PR_STATIC_CALLBACK(PLDHashOperator)
+//(* PLDHashEnumerator)(PLDHashTable *table, PLDHashEntryHdr *hdr,
+// PRUint32 number, void *arg);
+static PLDHashOperator
PrintPropertyPolicy(PLDHashTable *table, PLDHashEntryHdr *entry,
PRUint32 number, void *arg)
{
PropertyPolicy* pp = (PropertyPolicy*)entry;
nsCAutoString prop(" ");
JSContext* cx = (JSContext*)arg;
prop.AppendInt((PRUint32)pp->key);
prop += ' ';
@@ -3920,41 +3920,41 @@ PrintPropertyPolicy(PLDHashTable *table,
prop.AppendInt(pp->mSet.level);
else
prop += pp->mSet.capability;
printf("%s.\n", prop.get());
return PL_DHASH_NEXT;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
PrintClassPolicy(PLDHashTable *table, PLDHashEntryHdr *entry,
PRUint32 number, void *arg)
{
ClassPolicy* cp = (ClassPolicy*)entry;
printf(" %s\n", cp->key);
PL_DHashTableEnumerate(cp->mPolicy, PrintPropertyPolicy, arg);
return PL_DHASH_NEXT;
}
// typedef PRBool
-// (*PR_CALLBACK nsHashtableEnumFunc)(nsHashKey *aKey, void *aData, void* aClosure);
-PR_STATIC_CALLBACK(PRBool)
+// (* nsHashtableEnumFunc)(nsHashKey *aKey, void *aData, void* aClosure);
+static PRBool
PrintDomainPolicy(nsHashKey *aKey, void *aData, void* aClosure)
{
DomainEntry* de = (DomainEntry*)aData;
printf("----------------------------\n");
printf("Domain: %s Policy Name: %s.\n", de->mOrigin.get(),
de->mPolicyName_DEBUG.get());
PL_DHashTableEnumerate(de->mDomainPolicy, PrintClassPolicy, aClosure);
return PR_TRUE;
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
PrintCapability(nsHashKey *aKey, void *aData, void* aClosure)
{
char* cap = (char*)aData;
printf(" %s.\n", cap);
return PR_TRUE;
}
void
--- a/caps/src/nsSecurityManagerFactory.cpp
+++ b/caps/src/nsSecurityManagerFactory.cpp
@@ -125,17 +125,17 @@ getUTF8StringArgument(JSContext *cx, JSO
aRetval.Truncate();
return;
}
PRUnichar *data = (PRUnichar*)JS_GetStringChars(str);
CopyUTF16toUTF8(data, aRetval);
}
-PR_STATIC_CALLBACK(JSBool)
+static JSBool
netscape_security_isPrivilegeEnabled(JSContext *cx, JSObject *obj, uintN argc,
jsval *argv, jsval *rval)
{
JSBool result = JS_FALSE;
char *cap = getStringArgument(cx, obj, 0, argc, argv);
if (cap) {
nsresult rv;
nsCOMPtr<nsIScriptSecurityManager> securityManager =
@@ -148,17 +148,17 @@ netscape_security_isPrivilegeEnabled(JSC
result = JS_FALSE;
}
}
*rval = BOOLEAN_TO_JSVAL(result);
return JS_TRUE;
}
-PR_STATIC_CALLBACK(JSBool)
+static JSBool
netscape_security_enablePrivilege(JSContext *cx, JSObject *obj, uintN argc,
jsval *argv, jsval *rval)
{
char *cap = getStringArgument(cx, obj, 0, argc, argv);
if (!cap)
return JS_FALSE;
nsresult rv;
@@ -170,17 +170,17 @@ netscape_security_enablePrivilege(JSCont
// NS_ASSERTION(cx == GetCurrentContext(), "unexpected context");
rv = securityManager->EnableCapability(cap);
if (NS_FAILED(rv))
return JS_FALSE;
return JS_TRUE;
}
-PR_STATIC_CALLBACK(JSBool)
+static JSBool
netscape_security_disablePrivilege(JSContext *cx, JSObject *obj, uintN argc,
jsval *argv, jsval *rval)
{
char *cap = getStringArgument(cx, obj, 0, argc, argv);
if (!cap)
return JS_FALSE;
nsresult rv;
@@ -192,17 +192,17 @@ netscape_security_disablePrivilege(JSCon
// NS_ASSERTION(cx == GetCurrentContext(), "unexpected context");
rv = securityManager->DisableCapability(cap);
if (NS_FAILED(rv))
return JS_FALSE;
return JS_TRUE;
}
-PR_STATIC_CALLBACK(JSBool)
+static JSBool
netscape_security_revertPrivilege(JSContext *cx, JSObject *obj, uintN argc,
jsval *argv, jsval *rval)
{
char *cap = getStringArgument(cx, obj, 0, argc, argv);
if (!cap)
return JS_FALSE;
nsresult rv;
@@ -214,17 +214,17 @@ netscape_security_revertPrivilege(JSCont
// NS_ASSERTION(cx == GetCurrentContext(), "unexpected context");
rv = securityManager->RevertCapability(cap);
if (NS_FAILED(rv))
return JS_FALSE;
return JS_TRUE;
}
-PR_STATIC_CALLBACK(JSBool)
+static JSBool
netscape_security_setCanEnablePrivilege(JSContext *cx, JSObject *obj, uintN argc,
jsval *argv, jsval *rval)
{
if (argc < 2) return JS_FALSE;
nsCAutoString principalFingerprint;
getUTF8StringArgument(cx, obj, 0, argc, argv, principalFingerprint);
char *cap = getStringArgument(cx, obj, 1, argc, argv);
if (principalFingerprint.IsEmpty() || !cap)
@@ -240,17 +240,17 @@ netscape_security_setCanEnablePrivilege(
rv = securityManager->SetCanEnableCapability(principalFingerprint, cap,
nsIPrincipal::ENABLE_GRANTED);
if (NS_FAILED(rv))
return JS_FALSE;
return JS_TRUE;
}
-PR_STATIC_CALLBACK(JSBool)
+static JSBool
netscape_security_invalidate(JSContext *cx, JSObject *obj, uintN argc,
jsval *argv, jsval *rval)
{
nsCAutoString principalFingerprint;
getUTF8StringArgument(cx, obj, 0, argc, argv, principalFingerprint);
if (principalFingerprint.IsEmpty())
return JS_FALSE;
@@ -492,16 +492,16 @@ static const nsModuleComponentInfo capsC
nsnull,
nsnull,
nsnull,
nsIClassInfo::MAIN_THREAD_ONLY
}
};
-void PR_CALLBACK
+void
CapsModuleDtor(nsIModule* thisModules)
{
nsScriptSecurityManager::Shutdown();
}
NS_IMPL_NSGETMODULE_WITH_DTOR(nsSecurityManagerModule, capsComponentInfo,
CapsModuleDtor)
--- a/content/base/public/nsContentUtils.h
+++ b/content/base/public/nsContentUtils.h
@@ -1354,18 +1354,17 @@ private:
nsIDocument *aOldDocument,
nsIDocument *aNewDocument);
static nsresult EnsureStringBundle(PropertiesFile aFile);
static nsIDOMScriptObjectFactory *GetDOMScriptObjectFactory();
static nsresult HoldScriptObject(PRUint32 aLangID, void* aObject);
- PR_STATIC_CALLBACK(void) DropScriptObject(PRUint32 aLangID, void *aObject,
- void *aClosure);
+ static void DropScriptObject(PRUint32 aLangID, void *aObject, void *aClosure);
static PRBool CanCallerAccess(nsIPrincipal* aSubjectPrincipal,
nsIPrincipal* aPrincipal);
static nsIDOMScriptObjectFactory *sDOMScriptObjectFactory;
static nsIXPConnect *sXPConnect;
--- a/content/base/src/mozSanitizingSerializer.cpp
+++ b/content/base/src/mozSanitizingSerializer.cpp
@@ -102,17 +102,17 @@ mozSanitizingHTMLSerializer::~mozSanitiz
{
#ifdef DEBUG_BenB
printf("Output:\n%s\n", NS_LossyConvertUTF16toASCII(*mOutputString).get());
#endif
mAllowedTags.Enumerate(ReleaseProperties);
}
//<copy from="xpcom/ds/nsProperties.cpp">
-PRBool PR_CALLBACK
+PRBool
mozSanitizingHTMLSerializer::ReleaseProperties(nsHashKey* key, void* data,
void* closure)
{
nsIProperties* prop = (nsIProperties*)data;
NS_IF_RELEASE(prop);
return PR_TRUE;
}
//</copy>
--- a/content/base/src/mozSanitizingSerializer.h
+++ b/content/base/src/mozSanitizingSerializer.h
@@ -60,18 +60,17 @@
class mozSanitizingHTMLSerializer : public nsIContentSerializer,
public nsIHTMLContentSink,
public mozISanitizingHTMLSerializer
{
public:
mozSanitizingHTMLSerializer();
virtual ~mozSanitizingHTMLSerializer();
- static PRBool PR_CALLBACK ReleaseProperties(nsHashKey* key, void* data,
- void* closure);
+ static PRBool ReleaseProperties(nsHashKey* key, void* data, void* closure);
NS_DECL_ISUPPORTS
// nsIContentSerializer
NS_IMETHOD Init(PRUint32 flags, PRUint32 dummy, const char* aCharSet,
PRBool aIsCopying, PRBool aIsWholeDocument);
NS_IMETHOD AppendText(nsIDOMText* aText, PRInt32 aStartOffset,
--- a/content/base/src/nsContentList.cpp
+++ b/content/base/src/nsContentList.cpp
@@ -187,24 +187,24 @@ nsFormContentList::nsFormContentList(nsI
// Hashtable for storing nsContentLists
static PLDHashTable gContentListHashTable;
struct ContentListHashEntry : public PLDHashEntryHdr
{
nsContentList* mContentList;
};
-PR_STATIC_CALLBACK(PLDHashNumber)
+static PLDHashNumber
ContentListHashtableHashKey(PLDHashTable *table, const void *key)
{
const nsContentListKey* list = static_cast<const nsContentListKey *>(key);
return list->GetHash();
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
ContentListHashtableMatchEntry(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key)
{
const ContentListHashEntry *e =
static_cast<const ContentListHashEntry *>(entry);
const nsContentListKey* list1 = e->mContentList->GetKey();
const nsContentListKey* list2 = static_cast<const nsContentListKey *>(key);
--- a/content/base/src/nsContentUtils.cpp
+++ b/content/base/src/nsContentUtils.cpp
@@ -237,26 +237,26 @@ public:
private:
const void *mKey; // must be first, to look like PLDHashEntryStub
public:
nsCOMPtr<nsIEventListenerManager> mListenerManager;
};
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
EventListenerManagerHashInitEntry(PLDHashTable *table, PLDHashEntryHdr *entry,
const void *key)
{
// Initialize the entry with placement new
new (entry) EventListenerManagerMapEntry(key);
return PR_TRUE;
}
-PR_STATIC_CALLBACK(void)
+static void
EventListenerManagerHashClearEntry(PLDHashTable *table, PLDHashEntryHdr *entry)
{
EventListenerManagerMapEntry *lm =
static_cast<EventListenerManagerMapEntry *>(entry);
// Let the EventListenerManagerMapEntry clean itself up...
lm->~EventListenerManagerMapEntry();
}
@@ -2595,17 +2595,17 @@ void
nsContentUtils::UnregisterPrefCallback(const char *aPref,
PrefChangedFunc aCallback,
void * aClosure)
{
if (sPref)
sPref->UnregisterCallback(aPref, aCallback, aClosure);
}
-static int PR_CALLBACK
+static int
BoolVarChanged(const char *aPref, void *aClosure)
{
PRBool* cache = static_cast<PRBool*>(aClosure);
*cache = nsContentUtils::GetBoolPref(aPref, PR_FALSE);
return 0;
}
--- a/content/base/src/nsDocument.cpp
+++ b/content/base/src/nsDocument.cpp
@@ -266,17 +266,17 @@ nsUint32ToContentHashEntry::InitHashSet(
nsresult rv = newSet->Init();
NS_ENSURE_SUCCESS(rv, rv);
mValOrHash = newSet;
*aSet = newSet;
return NS_OK;
}
-static PLDHashOperator PR_CALLBACK
+static PLDHashOperator
nsUint32ToContentHashEntryVisitorCallback(nsISupportsHashKey* aEntry,
void* aClosure)
{
nsUint32ToContentHashEntry::Visitor* visitor =
static_cast<nsUint32ToContentHashEntry::Visitor*>(aClosure);
visitor->Visit(static_cast<nsIContent*>(aEntry->GetKey()));
return PL_DHASH_NEXT;
}
@@ -390,17 +390,17 @@ nsIdentifierMapEntry::RemoveContentChang
}
}
struct FireChangeArgs {
nsIContent* mFrom;
nsIContent* mTo;
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
FireChangeEnumerator(nsIdentifierMapEntry::ChangeCallbackEntry *aEntry, void *aArg)
{
FireChangeArgs* args = static_cast<FireChangeArgs*>(aArg);
return aEntry->mKey.mCallback(args->mFrom, args->mTo, aEntry->mKey.mData)
? PL_DHASH_NEXT : PL_DHASH_REMOVE;
}
void
@@ -1447,17 +1447,17 @@ nsDocument::nsDocument(const char* aCont
PR_LOG(gDocumentLeakPRLog, PR_LOG_DEBUG,
("DOCUMENT %p created", this));
#endif
// Start out mLastStyleSheetSet as null, per spec
SetDOMStringToNull(mLastStyleSheetSet);
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
ClearAllBoxObjects(const void* aKey, nsPIBoxObject* aBoxObject, void* aUserArg)
{
if (aBoxObject) {
aBoxObject->Clear();
}
return PL_DHASH_NEXT;
}
@@ -1611,33 +1611,33 @@ NS_INTERFACE_MAP_END
NS_IMPL_CYCLE_COLLECTING_ADDREF_AMBIGUOUS(nsDocument, nsIDocument)
NS_IMPL_CYCLE_COLLECTING_RELEASE_AMBIGUOUS_WITH_DESTROY(nsDocument,
nsIDocument,
nsNodeUtils::LastRelease(this))
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
SubDocTraverser(PLDHashTable *table, PLDHashEntryHdr *hdr, PRUint32 number,
void *arg)
{
SubDocMapEntry *entry = static_cast<SubDocMapEntry*>(hdr);
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(arg);
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mSubDocuments entry->mKey");
cb->NoteXPCOMChild(entry->mKey);
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mSubDocuments entry->mSubDocument");
cb->NoteXPCOMChild(entry->mSubDocument);
return PL_DHASH_NEXT;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
RadioGroupsTraverser(const nsAString& aKey, nsRadioGroupStruct* aData,
void* aClosure)
{
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(aClosure);
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb,
"mRadioGroups entry->mSelectedRadioButton");
@@ -1648,17 +1648,17 @@ RadioGroupsTraverser(const nsAString& aK
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb,
"mRadioGroups entry->mRadioButtons[i]");
cb->NoteXPCOMChild(aData->mRadioButtons[i]);
}
return PL_DHASH_NEXT;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
BoxObjectTraverser(const void* key, nsPIBoxObject* boxObject, void* userArg)
{
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(userArg);
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mBoxObjectTable entry");
cb->NoteXPCOMChild(boxObject);
@@ -1671,26 +1671,26 @@ public:
nsCycleCollectionTraversalCallback *mCb;
virtual void Visit(nsIContent* aContent)
{
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*mCb, "mLinkMap entry");
mCb->NoteXPCOMChild(aContent);
}
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
LinkMapTraverser(nsUint32ToContentHashEntry* aEntry, void* userArg)
{
LinkMapTraversalVisitor visitor;
visitor.mCb = static_cast<nsCycleCollectionTraversalCallback*>(userArg);
aEntry->VisitContent(&visitor);
return PL_DHASH_NEXT;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
IdentifierMapEntryTraverse(nsIdentifierMapEntry *aEntry, void *aArg)
{
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(aArg);
aEntry->Traverse(cb);
return PL_DHASH_NEXT;
}
@@ -2966,29 +2966,29 @@ nsDocument::DeleteShell(nsIPresShell* aS
nsIPresShell *
nsDocument::GetPrimaryShell() const
{
return mShellsAreHidden ? nsnull : mPresShells.SafeElementAt(0, nsnull);
}
-PR_STATIC_CALLBACK(void)
+static void
SubDocClearEntry(PLDHashTable *table, PLDHashEntryHdr *entry)
{
SubDocMapEntry *e = static_cast<SubDocMapEntry *>(entry);
NS_RELEASE(e->mKey);
if (e->mSubDocument) {
e->mSubDocument->SetParentDocument(nsnull);
NS_RELEASE(e->mSubDocument);
}
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
SubDocInitEntry(PLDHashTable *table, PLDHashEntryHdr *entry, const void *key)
{
SubDocMapEntry *e =
const_cast<SubDocMapEntry *>
(static_cast<const SubDocMapEntry *>(entry));
e->mKey = const_cast<nsIContent *>
(static_cast<const nsIContent *>(key));
@@ -3077,17 +3077,17 @@ nsDocument::GetSubDocumentFor(nsIContent
if (PL_DHASH_ENTRY_IS_BUSY(entry)) {
return entry->mSubDocument;
}
}
return nsnull;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
FindContentEnumerator(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg)
{
SubDocMapEntry *entry = static_cast<SubDocMapEntry*>(hdr);
FindContentData *data = static_cast<FindContentData*>(arg);
if (entry->mSubDocument == data->mSubDocument) {
data->mResult = entry->mKey;
@@ -5702,17 +5702,17 @@ nsDocument::SetDocumentURI(const nsAStri
{
// Not allowing this yet, need to think about security ramifications first.
// We use mDocumentURI to get principals for this document.
return NS_ERROR_NOT_IMPLEMENTED;
}
static void BlastSubtreeToPieces(nsINode *aNode);
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
BlastFunc(nsAttrHashKey::KeyType aKey, nsIDOMNode *aData, void* aUserArg)
{
nsCOMPtr<nsIAttribute> *attr =
static_cast<nsCOMPtr<nsIAttribute>*>(aUserArg);
*attr = do_QueryInterface(aData);
NS_ASSERTION(attr->get(),
@@ -6751,17 +6751,17 @@ nsDocument::Sanitize()
}
struct SubDocEnumArgs
{
nsIDocument::nsSubDocEnumFunc callback;
void *data;
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
SubDocHashEnum(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg)
{
SubDocMapEntry *entry = static_cast<SubDocMapEntry*>(hdr);
SubDocEnumArgs *args = static_cast<SubDocEnumArgs*>(arg);
nsIDocument *subdoc = entry->mSubDocument;
PRBool next = subdoc ? args->callback(subdoc, args->data) : PR_TRUE;
@@ -6773,17 +6773,17 @@ void
nsDocument::EnumerateSubDocuments(nsSubDocEnumFunc aCallback, void *aData)
{
if (mSubDocuments) {
SubDocEnumArgs args = { aCallback, aData };
PL_DHashTableEnumerate(mSubDocuments, SubDocHashEnum, &args);
}
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
CanCacheSubDocument(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg)
{
SubDocMapEntry *entry = static_cast<SubDocMapEntry*>(hdr);
PRBool *canCacheArg = static_cast<PRBool*>(arg);
nsIDocument *subdoc = entry->mSubDocument;
--- a/content/base/src/nsDocument.h
+++ b/content/base/src/nsDocument.h
@@ -131,19 +131,19 @@ class nsUnblockOnloadEvent;
struct PLEvent;
class nsChildContentList;
PR_BEGIN_EXTERN_C
/* Note that these typedefs declare functions, not pointer to
functions. That's the only way in which they differ from
PLHandleEventProc and PLDestroyEventProc. */
typedef void*
-(PR_CALLBACK EventHandlerFunc)(PLEvent* self);
+(EventHandlerFunc)(PLEvent* self);
typedef void
-(PR_CALLBACK EventDestructorFunc)(PLEvent* self);
+(EventDestructorFunc)(PLEvent* self);
PR_END_EXTERN_C
/**
* Hashentry using a PRUint32 key and a cheap set of nsIContent* owning
* pointers for the value.
*
* @see nsTHashtable::EntryType for specification
*/
--- a/content/base/src/nsGenericElement.cpp
+++ b/content/base/src/nsGenericElement.cpp
@@ -5067,18 +5067,17 @@ ParseSelectorList(nsINode* aNode,
return NS_OK;
}
/*
* Callback to be called as we iterate over the tree and match elements. If
* the callbacks returns false, the iteration should be stopped.
*/
typedef PRBool
-(* PR_CALLBACK ElementMatchedCallback)(nsIContent* aMatchingElement,
- void* aClosure);
+(* ElementMatchedCallback)(nsIContent* aMatchingElement, void* aClosure);
// returning false means stop iteration
static PRBool
TryMatchingElementsInSubtree(nsINode* aRoot,
RuleProcessorData* aParentData,
nsPresContext* aPresContext,
nsCSSSelectorList* aSelectorList,
ElementMatchedCallback aCallback,
@@ -5164,17 +5163,17 @@ TryMatchingElementsInSubtree(nsINode* aR
#ifdef DEBUG
NS_ASSERTION(!debugMutationGuard.Mutated(0), "Unexpected mutations happened");
#endif
return continueIteration;
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
FindFirstMatchingElement(nsIContent* aMatchingElement,
void* aClosure)
{
NS_PRECONDITION(aMatchingElement && aClosure, "How did that happen?");
nsIContent** slot = static_cast<nsIContent**>(aClosure);
*slot = aMatchingElement;
return PR_FALSE;
}
@@ -5200,17 +5199,17 @@ nsGenericElement::doQuerySelector(nsINod
if (foundElement) {
return CallQueryInterface(foundElement, aReturn);
}
*aReturn = nsnull;
return NS_OK;
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
AppendAllMatchingElements(nsIContent* aMatchingElement,
void* aClosure)
{
NS_PRECONDITION(aMatchingElement && aClosure, "How did that happen?");
static_cast<nsBaseContentList*>(aClosure)->AppendElement(aMatchingElement);
return PR_TRUE;
}
--- a/content/base/src/nsNodeInfoManager.h
+++ b/content/base/src/nsNodeInfoManager.h
@@ -146,19 +146,18 @@ protected:
const nsAString& );
/**
* Sets the principal of the document this nodeinfo manager belongs to.
*/
void SetDocumentPrincipal(nsIPrincipal *aPrincipal);
private:
- static PRIntn PR_CALLBACK NodeInfoInnerKeyCompare(const void *key1,
- const void *key2);
- static PLHashNumber PR_CALLBACK GetNodeInfoInnerHashValue(const void *key);
+ static PRIntn NodeInfoInnerKeyCompare(const void *key1, const void *key2);
+ static PLHashNumber GetNodeInfoInnerHashValue(const void *key);
nsAutoRefCnt mRefCnt;
NS_DECL_OWNINGTHREAD
PLHashTable *mNodeInfoHash;
nsIDocument *mDocument; // WEAK
nsIPrincipal *mPrincipal; // STRONG, but not nsCOMPtr to avoid include hell
// while inlining DocumentPrincipal(). Never null
--- a/content/base/src/nsNodeUtils.cpp
+++ b/content/base/src/nsNodeUtils.cpp
@@ -453,17 +453,17 @@ public:
nsIDOMElement *mElement;
nsNodeInfoManager *mNewNodeInfoManager;
JSContext *mCx;
JSObject *mOldScope;
JSObject *mNewScope;
nsCOMArray<nsINode> &mNodesWithProperties;
};
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
AdoptFunc(nsAttrHashKey::KeyType aKey, nsIDOMNode *aData, void* aUserArg)
{
nsCOMPtr<nsIAttribute> attr = do_QueryInterface(aData);
NS_ASSERTION(attr, "non-nsIAttribute somehow made it into the hashmap?!");
AdoptFuncData *data = static_cast<AdoptFuncData*>(aUserArg);
// If we were passed an element we need to clone the attribute nodes and
--- a/content/base/src/nsNodeUtils.h
+++ b/content/base/src/nsNodeUtils.h
@@ -265,17 +265,17 @@ public:
/**
* Release the UserData and UserDataHandlers for aNode.
*
* @param aNode the node to release the UserData and UserDataHandlers for
*/
static void UnlinkUserData(nsINode *aNode);
private:
- friend PLDHashOperator PR_CALLBACK
+ friend PLDHashOperator
AdoptFunc(nsAttrHashKey::KeyType aKey, nsIDOMNode *aData, void* aUserArg);
/**
* Walks aNode, its attributes and, if aDeep is PR_TRUE, its descendant nodes.
* If aClone is PR_TRUE the nodes will be cloned. If aNewNodeInfoManager is
* not null, it is used to create new nodeinfos for the nodes. Also reparents
* the XPConnect wrappers for the nodes in aNewScope if aCx is not null.
* aNodesWithProperties will be filled with all the nodes that have
--- a/content/base/src/nsPropertyTable.cpp
+++ b/content/base/src/nsPropertyTable.cpp
@@ -319,17 +319,17 @@ nsPropertyTable::PropertyList::PropertyL
}
nsPropertyTable::PropertyList::~PropertyList()
{
PL_DHashTableFinish(&mObjectValueMap);
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
DestroyPropertyEnumerator(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg)
{
nsPropertyTable::PropertyList *propList =
static_cast<nsPropertyTable::PropertyList*>(table->data);
PropertyListMapEntry* entry = static_cast<PropertyListMapEntry*>(hdr);
propList->mDtorFunc(const_cast<void*>(entry->key), propList->mName,
--- a/content/base/src/nsXMLNameSpaceMap.cpp
+++ b/content/base/src/nsXMLNameSpaceMap.cpp
@@ -177,17 +177,17 @@ nsXMLNameSpaceMap::FindPrefix(PRInt32 aN
if (entry->nameSpaceID == aNameSpaceID) {
return entry->prefix;
}
}
return nsnull;
}
-PR_STATIC_CALLBACK(PRBool) DeleteEntry(void *aElement, void *aData)
+static PRBool DeleteEntry(void *aElement, void *aData)
{
delete static_cast<nsNameSpaceEntry*>(aElement);
return PR_TRUE;
}
void
nsXMLNameSpaceMap::Clear()
{
--- a/content/events/src/nsDOMDataContainerEvent.h
+++ b/content/events/src/nsDOMDataContainerEvent.h
@@ -52,16 +52,16 @@ public:
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(nsDOMDataContainerEvent, nsDOMEvent)
NS_FORWARD_TO_NSDOMEVENT
NS_DECL_NSIDOMDATACONTAINEREVENT
private:
- static PLDHashOperator PR_CALLBACK
+ static PLDHashOperator
TraverseEntry(const nsAString& aKey, nsIVariant *aDataItem, void* aUserArg);
nsInterfaceHashtable<nsStringHashKey, nsIVariant> mData;
};
#endif
--- a/content/events/src/nsXMLEventsManager.cpp
+++ b/content/events/src/nsXMLEventsManager.cpp
@@ -246,28 +246,28 @@ nsXMLEventsListener::HandleEvent(nsIDOME
return rv;
}
return NS_OK;
}
//XMLEventsManager / DocumentObserver
-PR_STATIC_CALLBACK(PLDHashOperator) EnumAndUnregisterListener(nsISupports * aContent,
- nsCOMPtr<nsXMLEventsListener> & aListener,
- void * aData)
+static PLDHashOperator EnumAndUnregisterListener(nsISupports * aContent,
+ nsCOMPtr<nsXMLEventsListener> & aListener,
+ void * aData)
{
if (aListener)
aListener->Unregister();
return PL_DHASH_NEXT;
}
-PR_STATIC_CALLBACK(PLDHashOperator) EnumAndSetIncomplete(nsISupports * aContent,
- nsCOMPtr<nsXMLEventsListener> & aListener,
- void * aData)
+static PLDHashOperator EnumAndSetIncomplete(nsISupports * aContent,
+ nsCOMPtr<nsXMLEventsListener> & aListener,
+ void * aData)
{
if (aListener && aData) {
nsCOMPtr<nsIContent> content = static_cast<nsIContent *>(aData);
if (content) {
if (aListener->ObserverEquals(content) || aListener->HandlerEquals(content)) {
aListener->SetIncomplete();
return PL_DHASH_REMOVE;
}
--- a/content/html/content/src/nsHTMLFormElement.cpp
+++ b/content/html/content/src/nsHTMLFormElement.cpp
@@ -522,17 +522,17 @@ nsHTMLFormElement::Init()
NS_ERROR_OUT_OF_MEMORY);
return NS_OK;
}
// nsISupports
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
ElementTraverser(const nsAString& key, nsIDOMHTMLInputElement* element,
void* userArg)
{
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(userArg);
cb->NoteXPCOMChild(element);
return PL_DHASH_NEXT;
@@ -2087,17 +2087,17 @@ nsFormControlList::FlushPendingNotificat
if (mForm) {
nsIDocument* doc = mForm->GetCurrentDoc();
if (doc) {
doc->FlushPendingNotifications(Flush_Content);
}
}
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
ControlTraverser(const nsAString& key, nsISupports* control, void* userArg)
{
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(userArg);
cb->NoteXPCOMChild(control);
return PL_DHASH_NEXT;
}
--- a/content/html/content/src/nsHTMLTableRowElement.cpp
+++ b/content/html/content/src/nsHTMLTableRowElement.cpp
@@ -224,17 +224,17 @@ nsHTMLTableRowElement::GetSectionRowInde
found = PR_TRUE;
}
}
}
return NS_OK;
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
IsCell(nsIContent *aContent, PRInt32 aNamespaceID,
nsIAtom* aAtom, void *aData)
{
nsIAtom* tag = aContent->Tag();
return ((tag == nsGkAtoms::td || tag == nsGkAtoms::th) &&
aContent->IsNodeOfType(nsINode::eHTML));
}
--- a/content/html/document/src/nsHTMLDocument.cpp
+++ b/content/html/document/src/nsHTMLDocument.cpp
@@ -172,17 +172,17 @@ static PRBool ConvertToMidasInternalComm
const nsAString & inParam,
nsACString& outCommandID,
nsACString& outParam,
PRBool& isBoolean,
PRBool& boolValue);
static PRBool ConvertToMidasInternalCommand(const nsAString & inCommandID,
nsACString& outCommandID);
-static int PR_CALLBACK
+static int
MyPrefChangedCallback(const char*aPrefName, void* instance_data)
{
const nsAdoptingString& detector_name =
nsContentUtils::GetLocalizedStringPref("intl.charset.detector");
if (detector_name.Length() > 0) {
PL_strncpy(g_detector_contractid, NS_CHARSET_DETECTOR_CONTRACTID_BASE,
DETECTOR_CONTRACTID_MAX);
--- a/content/xbl/src/nsBindingManager.cpp
+++ b/content/xbl/src/nsBindingManager.cpp
@@ -226,24 +226,24 @@ public:
void SetValue(nsISupports* aValue) { mValue = aValue; }
void SetKey(nsISupports* aKey) { mKey = aKey; }
private:
nsCOMPtr<nsISupports> mKey;
nsCOMPtr<nsISupports> mValue;
};
-PR_STATIC_CALLBACK(void)
+static void
ClearObjectEntry(PLDHashTable* table, PLDHashEntryHdr *entry)
{
ObjectEntry* objEntry = static_cast<ObjectEntry*>(entry);
objEntry->~ObjectEntry();
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
InitObjectEntry(PLDHashTable* table, PLDHashEntryHdr* entry, const void* key)
{
new (entry) ObjectEntry;
return PR_TRUE;
}
@@ -443,18 +443,18 @@ nsBindingManager::~nsBindingManager(void
"Insertion parent table isn't empty!");
if (mInsertionParentTable.ops)
PL_DHashTableFinish(&mInsertionParentTable);
if (mWrapperTable.ops)
PL_DHashTableFinish(&mWrapperTable);
}
PLDHashOperator
-PR_CALLBACK RemoveInsertionParentCB(PLDHashTable* aTable, PLDHashEntryHdr* aEntry,
- PRUint32 aNumber, void* aArg)
+RemoveInsertionParentCB(PLDHashTable* aTable, PLDHashEntryHdr* aEntry,
+ PRUint32 aNumber, void* aArg)
{
return (static_cast<ObjectEntry*>(aEntry)->GetValue() ==
static_cast<nsISupports*>(aArg)) ? PL_DHASH_REMOVE : PL_DHASH_NEXT;
}
static void
RemoveInsertionParentForNodeList(nsIDOMNodeList* aList, nsIContent* aParent)
{
@@ -1013,17 +1013,17 @@ nsBindingManager::ProcessAttachedQueue(P
// Keep bindings and bound elements alive while executing detached handlers.
struct BindingTableReadClosure
{
nsCOMArray<nsIContent> mBoundElements;
nsBindingList mBindings;
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
AccumulateBindingsToDetach(nsISupports *aKey, nsXBLBinding *aBinding,
void* aClosure)
{
BindingTableReadClosure* closure =
static_cast<BindingTableReadClosure*>(aClosure);
if (aBinding && closure->mBindings.AppendElement(aBinding)) {
if (!closure->mBoundElements.AppendObject(aBinding->GetBoundElement())) {
closure->mBindings.RemoveElementAt(closure->mBindings.Length() - 1);
@@ -1104,17 +1104,17 @@ nsBindingManager::GetLoadingDocListener(
void
nsBindingManager::RemoveLoadingDocListener(nsIURI* aURL)
{
if (mLoadingDocTable.IsInitialized()) {
mLoadingDocTable.Remove(aURL);
}
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
MarkForDeath(nsISupports *aKey, nsXBLBinding *aBinding, void* aClosure)
{
if (aBinding->MarkedForDeath())
return PL_DHASH_NEXT; // Already marked for death.
nsCAutoString path;
aBinding->PrototypeBinding()->DocURI()->GetPath(path);
@@ -1294,17 +1294,17 @@ nsBindingManager::WalkRules(nsIStyleRule
// Null out the scoped root that we set repeatedly
aData->mScopedRoot = nsnull;
return NS_OK;
}
typedef nsTHashtable<nsVoidPtrHashKey> RuleProcessorSet;
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
EnumRuleProcessors(nsISupports *aKey, nsXBLBinding *aBinding, void* aClosure)
{
RuleProcessorSet *set = static_cast<RuleProcessorSet*>(aClosure);
for (nsXBLBinding *binding = aBinding; binding;
binding = binding->GetBaseBinding()) {
nsIStyleRuleProcessor *ruleProc =
binding->PrototypeBinding()->GetRuleProcessor();
if (ruleProc) {
@@ -1316,17 +1316,17 @@ EnumRuleProcessors(nsISupports *aKey, ns
return PL_DHASH_NEXT;
}
struct MediumFeaturesChangedData {
nsPresContext *mPresContext;
PRBool *mRulesChanged;
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
EnumMediumFeaturesChanged(nsVoidPtrHashKey *aKey, void* aClosure)
{
nsIStyleRuleProcessor *ruleProcessor =
static_cast<nsIStyleRuleProcessor*>(const_cast<void*>(aKey->GetKey()));
MediumFeaturesChangedData *data =
static_cast<MediumFeaturesChangedData*>(aClosure);
PRBool thisChanged = PR_FALSE;
--- a/content/xbl/src/nsXBLBinding.cpp
+++ b/content/xbl/src/nsXBLBinding.cpp
@@ -282,17 +282,17 @@ nsXBLBinding::nsXBLBinding(nsXBLPrototyp
nsXBLBinding::~nsXBLBinding(void)
{
delete mInsertionPointTable;
nsIXBLDocumentInfo* info = mPrototypeBinding->XBLDocumentInfo();
NS_RELEASE(info);
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
TraverseKey(nsISupports* aKey, nsInsertionPointList* aData, void* aClosure)
{
nsCycleCollectionTraversalCallback &cb =
*static_cast<nsCycleCollectionTraversalCallback*>(aClosure);
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mInsertionPointTable key");
cb.NoteXPCOMChild(aKey);
if (aData) {
@@ -402,17 +402,17 @@ struct ContentListData : public EnumData
nsBindingManager* mBindingManager;
nsresult mRv;
ContentListData(nsXBLBinding* aBinding, nsBindingManager* aManager)
:EnumData(aBinding), mBindingManager(aManager), mRv(NS_OK)
{}
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
BuildContentLists(nsISupports* aKey,
nsAutoPtr<nsInsertionPointList>& aData,
void* aClosure)
{
ContentListData* data = (ContentListData*)aClosure;
nsBindingManager* bm = data->mBindingManager;
nsXBLBinding* binding = data->mBinding;
@@ -495,17 +495,17 @@ BuildContentLists(nsISupports* aKey,
// insertion points be nested into an inner binding.
if (parent == boundElement)
bm->SetAnonymousNodesFor(parent, contentList);
else
bm->SetContentListFor(parent, contentList);
return PL_DHASH_NEXT;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
RealizeDefaultContent(nsISupports* aKey,
nsAutoPtr<nsInsertionPointList>& aData,
void* aClosure)
{
ContentListData* data = (ContentListData*)aClosure;
nsBindingManager* bm = data->mBindingManager;
nsXBLBinding* binding = data->mBinding;
@@ -556,17 +556,17 @@ RealizeDefaultContent(nsISupports* aKey,
}
}
}
}
return PL_DHASH_NEXT;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
ChangeDocumentForDefaultContent(nsISupports* aKey,
nsAutoPtr<nsInsertionPointList>& aData,
void* aClosure)
{
PRInt32 count = aData->Length();
for (PRInt32 i = 0; i < count; i++) {
aData->ElementAt(i)->UnbindDefaultContent();
}
--- a/content/xbl/src/nsXBLDocumentInfo.cpp
+++ b/content/xbl/src/nsXBLDocumentInfo.cpp
@@ -122,62 +122,62 @@ nsXBLDocGlobalObject::doCheckAccess(JSCo
}
}
nsresult rv = ssm->CheckPropertyAccess(cx, obj, JS_GET_CLASS(cx, obj)->name,
id, accessType);
return NS_SUCCEEDED(rv);
}
-PR_STATIC_CALLBACK(JSBool)
+static JSBool
nsXBLDocGlobalObject_getProperty(JSContext *cx, JSObject *obj,
jsval id, jsval *vp)
{
return nsXBLDocGlobalObject::
doCheckAccess(cx, obj, id, nsIXPCSecurityManager::ACCESS_GET_PROPERTY);
}
-PR_STATIC_CALLBACK(JSBool)
+static JSBool
nsXBLDocGlobalObject_setProperty(JSContext *cx, JSObject *obj,
jsval id, jsval *vp)
{
return nsXBLDocGlobalObject::
doCheckAccess(cx, obj, id, nsIXPCSecurityManager::ACCESS_SET_PROPERTY);
}
-PR_STATIC_CALLBACK(JSBool)
+static JSBool
nsXBLDocGlobalObject_checkAccess(JSContext *cx, JSObject *obj, jsval id,
JSAccessMode mode, jsval *vp)
{
PRUint32 translated;
if (mode & JSACC_WRITE) {
translated = nsIXPCSecurityManager::ACCESS_SET_PROPERTY;
} else {
translated = nsIXPCSecurityManager::ACCESS_GET_PROPERTY;
}
return nsXBLDocGlobalObject::
doCheckAccess(cx, obj, id, translated);
}
-PR_STATIC_CALLBACK(void)
+static void
nsXBLDocGlobalObject_finalize(JSContext *cx, JSObject *obj)
{
nsISupports *nativeThis = (nsISupports*)JS_GetPrivate(cx, obj);
nsCOMPtr<nsIScriptGlobalObject> sgo(do_QueryInterface(nativeThis));
if (sgo)
sgo->OnFinalize(nsIProgrammingLanguage::JAVASCRIPT, obj);
// The addref was part of JSObject construction
NS_RELEASE(nativeThis);
}
-PR_STATIC_CALLBACK(JSBool)
+static JSBool
nsXBLDocGlobalObject_resolve(JSContext *cx, JSObject *obj, jsval id)
{
JSBool did_resolve = JS_FALSE;
return JS_ResolveStandardClass(cx, obj, id, &did_resolve);
}
JSClass nsXBLDocGlobalObject::gSharedGlobalClass = {
@@ -429,41 +429,41 @@ static PRBool IsChromeURI(nsIURI* aURI)
PRBool isChrome = PR_FALSE;
if (NS_SUCCEEDED(aURI->SchemeIs("chrome", &isChrome)))
return isChrome;
return PR_FALSE;
}
/* Implementation file */
-static PRIntn PR_CALLBACK
+static PRIntn
TraverseProtos(nsHashKey *aKey, void *aData, void* aClosure)
{
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(aClosure);
nsXBLPrototypeBinding *proto = static_cast<nsXBLPrototypeBinding*>(aData);
proto->Traverse(*cb);
return kHashEnumerateNext;
}
-static PRIntn PR_CALLBACK
+static PRIntn
UnlinkProtoJSObjects(nsHashKey *aKey, void *aData, void* aClosure)
{
nsXBLPrototypeBinding *proto = static_cast<nsXBLPrototypeBinding*>(aData);
proto->UnlinkJSObjects();
return kHashEnumerateNext;
}
struct ProtoTracer
{
TraceCallback mCallback;
void *mClosure;
};
-static PRIntn PR_CALLBACK
+static PRIntn
TraceProtos(nsHashKey *aKey, void *aData, void* aClosure)
{
ProtoTracer* closure = static_cast<ProtoTracer*>(aClosure);
nsXBLPrototypeBinding *proto = static_cast<nsXBLPrototypeBinding*>(aData);
proto->Trace(closure->mCallback, closure->mClosure);
return kHashEnumerateNext;
}
@@ -552,17 +552,17 @@ nsXBLDocumentInfo::GetPrototypeBinding(c
const nsPromiseFlatCString& flat = PromiseFlatCString(aRef);
nsCStringKey key(flat.get());
*aResult = static_cast<nsXBLPrototypeBinding*>(mBindingTable->Get(&key));
return NS_OK;
}
-static PRBool PR_CALLBACK
+static PRBool
DeletePrototypeBinding(nsHashKey* aKey, void* aData, void* aClosure)
{
nsXBLPrototypeBinding* binding = static_cast<nsXBLPrototypeBinding*>(aData);
delete binding;
return PR_TRUE;
}
NS_IMETHODIMP
@@ -587,17 +587,17 @@ nsXBLDocumentInfo::SetPrototypeBinding(c
NS_IMETHODIMP
nsXBLDocumentInfo::SetFirstPrototypeBinding(nsXBLPrototypeBinding* aBinding)
{
mFirstBinding = aBinding;
return NS_OK;
}
-PRBool PR_CALLBACK FlushScopedSkinSheets(nsHashKey* aKey, void* aData, void* aClosure)
+PRBool FlushScopedSkinSheets(nsHashKey* aKey, void* aData, void* aClosure)
{
nsXBLPrototypeBinding* proto = (nsXBLPrototypeBinding*)aData;
proto->FlushSkinSheets();
return PR_TRUE;
}
NS_IMETHODIMP
nsXBLDocumentInfo::FlushSkinStylesheets()
--- a/content/xbl/src/nsXBLPrototypeBinding.cpp
+++ b/content/xbl/src/nsXBLPrototypeBinding.cpp
@@ -327,30 +327,30 @@ nsXBLPrototypeBinding::Init(const nsACSt
bindingURL->SetRef(aID);
mXBLDocInfoWeak = aInfo;
SetBindingElement(aElement);
return NS_OK;
}
-PR_STATIC_CALLBACK(PRIntn)
+static PRIntn
TraverseInsertionPoint(nsHashKey* aKey, void* aData, void* aClosure)
{
nsCycleCollectionTraversalCallback &cb =
*static_cast<nsCycleCollectionTraversalCallback*>(aClosure);
nsXBLInsertionPointEntry* entry =
static_cast<nsXBLInsertionPointEntry*>(aData);
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NATIVE_PTR(entry,
nsXBLInsertionPointEntry,
"[insertion point table] value")
return kHashEnumerateNext;
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
TraverseBinding(nsHashKey *aKey, void *aData, void* aClosure)
{
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(aClosure);
cb->NoteXPCOMChild(static_cast<nsISupports*>(aData));
return kHashEnumerateNext;
}
@@ -641,17 +641,17 @@ struct InsertionData {
nsXBLBinding* mBinding;
nsXBLPrototypeBinding* mPrototype;
InsertionData(nsXBLBinding* aBinding,
nsXBLPrototypeBinding* aPrototype)
:mBinding(aBinding), mPrototype(aPrototype) {}
};
-PRBool PR_CALLBACK InstantiateInsertionPoint(nsHashKey* aKey, void* aData, void* aClosure)
+PRBool InstantiateInsertionPoint(nsHashKey* aKey, void* aData, void* aClosure)
{
nsXBLInsertionPointEntry* entry = static_cast<nsXBLInsertionPointEntry*>(aData);
InsertionData* data = static_cast<InsertionData*>(aClosure);
nsXBLBinding* binding = data->mBinding;
nsXBLPrototypeBinding* proto = data->mPrototype;
// Get the insertion parent.
nsIContent* content = entry->GetInsertionParent();
@@ -941,17 +941,17 @@ struct nsXBLAttrChangeData
PRInt32 mSrcNamespace;
nsXBLAttrChangeData(nsXBLPrototypeBinding* aProto,
nsIContent* aElt, nsIContent* aContent)
:mProto(aProto), mBoundElement(aElt), mContent(aContent) {}
};
// XXXbz this duplicates lots of AttributeChanged
-PRBool PR_CALLBACK SetAttrs(nsHashKey* aKey, void* aData, void* aClosure)
+PRBool SetAttrs(nsHashKey* aKey, void* aData, void* aClosure)
{
nsXBLAttributeEntry* entry = static_cast<nsXBLAttributeEntry*>(aData);
nsXBLAttrChangeData* changeData = static_cast<nsXBLAttrChangeData*>(aClosure);
nsIAtom* src = entry->GetSrcAttribute();
PRInt32 srcNs = changeData->mSrcNamespace;
nsAutoString value;
PRBool attrPresent = PR_TRUE;
@@ -1007,17 +1007,17 @@ PRBool PR_CALLBACK SetAttrs(nsHashKey* a
curr = curr->GetNext();
}
}
return PR_TRUE;
}
-PRBool PR_CALLBACK SetAttrsNS(nsHashKey* aKey, void* aData, void* aClosure)
+PRBool SetAttrsNS(nsHashKey* aKey, void* aData, void* aClosure)
{
if (aData && aClosure) {
nsPRUint32Key * key = static_cast<nsPRUint32Key*>(aKey);
nsObjectHashtable* xblAttributes =
static_cast<nsObjectHashtable*>(aData);
nsXBLAttrChangeData * changeData = static_cast<nsXBLAttrChangeData *>
(aClosure);
changeData->mSrcNamespace = key->GetValue();
@@ -1067,24 +1067,24 @@ nsXBLPrototypeBinding::ShouldBuildChildF
nsISupportsKey key(nsGkAtoms::text);
void* entry = xblAttributes->Get(&key);
return !entry;
}
return PR_TRUE;
}
-static PRBool PR_CALLBACK
+static PRBool
DeleteAttributeEntry(nsHashKey* aKey, void* aData, void* aClosure)
{
nsXBLAttributeEntry::Destroy(static_cast<nsXBLAttributeEntry*>(aData));
return PR_TRUE;
}
-static PRBool PR_CALLBACK
+static PRBool
DeleteAttributeTable(nsHashKey* aKey, void* aData, void* aClosure)
{
delete static_cast<nsObjectHashtable*>(aData);
return PR_TRUE;
}
void
nsXBLPrototypeBinding::ConstructAttributeTable(nsIContent* aElement)
@@ -1198,17 +1198,17 @@ nsXBLPrototypeBinding::ConstructAttribut
// Recur into our children.
PRUint32 childCount = aElement->GetChildCount();
for (PRUint32 i = 0; i < childCount; i++) {
ConstructAttributeTable(aElement->GetChildAt(i));
}
}
-static PRBool PR_CALLBACK
+static PRBool
DeleteInsertionPointEntry(nsHashKey* aKey, void* aData, void* aClosure)
{
static_cast<nsXBLInsertionPointEntry*>(aData)->Release();
return PR_TRUE;
}
void
nsXBLPrototypeBinding::ConstructInsertionTable(nsIContent* aContent)
--- a/content/xslt/src/xml/txXMLParser.cpp
+++ b/content/xslt/src/xml/txXMLParser.cpp
@@ -153,52 +153,52 @@ txParseFromStream(istream& aInputStream,
#define TX_ENSURE_DATA(_userData) \
PR_BEGIN_MACRO \
if (!aUserData) { \
NS_WARNING("no userData in comment handler"); \
return; \
} \
PR_END_MACRO
-PR_STATIC_CALLBACK(void)
+static void
startElement(void *aUserData, const XML_Char *aName, const XML_Char **aAtts)
{
TX_ENSURE_DATA(aUserData);
TX_XMLPARSER(aUserData)->StartElement(aName, aAtts);
}
-PR_STATIC_CALLBACK(void)
+static void
endElement(void *aUserData, const XML_Char* aName)
{
TX_ENSURE_DATA(aUserData);
TX_XMLPARSER(aUserData)->EndElement(aName);
}
-PR_STATIC_CALLBACK(void)
+static void
charData(void* aUserData, const XML_Char* aChars, int aLength)
{
TX_ENSURE_DATA(aUserData);
TX_XMLPARSER(aUserData)->CharacterData(aChars, aLength);
}
-PR_STATIC_CALLBACK(void)
+static void
commentHandler(void* aUserData, const XML_Char* aChars)
{
TX_ENSURE_DATA(aUserData);
TX_XMLPARSER(aUserData)->Comment(aChars);
}
-PR_STATIC_CALLBACK(void)
+static void
piHandler(void *aUserData, const XML_Char *aTarget, const XML_Char *aData)
{
TX_ENSURE_DATA(aUserData);
TX_XMLPARSER(aUserData)->ProcessingInstruction(aTarget, aData);
}
-PR_STATIC_CALLBACK(int)
+static int
externalEntityRefHandler(XML_Parser aParser,
const XML_Char *aContext,
const XML_Char *aBase,
const XML_Char *aSystemId,
const XML_Char *aPublicId)
{
// aParser is aUserData is the txXMLParser,
// we set that in txXMLParser::parse
--- a/content/xslt/src/xslt/txBufferingHandler.cpp
+++ b/content/xslt/src/xslt/txBufferingHandler.cpp
@@ -338,17 +338,17 @@ txBufferingHandler::startElement(nsIAtom
txOutputTransaction* transaction =
new txStartElementTransaction(aPrefix, aLocalName, aNsID);
NS_ENSURE_TRUE(transaction, NS_ERROR_OUT_OF_MEMORY);
return mBuffer->addTransaction(transaction);
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
deleteTransaction(void* aElement, void *aData)
{
delete static_cast<txOutputTransaction*>(aElement);
return PR_TRUE;
}
txResultBuffer::~txResultBuffer()
{
@@ -366,17 +366,17 @@ txResultBuffer::addTransaction(txOutputT
struct Holder
{
txAXMLEventHandler** mHandler;
nsresult mResult;
nsAFlatString::const_char_iterator mIter;
};
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
flushTransaction(void* aElement, void *aData)
{
Holder* holder = static_cast<Holder*>(aData);
txAXMLEventHandler* handler = *holder->mHandler;
txOutputTransaction* transaction =
static_cast<txOutputTransaction*>(aElement);
nsresult rv;
--- a/content/xslt/src/xslt/txStandaloneStylesheetCompiler.cpp
+++ b/content/xslt/src/xslt/txStandaloneStylesheetCompiler.cpp
@@ -114,47 +114,47 @@ TX_CompileStylesheetPath(const txParsedU
/**
* expat C stub handlers
*/
// shortcut macro for redirection into txDriver method calls
#define TX_DRIVER(_userData) static_cast<txDriver*>(_userData)
-PR_STATIC_CALLBACK(void)
+static void
startElement(void *aUserData, const XML_Char *aName, const XML_Char **aAtts)
{
if (!aUserData) {
NS_WARNING("no userData in startElement handler");
return;
}
TX_DRIVER(aUserData)->StartElement(aName, aAtts);
}
-PR_STATIC_CALLBACK(void)
+static void
endElement(void *aUserData, const XML_Char* aName)
{
if (!aUserData) {
NS_WARNING("no userData in endElement handler");
return;
}
TX_DRIVER(aUserData)->EndElement(aName);
}
-PR_STATIC_CALLBACK(void)
+static void
charData(void* aUserData, const XML_Char* aChars, int aLength)
{
if (!aUserData) {
NS_WARNING("no userData in charData handler");
return;
}
TX_DRIVER(aUserData)->CharacterData(aChars, aLength);
}
-PR_STATIC_CALLBACK(int)
+static int
externalEntityRefHandler(XML_Parser aParser,
const XML_Char *aContext,
const XML_Char *aBase,
const XML_Char *aSystemId,
const XML_Char *aPublicId)
{
// aParser is aUserData is the txDriver,
// we set that in txDriver::parse
--- a/content/xul/document/src/nsXULDocument.cpp
+++ b/content/xul/document/src/nsXULDocument.cpp
@@ -301,32 +301,32 @@ NS_NewXULDocument(nsIXULDocument** resul
//----------------------------------------------------------------------
//
// nsISupports interface
//
NS_IMPL_CYCLE_COLLECTION_CLASS(nsXULDocument)
-static PLDHashOperator PR_CALLBACK
+static PLDHashOperator
TraverseTemplateBuilders(nsISupports* aKey, nsIXULTemplateBuilder* aData,
void* aContext)
{
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(aContext);
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mTemplateBuilderTable key");
cb->NoteXPCOMChild(aKey);
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mTemplateBuilderTable value");
cb->NoteXPCOMChild(aData);
return PL_DHASH_NEXT;
}
-static PLDHashOperator PR_CALLBACK
+static PLDHashOperator
TraverseObservers(nsIURI* aKey, nsIObserver* aData, void* aContext)
{
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(aContext);
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mOverlayLoadObservers/mPendingOverlayLoadNotifications value");
cb->NoteXPCOMChild(aData);
@@ -642,17 +642,17 @@ nsXULDocument::OnDocumentParserError()
}
return PR_FALSE;
}
return PR_TRUE;
}
-PR_STATIC_CALLBACK(void)
+static void
ClearBroadcasterMapEntry(PLDHashTable* aTable, PLDHashEntryHdr* aEntry)
{
BroadcasterMapEntry* entry =
static_cast<BroadcasterMapEntry*>(aEntry);
for (PRInt32 i = entry->mListeners.Count() - 1; i >= 0; --i) {
delete (BroadcastListener*)entry->mListeners[i];
}
@@ -2786,17 +2786,17 @@ nsXULDocument::LoadOverlayInternal(nsIUR
// completes, it will trigger an EndLoad(), which'll wind
// us back in ResumeWalk().
if (!aIsDynamic)
*aShouldReturn = PR_TRUE;
}
return NS_OK;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
FirePendingMergeNotification(nsIURI* aKey, nsCOMPtr<nsIObserver>& aObserver, void* aClosure)
{
aObserver->Observe(aKey, "xul-overlay-merged", EmptyString().get());
typedef nsInterfaceHashtable<nsURIHashKey,nsIObserver> table;
table* observers = static_cast<table*>(aClosure);
observers->Remove(aKey);
--- a/content/xul/document/src/nsXULPrototypeCache.cpp
+++ b/content/xul/document/src/nsXULPrototypeCache.cpp
@@ -66,17 +66,17 @@
static NS_DEFINE_CID(kXULPrototypeCacheCID, NS_XULPROTOTYPECACHE_CID);
static PRBool gDisableXULCache = PR_FALSE; // enabled by default
static const char kDisableXULCachePref[] = "nglayout.debug.disable_xul_cache";
//----------------------------------------------------------------------
-PR_STATIC_CALLBACK(int)
+static int
DisableXULCacheChangedCallback(const char* aPref, void* aClosure)
{
gDisableXULCache =
nsContentUtils::GetBoolPref(kDisableXULCachePref, gDisableXULCache);
// Flush the cache, regardless
nsXULPrototypeCache* cache = nsXULPrototypeCache::GetInstance();
if (cache)
@@ -265,17 +265,17 @@ nsXULPrototypeCache::GetScript(nsIURI* a
return nsnull;
}
*aLangID = entry.mScriptTypeID;
return entry.mScriptObject;
}
/* static */
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
ReleaseScriptObjectCallback(nsIURI* aKey, CacheScriptEntry &aData, void* aClosure)
{
nsCOMPtr<nsIScriptRuntime> rt;
if (NS_SUCCEEDED(NS_GetScriptRuntimeByID(aData.mScriptTypeID, getter_AddRefs(rt))))
rt->DropScriptObject(aData.mScriptObject);
return PL_DHASH_REMOVE;
}
@@ -323,49 +323,49 @@ nsXULPrototypeCache::PutXBLDocumentInfo(
mXBLDocTable.Get(uri, getter_AddRefs(info));
if (!info) {
NS_ENSURE_TRUE(mXBLDocTable.Put(uri, aDocumentInfo),
NS_ERROR_OUT_OF_MEMORY);
}
return NS_OK;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
FlushSkinXBL(nsIURI* aKey, nsCOMPtr<nsIXBLDocumentInfo>& aDocInfo, void* aClosure)
{
nsCAutoString str;
aKey->GetPath(str);
PLDHashOperator ret = PL_DHASH_NEXT;
if (!strncmp(str.get(), "/skin", 5)) {
ret = PL_DHASH_REMOVE;
}
return ret;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
FlushSkinSheets(nsIURI* aKey, nsCOMPtr<nsICSSStyleSheet>& aSheet, void* aClosure)
{
nsCOMPtr<nsIURI> uri;
aSheet->GetSheetURI(getter_AddRefs(uri));
nsCAutoString str;
uri->GetPath(str);
PLDHashOperator ret = PL_DHASH_NEXT;
if (!strncmp(str.get(), "/skin", 5)) {
// This is a skin binding. Add the key to the list.
ret = PL_DHASH_REMOVE;
}
return ret;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
FlushScopedSkinStylesheets(nsIURI* aKey, nsCOMPtr<nsIXBLDocumentInfo> &aDocInfo, void* aClosure)
{
aDocInfo->FlushSkinStylesheets();
return PL_DHASH_NEXT;
}
void
nsXULPrototypeCache::FlushSkinFiles()
@@ -576,17 +576,17 @@ nsXULPrototypeCache::StartFastLoadingURI
// we must be reading the file, and urlspec was not associated
// with any multiplexed stream in it. The FastLoad service
// will therefore arrange to update the file, writing new data
// at the end while old (available) data continues to be read
// from the pre-existing part of the file.
return gFastLoadService->StartMuxedDocument(aURI, urlspec.get(), aDirectionFlags);
}
-PR_STATIC_CALLBACK(int)
+static int
FastLoadPrefChangedCallback(const char* aPref, void* aClosure)
{
PRBool wasEnabled = !gDisableXULFastLoad;
gDisableXULFastLoad =
nsContentUtils::GetBoolPref(kDisableXULFastLoadPref,
gDisableXULFastLoad);
if (wasEnabled && gDisableXULFastLoad) {
--- a/content/xul/document/src/nsXULPrototypeDocument.cpp
+++ b/content/xul/document/src/nsXULPrototypeDocument.cpp
@@ -110,33 +110,33 @@ protected:
static JSClass gSharedGlobalClass;
};
nsIPrincipal* nsXULPrototypeDocument::gSystemPrincipal;
nsXULPDGlobalObject* nsXULPrototypeDocument::gSystemGlobal;
PRUint32 nsXULPrototypeDocument::gRefCnt;
-void PR_CALLBACK
+void
nsXULPDGlobalObject_finalize(JSContext *cx, JSObject *obj)
{
nsISupports *nativeThis = (nsISupports*)JS_GetPrivate(cx, obj);
nsCOMPtr<nsIScriptGlobalObject> sgo(do_QueryInterface(nativeThis));
if (sgo) {
sgo->OnFinalize(nsIProgrammingLanguage::JAVASCRIPT, obj);
}
// The addref was part of JSObject construction
NS_RELEASE(nativeThis);
}
-JSBool PR_CALLBACK
+JSBool
nsXULPDGlobalObject_resolve(JSContext *cx, JSObject *obj, jsval id)
{
JSBool did_resolve = JS_FALSE;
return JS_ResolveStandardClass(cx, obj, id, &did_resolve);
}
--- a/content/xul/templates/src/nsXULContentUtils.h
+++ b/content/xul/templates/src/nsXULContentUtils.h
@@ -66,17 +66,17 @@ class nsXULContentUtils
protected:
static nsrefcnt gRefCnt;
static nsIRDFService* gRDF;
static nsIDateTimeFormat* gFormat;
static nsICollation *gCollation;
static PRBool gDisableXULCache;
- static int PR_CALLBACK
+ static int
DisableXULCacheChangedCallback(const char* aPrefName, void* aClosure);
public:
static nsresult
Init();
static nsresult
Finish();
--- a/content/xul/templates/src/nsXULSortService.cpp
+++ b/content/xul/templates/src/nsXULSortService.cpp
@@ -218,17 +218,17 @@ XULSortServiceImpl::GetTemplateItemsToSo
rv = GetTemplateItemsToSort(child, aBuilder, aSortState, aSortItems);
NS_ENSURE_SUCCESS(rv, rv);
}
}
return NS_OK;
}
-int PR_CALLBACK
+int
testSortCallback(const void *data1, const void *data2, void *privateData)
{
/// Note: testSortCallback is a small C callback stub for NS_QuickSort
contentSortInfo *left = (contentSortInfo *)data1;
contentSortInfo *right = (contentSortInfo *)data2;
nsSortState* sortState = (nsSortState *)privateData;
PRInt32 sortOrder = 0;
--- a/content/xul/templates/src/nsXULTemplateQueryProcessorRDF.cpp
+++ b/content/xul/templates/src/nsXULTemplateQueryProcessorRDF.cpp
@@ -83,49 +83,49 @@ nsrefcnt nsXULTemplateQ
nsIRDFService* nsXULTemplateQueryProcessorRDF::gRDFService;
nsIRDFContainerUtils* nsXULTemplateQueryProcessorRDF::gRDFContainerUtils;
nsIRDFResource* nsXULTemplateQueryProcessorRDF::kNC_BookmarkSeparator;
nsIRDFResource* nsXULTemplateQueryProcessorRDF::kRDF_type;
NS_IMPL_CYCLE_COLLECTION_CLASS(nsXULTemplateQueryProcessorRDF)
NS_IMPL_CYCLE_COLLECTION_UNLINK_0(nsXULTemplateQueryProcessorRDF)
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
BindingDependenciesTraverser(nsISupports* key,
nsCOMArray<nsXULTemplateResultRDF>* array,
void* userArg)
{
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(userArg);
PRInt32 i, count = array->Count();
for (i = 0; i < count; ++i) {
cb->NoteXPCOMChild(array->ObjectAt(i));
}
return PL_DHASH_NEXT;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
MemoryElementTraverser(const PRUint32& key,
nsCOMArray<nsXULTemplateResultRDF>* array,
void* userArg)
{
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(userArg);
PRInt32 i, count = array->Count();
for (i = 0; i < count; ++i) {
cb->NoteXPCOMChild(array->ObjectAt(i));
}
return PL_DHASH_NEXT;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
RuleToBindingTraverser(nsISupports* key, RDFBindingSet* binding, void* userArg)
{
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(userArg);
cb->NoteXPCOMChild(key);
return PL_DHASH_NEXT;
--- a/content/xul/templates/src/nsXULTreeBuilder.cpp
+++ b/content/xul/templates/src/nsXULTreeBuilder.cpp
@@ -174,17 +174,17 @@ protected:
IsContainerOpen(nsIXULTemplateResult *aResult, PRBool* aOpen);
nsresult
IsContainerOpen(nsIRDFResource* aResource, PRBool* aOpen);
/**
* A sorting callback for NS_QuickSort().
*/
- static int PR_CALLBACK
+ static int
Compare(const void* aLeft, const void* aRight, void* aClosure);
/**
* The real sort routine
*/
PRInt32
CompareResults(nsIXULTemplateResult* aLeft, nsIXULTemplateResult* aRight);
--- a/db/morkreader/nsMorkReader.cpp
+++ b/db/morkreader/nsMorkReader.cpp
@@ -140,17 +140,17 @@ MorkUnescape(const nsCSubstring &aString
nsresult
nsMorkReader::Init()
{
NS_ENSURE_TRUE(mValueMap.Init(), NS_ERROR_OUT_OF_MEMORY);
NS_ENSURE_TRUE(mTable.Init(), NS_ERROR_OUT_OF_MEMORY);
return NS_OK;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
DeleteStringArray(const nsCSubstring& aKey,
nsTArray<nsCString> *aData,
void *aUserArg)
{
delete aData;
return PL_DHASH_NEXT;
}
@@ -165,17 +165,17 @@ struct AddColumnClosure
nsMorkReader::IndexMap *c)
: array(a), columnMap(c), result(NS_OK) {}
nsTArray<nsMorkReader::MorkColumn> *array;
nsMorkReader::IndexMap *columnMap;
nsresult result;
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
AddColumn(const nsCSubstring &id, nsCString name, void *userData)
{
AddColumnClosure *closure = static_cast<AddColumnClosure*>(userData);
nsTArray<nsMorkReader::MorkColumn> *array = closure->array;
if (!array->AppendElement(nsMorkReader::MorkColumn(id, name)) ||
!closure->columnMap->Put(id, array->Length() - 1)) {
closure->result = NS_ERROR_OUT_OF_MEMORY;
--- a/db/morkreader/nsMorkReader.h
+++ b/db/morkreader/nsMorkReader.h
@@ -123,19 +123,19 @@ class NS_STACK_CLASS nsMorkReader
// rowID is the table-unique row id
// values contains the cell values, in an order which corresponds to
// the columns returned by GetColumns().
// You should call NormalizeValue() on any cell value that you plan to use.
// userData is the opaque pointer passed to EnumerateRows()
// The callback can return PL_DHASH_NEXT to continue enumerating,
// or PL_DHASH_STOP to stop.
typedef PLDHashOperator
- (*PR_CALLBACK RowEnumerator)(const nsCSubstring &rowID,
- const nsTArray<nsCString> *values,
- void *userData);
+ (* RowEnumerator)(const nsCSubstring &rowID,
+ const nsTArray<nsCString> *values,
+ void *userData);
// Initialize the importer object's data structures
nsresult Init();
// Read in the given mork file
// Note: currently, only single-table mork files are supported
nsresult Read(nsIFile *aFile);
--- a/docshell/base/nsWebShell.cpp
+++ b/docshell/base/nsWebShell.cpp
@@ -629,17 +629,17 @@ nsWebShell::GetInterface(const nsIID &aI
*aInstancePtr = mCommandManager;
NS_ADDREF((nsISupports*) *aInstancePtr);
return NS_OK;
}
return nsDocShell::GetInterface(aIID, aInstancePtr);
}
-nsEventStatus PR_CALLBACK
+nsEventStatus
nsWebShell::HandleEvent(nsGUIEvent *aEvent)
{
return nsEventStatus_eIgnore;
}
//----------------------------------------------------------------------
// Web Shell Services API
--- a/docshell/base/nsWebShell.h
+++ b/docshell/base/nsWebShell.h
@@ -95,17 +95,17 @@ public:
NS_IMETHOD OnOverLink(nsIContent* aContent,
nsIURI* aURI,
const PRUnichar* aTargetSpec);
NS_IMETHOD OnLeaveLink();
NS_IMETHOD GetLinkState(nsIURI* aLinkURI, nsLinkState& aState);
NS_IMETHOD Create();
- static nsEventStatus PR_CALLBACK HandleEvent(nsGUIEvent *aEvent);
+ static nsEventStatus HandleEvent(nsGUIEvent *aEvent);
// NS_IMETHOD SetURL(const PRUnichar* aURL);
friend class OnLinkClickEvent;
protected:
void InitFrameData();
--- a/docshell/build/nsDocShellModule.cpp
+++ b/docshell/build/nsDocShellModule.cpp
@@ -71,33 +71,33 @@
// download history
#include "nsDownloadHistory.h"
static PRBool gInitialized = PR_FALSE;
// The one time initialization for this module
// static
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
Initialize(nsIModule* aSelf)
{
NS_PRECONDITION(!gInitialized, "docshell module already initialized");
if (gInitialized) {
return NS_OK;
}
gInitialized = PR_TRUE;
nsresult rv = nsSHistory::Startup();
NS_ENSURE_SUCCESS(rv, rv);
rv = nsSHEntry::Startup();
return rv;
}
-PR_STATIC_CALLBACK(void)
+static void
Shutdown(nsIModule* aSelf)
{
nsSHEntry::Shutdown();
gInitialized = PR_FALSE;
}
// docshell
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsWebShell, Init)
--- a/docshell/shistory/src/nsSHEntry.cpp
+++ b/docshell/shistory/src/nsSHEntry.cpp
@@ -134,17 +134,17 @@ nsSHEntry::nsSHEntry(const nsSHEntry &ot
// XXX why not copy mContentType?
, mCacheKey(other.mCacheKey)
, mParent(other.mParent)
, mViewerBounds(0, 0, 0, 0)
, mOwner(other.mOwner)
{
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
ClearParentPtr(nsISHEntry* aEntry, void* /* aData */)
{
if (aEntry) {
aEntry->SetParent(nsnull);
}
return PR_TRUE;
}
--- a/dom/src/base/nsGlobalWindow.cpp
+++ b/dom/src/base/nsGlobalWindow.cpp
@@ -1062,17 +1062,17 @@ struct TraceData
{
TraceData(TraceCallback& aCallback, void* aClosure) :
callback(aCallback), closure(aClosure) {}
TraceCallback& callback;
void* closure;
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
TraceXBLHandlers(const void* aKey, void* aData, void* aClosure)
{
TraceData* data = static_cast<TraceData*>(aClosure);
data->callback(nsIProgrammingLanguage::JAVASCRIPT, aData, data->closure);
return PL_DHASH_NEXT;
}
NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(nsGlobalWindow)
@@ -6927,17 +6927,17 @@ nsGlobalWindow::Observe(nsISupports* aSu
return NS_OK;
}
NS_WARNING("unrecognized topic in nsGlobalWindow::Observe");
return NS_ERROR_FAILURE;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
FirePendingStorageEvents(const nsAString& aKey, PRBool aData, void *userArg)
{
nsGlobalWindow *win = static_cast<nsGlobalWindow *>(userArg);
nsCOMPtr<nsIDOMStorage> storage;
win->GetSessionStorage(getter_AddRefs(storage));
if (storage) {
--- a/dom/src/base/nsJSEnvironment.cpp
+++ b/dom/src/base/nsJSEnvironment.cpp
@@ -1130,17 +1130,17 @@ static const char js_strict_option_str[]
static const char js_werror_option_str[] = JS_OPTIONS_DOT_STR "werror";
static const char js_relimit_option_str[]= JS_OPTIONS_DOT_STR "relimit";
#ifdef JS_GC_ZEAL
static const char js_zeal_option_str[] = JS_OPTIONS_DOT_STR "gczeal";
#endif
static const char js_jit_content_str[] = JS_OPTIONS_DOT_STR "jit.content";
static const char js_jit_chrome_str[] = JS_OPTIONS_DOT_STR "jit.chrome";
-int PR_CALLBACK
+int
nsJSContext::JSOptionChangedCallback(const char *pref, void *data)
{
nsJSContext *context = reinterpret_cast<nsJSContext *>(data);
PRUint32 oldDefaultJSOptions = context->mDefaultJSOptions;
PRUint32 newDefaultJSOptions = oldDefaultJSOptions;
PRBool strict = nsContentUtils::GetBoolPref(js_strict_option_str);
if (strict)
@@ -3694,17 +3694,17 @@ nsJSRuntime::Startup()
gOldJSGCCallback = nsnull;
sIsInitialized = PR_FALSE;
sDidShutdown = PR_FALSE;
sContextCount = 0;
sSecurityManager = nsnull;
gCollation = nsnull;
}
-static int PR_CALLBACK
+static int
MaxScriptRunTimePrefChangedCallback(const char *aPrefName, void *aClosure)
{
// Default limit on script run time to 10 seconds. 0 means let
// scripts run forever.
PRBool isChromePref =
strcmp(aPrefName, "dom.max_chrome_script_run_time") == 0;
PRInt32 time = nsContentUtils::GetIntPref(aPrefName, isChromePref ? 20 : 10);
@@ -3720,17 +3720,17 @@ MaxScriptRunTimePrefChangedCallback(cons
sMaxChromeScriptRunTime = t;
} else {
sMaxScriptRunTime = t;
}
return 0;
}
-static int PR_CALLBACK
+static int
ReportAllJSExceptionsPrefChangedCallback(const char* aPrefName, void* aClosure)
{
PRBool reportAll = nsContentUtils::GetBoolPref(aPrefName, PR_FALSE);
nsContentUtils::XPConnect()->SetReportAllJSExceptions(reportAll);
return 0;
}
static JSPrincipals *
--- a/dom/src/base/nsJSEnvironment.h
+++ b/dom/src/base/nsJSEnvironment.h
@@ -287,17 +287,17 @@ private:
// mGlobalWrapperRef is used only to hold a strong reference to the
// global object wrapper while the nsJSContext is alive. This cuts
// down on the number of rooting and unrooting calls XPConnect has
// to make when the global object is touched in JS.
nsCOMPtr<nsISupports> mGlobalWrapperRef;
- static int PR_CALLBACK JSOptionChangedCallback(const char *pref, void *data);
+ static int JSOptionChangedCallback(const char *pref, void *data);
static JSBool DOMOperationCallback(JSContext *cx);
};
class nsIJSRuntimeService;
class nsJSRuntime : public nsIScriptRuntime
{
--- a/dom/src/base/nsScriptNameSpaceManager.cpp
+++ b/dom/src/base/nsScriptNameSpaceManager.cpp
@@ -63,36 +63,36 @@ class GlobalNameMapEntry : public PLDHas
{
public:
// Our hash table ops don't care about the order of these members
nsString mKey;
nsGlobalNameStruct mGlobalName;
};
-PR_STATIC_CALLBACK(PLDHashNumber)
+static PLDHashNumber
GlobalNameHashHashKey(PLDHashTable *table, const void *key)
{
const nsAString *str = static_cast<const nsAString *>(key);
return HashString(*str);
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
GlobalNameHashMatchEntry(PLDHashTable *table, const PLDHashEntryHdr *entry,
const void *key)
{
const GlobalNameMapEntry *e =
static_cast<const GlobalNameMapEntry *>(entry);
const nsAString *str = static_cast<const nsAString *>(key);
return str->Equals(e->mKey);
}
-PR_STATIC_CALLBACK(void)
+static void
GlobalNameHashClearEntry(PLDHashTable *table, PLDHashEntryHdr *entry)
{
GlobalNameMapEntry *e = static_cast<GlobalNameMapEntry *>(entry);
// An entry is being cleared, let the key (nsString) do its own
// cleanup.
e->mKey.~nsString();
if (e->mGlobalName.mType == nsGlobalNameStruct::eTypeExternalClassInfo) {
@@ -111,17 +111,17 @@ GlobalNameHashClearEntry(PLDHashTable *t
delete e->mGlobalName.mAlias;
}
// This will set e->mGlobalName.mType to
// nsGlobalNameStruct::eTypeNotInitialized
memset(&e->mGlobalName, 0, sizeof(nsGlobalNameStruct));
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
GlobalNameHashInitEntry(PLDHashTable *table, PLDHashEntryHdr *entry,
const void *key)
{
GlobalNameMapEntry *e = static_cast<GlobalNameMapEntry *>(entry);
const nsAString *keyStr = static_cast<const nsAString *>(key);
// Initialize the key in the entry with placement new
new (&e->mKey) nsString(*keyStr);
@@ -505,17 +505,17 @@ nsScriptNameSpaceManager::Init()
return NS_OK;
}
struct NameSetClosure {
nsIScriptContext* ctx;
nsresult rv;
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
NameSetInitCallback(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg)
{
GlobalNameMapEntry *entry = static_cast<GlobalNameMapEntry *>(hdr);
if (entry->mGlobalName.mType == nsGlobalNameStruct::eTypeStaticNameSet) {
nsresult rv = NS_OK;
nsCOMPtr<nsIScriptExternalNameSet> ns =
--- a/dom/src/storage/nsDOMStorage.cpp
+++ b/dom/src/storage/nsDOMStorage.cpp
@@ -223,17 +223,17 @@ nsDOMStorageManager::Shutdown()
gStorageManager = nsnull;
#ifdef MOZ_STORAGE
delete nsDOMStorage::gStorageDB;
nsDOMStorage::gStorageDB = nsnull;
#endif
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
ClearStorage(nsDOMStorageEntry* aEntry, void* userArg)
{
aEntry->mStorage->ClearAll();
return PL_DHASH_REMOVE;
}
static nsresult
GetOfflineDomains(nsStringArray& aDomains)
@@ -359,17 +359,17 @@ nsDOMStorageEntry::nsDOMStorageEntry(con
{
NS_ERROR("DOMStorage horked.");
}
nsDOMStorageEntry::~nsDOMStorageEntry()
{
}
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
SessionStorageTraverser(nsSessionStorageEntry* aEntry, void* userArg) {
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(userArg);
cb->NoteXPCOMChild((nsIDOMStorageItem *) aEntry->mItem);
return PL_DHASH_NEXT;
}
@@ -505,17 +505,17 @@ public:
}
PRBool mIsCallerSecure;
PRBool mCount;
private:
ItemCounterState(); // Not to be implemented
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
ItemCounter(nsSessionStorageEntry* aEntry, void* userArg)
{
ItemCounterState *state = (ItemCounterState *)userArg;
if (state->mIsCallerSecure || !aEntry->mItem->IsSecure()) {
++state->mCount;
}
@@ -553,17 +553,17 @@ public:
PRUint32 mIndex;
PRUint32 mWantedIndex;
nsSessionStorageEntry *mItem;
private:
IndexFinderData(); // Not to be implemented
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
IndexFinder(nsSessionStorageEntry* aEntry, void* userArg)
{
IndexFinderData *data = (IndexFinderData *)userArg;
if (data->mIndex == data->mWantedIndex &&
(data->mIsCallerSecure || !aEntry->mItem->IsSecure())) {
data->mItem = aEntry;
@@ -926,30 +926,30 @@ nsDOMStorage::SetSecure(const nsAString&
if (entry) {
entry->mItem->SetSecureInternal(aSecure);
}
return NS_OK;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
ClearStorageItem(nsSessionStorageEntry* aEntry, void* userArg)
{
aEntry->mItem->SetValueInternal(EmptyString());
return PL_DHASH_NEXT;
}
void
nsDOMStorage::ClearAll()
{
mItems.EnumerateEntries(ClearStorageItem, nsnull);
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
CopyStorageItems(nsSessionStorageEntry* aEntry, void* userArg)
{
nsDOMStorage* newstorage = static_cast<nsDOMStorage*>(userArg);
newstorage->SetItem(aEntry->GetKey(), aEntry->mItem->GetValueInternal());
if (aEntry->mItem->IsSecure()) {
newstorage->SetSecure(aEntry->GetKey(), PR_TRUE);
@@ -979,17 +979,17 @@ nsDOMStorage::Clone(nsIURI* aURI)
}
struct KeysArrayBuilderStruct
{
PRBool callerIsSecure;
nsTArray<nsString> *keys;
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
KeysArrayBuilder(nsSessionStorageEntry* aEntry, void* userArg)
{
KeysArrayBuilderStruct *keystruct = (KeysArrayBuilderStruct *)userArg;
if (keystruct->callerIsSecure || !aEntry->mItem->IsSecure())
keystruct->keys->AppendElement(aEntry->GetKey());
return PL_DHASH_NEXT;
--- a/embedding/browser/activex/src/common/IEHtmlNode.cpp
+++ b/embedding/browser/activex/src/common/IEHtmlNode.cpp
@@ -38,22 +38,22 @@
#include "stdafx.h"
#include "IEHtmlNode.h"
#include "plhash.h"
static PLHashTable *g_NodeLookupTable;
-static PLHashNumber PR_CALLBACK HashFunction(const void *key)
+static PLHashNumber HashFunction(const void *key)
{
return (PRUint32) key;
}
-PRIntn PR_CALLBACK HashComparator(const void *v1, const void *v2)
+PRIntn HashComparator(const void *v1, const void *v2)
{
if (v1 == v2)
{
return 1;
}
return 0;
}
--- a/embedding/browser/activex/src/plugin/XPConnect.cpp
+++ b/embedding/browser/activex/src/plugin/XPConnect.cpp
@@ -371,17 +371,17 @@ nsScriptablePeer::ConvertVariants(VARIAN
if (NS_FAILED(rv))
{
// do_CreateInstance macro is broken so load the component manager by
// hand and get it to create the component.
HMODULE hlib = ::LoadLibraryW(L"xpcom.dll");
if (hlib)
{
nsIComponentManager *pManager = nsnull; // A frozen interface, even in 1.0.x
- typedef nsresult (PR_CALLBACK *Moz1XGetComponentManagerFunc)(nsIComponentManager* *result);
+ typedef nsresult (*Moz1XGetComponentManagerFunc)(nsIComponentManager* *result);
Moz1XGetComponentManagerFunc compMgr = (Moz1XGetComponentManagerFunc)
::GetProcAddress(hlib, "NS_GetComponentManager");
if (compMgr)
{
compMgr(&pManager);
if (pManager)
{
rv = pManager->CreateInstanceByContractID("@mozilla.org/variant;1",
--- a/embedding/browser/photon/src/PtMozilla.cpp
+++ b/embedding/browser/photon/src/PtMozilla.cpp
@@ -89,17 +89,17 @@
#include "HeaderSniffer.h"
#include "PromptService.h"
#include "PtMozilla.h"
//#include "nsUnknownContentTypeHandler.h"
#ifdef _BUILD_STATIC_BIN
#include "nsStaticComponent.h"
-nsresult PR_CALLBACK
+nsresult
ph_getModuleInfo(nsStaticModuleInfo **info, PRUint32 *count);
#endif
// Macro for converting from nscolor to PtColor_t
// Photon RGB values are stored as 00 RR GG BB
// nscolor RGB values are 00 BB GG RR
#define NS_TO_PH_RGB(ns) (ns & 0xff) << 16 | (ns & 0xff00) | ((ns >> 16) & 0xff)
#define PH_TO_NS_RGB(ns) (ns & 0xff) << 16 | (ns & 0xff00) | ((ns >> 16) & 0xff)
--- a/embedding/browser/webBrowser/nsWebBrowser.cpp
+++ b/embedding/browser/webBrowser/nsWebBrowser.cpp
@@ -118,17 +118,17 @@ nsWebBrowser::nsWebBrowser() : mDocShell
NS_ASSERTION(mWWatch, "failed to get WindowWatcher");
}
nsWebBrowser::~nsWebBrowser()
{
InternalDestroy();
}
-PRBool PR_CALLBACK deleteListener(void *aElement, void *aData) {
+PRBool deleteListener(void *aElement, void *aData) {
nsWebBrowserListenerState *state = (nsWebBrowserListenerState*)aElement;
NS_DELETEXPCOM(state);
return PR_TRUE;
}
NS_IMETHODIMP nsWebBrowser::InternalDestroy()
{
@@ -1642,17 +1642,17 @@ NS_IMETHODIMP nsWebBrowser::EnsureDocShe
NS_ADDREF(mDocShellTreeOwner);
mDocShellTreeOwner->WebBrowser(this);
return NS_OK;
}
/* static */
-nsEventStatus PR_CALLBACK nsWebBrowser::HandleEvent(nsGUIEvent *aEvent)
+nsEventStatus nsWebBrowser::HandleEvent(nsGUIEvent *aEvent)
{
nsWebBrowser *browser = nsnull;
void *data = nsnull;
if (!aEvent->widget)
return nsEventStatus_eIgnore;
aEvent->widget->GetClientData(data);
--- a/embedding/browser/webBrowser/nsWebBrowser.h
+++ b/embedding/browser/webBrowser/nsWebBrowser.h
@@ -146,17 +146,17 @@ protected:
NS_IMETHOD SetDocShell(nsIDocShell* aDocShell);
NS_IMETHOD EnsureDocShellTreeOwner();
NS_IMETHOD GetPrimaryContentWindow(nsIDOMWindowInternal **aDomWindow);
NS_IMETHOD BindListener(nsISupports *aListener, const nsIID& aIID);
NS_IMETHOD UnBindListener(nsISupports *aListener, const nsIID& aIID);
NS_IMETHOD EnableGlobalHistory(PRBool aEnable);
- static nsEventStatus PR_CALLBACK HandleEvent(nsGUIEvent *aEvent);
+ static nsEventStatus HandleEvent(nsGUIEvent *aEvent);
protected:
nsDocShellTreeOwner* mDocShellTreeOwner;
nsCOMPtr<nsIDocShell> mDocShell;
nsCOMPtr<nsIInterfaceRequestor> mDocShellAsReq;
nsCOMPtr<nsIBaseWindow> mDocShellAsWin;
nsCOMPtr<nsIDocShellTreeItem> mDocShellAsItem;
nsCOMPtr<nsIWebNavigation> mDocShellAsNav;
--- a/embedding/components/commandhandler/src/nsCommandGroup.cpp
+++ b/embedding/components/commandhandler/src/nsCommandGroup.cpp
@@ -54,17 +54,17 @@ public:
nsGroupsEnumerator(nsHashtable& inHashTable);
virtual ~nsGroupsEnumerator();
NS_DECL_ISUPPORTS
NS_DECL_NSISIMPLEENUMERATOR
protected:
- static PRBool PR_CALLBACK HashEnum(nsHashKey *aKey, void *aData, void* aClosure);
+ static PRBool HashEnum(nsHashKey *aKey, void *aData, void* aClosure);
nsresult Initialize();
protected:
nsHashtable& mHashTable;
PRInt32 mIndex;
char ** mGroupNames; // array of pointers to PRUnichar* in the hash table
--- a/embedding/components/commandhandler/src/nsCommandGroup.h
+++ b/embedding/components/commandhandler/src/nsCommandGroup.h
@@ -65,17 +65,17 @@ public:
protected:
void ClearGroupsHash();
protected:
- static PRBool PR_CALLBACK ClearEnumerator(nsHashKey *aKey, void *aData, void* closure);
+ static PRBool ClearEnumerator(nsHashKey *aKey, void *aData, void* closure);
protected:
nsHashtable mGroupsHash; // hash keyed on command group.
// Entries are nsVoidArrays of pointers to PRUnichar*
// This could be made more space-efficient, maybe with atoms
};
--- a/embedding/components/commandhandler/src/nsCommandManager.cpp
+++ b/embedding/components/commandhandler/src/nsCommandManager.cpp
@@ -65,17 +65,17 @@ nsCommandManager::nsCommandManager()
}
nsCommandManager::~nsCommandManager()
{
/* destructor code */
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
TraverseCommandObservers(const char* aKey, nsCOMArray<nsIObserver>* aObservers,
void* aClosure)
{
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(aClosure);
PRInt32 i, numItems = aObservers->Count();
for (i = 0; i < numItems; ++i) {
--- a/embedding/components/commandhandler/src/nsCommandParams.h
+++ b/embedding/components/commandhandler/src/nsCommandParams.h
@@ -146,25 +146,25 @@ protected:
HashEntry* GetNamedEntry(const char * name);
HashEntry* GetIndexedEntry(PRInt32 index);
PRUint32 GetNumEntries();
nsresult GetOrMakeEntry(const char * name, PRUint8 entryType, HashEntry*& outEntry);
protected:
- static PLDHashNumber PR_CALLBACK HashKey(PLDHashTable *table, const void *key);
+ static PLDHashNumber HashKey(PLDHashTable *table, const void *key);
- static PRBool PR_CALLBACK HashMatchEntry(PLDHashTable *table,
- const PLDHashEntryHdr *entry, const void *key);
+ static PRBool HashMatchEntry(PLDHashTable *table,
+ const PLDHashEntryHdr *entry, const void *key);
- static void PR_CALLBACK HashMoveEntry(PLDHashTable *table, const PLDHashEntryHdr *from,
- PLDHashEntryHdr *to);
+ static void HashMoveEntry(PLDHashTable *table, const PLDHashEntryHdr *from,
+ PLDHashEntryHdr *to);
- static void PR_CALLBACK HashClearEntry(PLDHashTable *table, PLDHashEntryHdr *entry);
+ static void HashClearEntry(PLDHashTable *table, PLDHashEntryHdr *entry);
protected:
enum {
eNumEntriesUnknown = -1
};
--- a/embedding/components/webbrowserpersist/src/nsWebBrowserPersist.cpp
+++ b/embedding/components/webbrowserpersist/src/nsWebBrowserPersist.cpp
@@ -2399,17 +2399,17 @@ nsWebBrowserPersist::FixRedirectedChanne
nsISupportsKey key(keyPtr);
mOutputMap.Put(&key, outputData);
}
}
return NS_OK;
}
-PRBool PR_CALLBACK
+PRBool
nsWebBrowserPersist::EnumFixRedirect(nsHashKey *aKey, void *aData, void* closure)
{
FixRedirectData *data = (FixRedirectData *) closure;
nsCOMPtr<nsISupports> keyPtr;
((nsMyISupportsKey *) aKey)->GetISupports(getter_AddRefs(keyPtr));
nsCOMPtr<nsIChannel> thisChannel = do_QueryInterface(keyPtr);
@@ -2451,58 +2451,58 @@ nsWebBrowserPersist::CalcTotalProgress()
if (mTotalCurrentProgress == LL_ZERO && mTotalMaxProgress == LL_ZERO)
{
// No output streams so we must be complete
mTotalCurrentProgress = 10000;
mTotalMaxProgress = 10000;
}
}
-PRBool PR_CALLBACK
+PRBool
nsWebBrowserPersist::EnumCalcProgress(nsHashKey *aKey, void *aData, void* closure)
{
nsWebBrowserPersist *pthis = (nsWebBrowserPersist *) closure;
OutputData *data = (OutputData *) aData;
// only count toward total progress if destination file is local
nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(data->mFile);
if (fileURL)
{
pthis->mTotalCurrentProgress += data->mSelfProgress;
pthis->mTotalMaxProgress += data->mSelfProgressMax;
}
return PR_TRUE;
}
-PRBool PR_CALLBACK
+PRBool
nsWebBrowserPersist::EnumCalcUploadProgress(nsHashKey *aKey, void *aData, void* closure)
{
if (aData && closure)
{
nsWebBrowserPersist *pthis = (nsWebBrowserPersist *) closure;
UploadData *data = (UploadData *) aData;
pthis->mTotalCurrentProgress += data->mSelfProgress;
pthis->mTotalMaxProgress += data->mSelfProgressMax;
}
return PR_TRUE;
}
-PRBool PR_CALLBACK
+PRBool
nsWebBrowserPersist::EnumCountURIsToPersist(nsHashKey *aKey, void *aData, void* closure)
{
URIData *data = (URIData *) aData;
PRUint32 *count = (PRUint32 *) closure;
if (data->mNeedsPersisting && !data->mSaved)
{
(*count)++;
}
return PR_TRUE;
}
-PRBool PR_CALLBACK
+PRBool
nsWebBrowserPersist::EnumPersistURIs(nsHashKey *aKey, void *aData, void* closure)
{
URIData *data = (URIData *) aData;
if (!data->mNeedsPersisting || data->mSaved)
{
return PR_TRUE;
}
@@ -2543,17 +2543,17 @@ nsWebBrowserPersist::EnumPersistURIs(nsH
}
if (pthis->mSerializingOutput)
return PR_FALSE;
return PR_TRUE;
}
-PRBool PR_CALLBACK
+PRBool
nsWebBrowserPersist::EnumCleanupOutputMap(nsHashKey *aKey, void *aData, void* closure)
{
nsCOMPtr<nsISupports> keyPtr;
((nsMyISupportsKey *) aKey)->GetISupports(getter_AddRefs(keyPtr));
nsCOMPtr<nsIChannel> channel = do_QueryInterface(keyPtr);
if (channel)
{
channel->Cancel(NS_BINDING_ABORTED);
@@ -2562,29 +2562,29 @@ nsWebBrowserPersist::EnumCleanupOutputMa
if (data)
{
delete data;
}
return PR_TRUE;
}
-PRBool PR_CALLBACK
+PRBool
nsWebBrowserPersist::EnumCleanupURIMap(nsHashKey *aKey, void *aData, void* closure)
{
URIData *data = (URIData *) aData;
if (data)
{
delete data; // Delete data associated with key
}
return PR_TRUE;
}
-PRBool PR_CALLBACK
+PRBool
nsWebBrowserPersist::EnumCleanupUploadList(nsHashKey *aKey, void *aData, void* closure)
{
nsCOMPtr<nsISupports> keyPtr;
((nsMyISupportsKey *) aKey)->GetISupports(getter_AddRefs(keyPtr));
nsCOMPtr<nsIChannel> channel = do_QueryInterface(keyPtr);
if (channel)
{
channel->Cancel(NS_BINDING_ABORTED);
--- a/embedding/components/webbrowserpersist/src/nsWebBrowserPersist.h
+++ b/embedding/components/webbrowserpersist/src/nsWebBrowserPersist.h
@@ -181,31 +181,31 @@ private:
void EndDownload(nsresult aResult = NS_OK);
nsresult SaveGatheredURIs(nsIURI *aFileAsURI);
PRBool SerializeNextFile();
void CalcTotalProgress();
void SetApplyConversionIfNeeded(nsIChannel *aChannel);
// Hash table enumerators
- static PRBool PR_CALLBACK EnumPersistURIs(
+ static PRBool EnumPersistURIs(
nsHashKey *aKey, void *aData, void* closure);
- static PRBool PR_CALLBACK EnumCleanupURIMap(
+ static PRBool EnumCleanupURIMap(
nsHashKey *aKey, void *aData, void* closure);
- static PRBool PR_CALLBACK EnumCleanupOutputMap(
+ static PRBool EnumCleanupOutputMap(
nsHashKey *aKey, void *aData, void* closure);
- static PRBool PR_CALLBACK EnumCleanupUploadList(
+ static PRBool EnumCleanupUploadList(
nsHashKey *aKey, void *aData, void* closure);
- static PRBool PR_CALLBACK EnumCalcProgress(
+ static PRBool EnumCalcProgress(
nsHashKey *aKey, void *aData, void* closure);
- static PRBool PR_CALLBACK EnumCalcUploadProgress(
+ static PRBool EnumCalcUploadProgress(
nsHashKey *aKey, void *aData, void* closure);
- static PRBool PR_CALLBACK EnumFixRedirect(
+ static PRBool EnumFixRedirect(
nsHashKey *aKey, void *aData, void* closure);
- static PRBool PR_CALLBACK EnumCountURIsToPersist(
+ static PRBool EnumCountURIsToPersist(
nsHashKey *aKey, void *aData, void* closure);
nsCOMPtr<nsIURI> mCurrentDataPath;
PRBool mCurrentDataPathIsRelative;
nsCString mCurrentRelativePathToData;
nsCOMPtr<nsIURI> mCurrentBaseURI;
nsCString mCurrentCharset;
nsCOMPtr<nsIURI> mTargetBaseURI;
--- a/extensions/access-builtin/accessproxy/nsAccessProxyRegistration.cpp
+++ b/extensions/access-builtin/accessproxy/nsAccessProxyRegistration.cpp
@@ -68,17 +68,17 @@ static NS_METHOD nsAccessProxyRegistrati
rv = categoryManager->AddCategoryEntry(APPSTARTUP_CATEGORY, "Access Proxy",
"service," NS_ACCESSPROXY_CONTRACTID, PR_TRUE, PR_TRUE, nsnull);
return rv;
}
NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsAccessProxy,nsAccessProxy::GetInstance)
-static void PR_CALLBACK AccessProxyModuleDtor(nsIModule* self)
+static void AccessProxyModuleDtor(nsIModule* self)
{
nsAccessProxy::ReleaseInstance();
}
static const nsModuleComponentInfo components[] =
{
{ "AccessProxy Component", NS_ACCESSPROXY_CID, NS_ACCESSPROXY_CONTRACTID,
nsAccessProxyConstructor, nsAccessProxyRegistrationProc,
--- a/extensions/auth/nsAuthFactory.cpp
+++ b/extensions/auth/nsAuthFactory.cpp
@@ -255,26 +255,26 @@ static nsModuleComponentInfo components[
}
};
//-----------------------------------------------------------------------------
#if defined( PR_LOGGING )
PRLogModuleInfo *gNegotiateLog;
// setup nspr logging ...
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
InitNegotiateAuth(nsIModule *self)
{
gNegotiateLog = PR_NewLogModule("negotiateauth");
return NS_OK;
}
#else
#define InitNegotiateAuth nsnull
#endif
-PR_STATIC_CALLBACK(void)
+static void
DestroyNegotiateAuth(nsIModule *self)
{
nsAuthGSSAPI::Shutdown();
}
NS_IMPL_NSGETMODULE_WITH_CTOR_DTOR(nsAuthModule, components,
InitNegotiateAuth, DestroyNegotiateAuth)
--- a/extensions/cookie/nsPermissionManager.cpp
+++ b/extensions/cookie/nsPermissionManager.cpp
@@ -541,17 +541,17 @@ struct nsGetEnumeratorData
nsGetEnumeratorData(nsCOMArray<nsIPermission> *aArray, const nsTArray<nsCString> *aTypes)
: array(aArray)
, types(aTypes) {}
nsCOMArray<nsIPermission> *array;
const nsTArray<nsCString> *types;
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
AddPermissionsToList(nsHostEntry *entry, void *arg)
{
nsGetEnumeratorData *data = static_cast<nsGetEnumeratorData *>(arg);
for (PRUint32 i = 0; i < entry->GetPermissions().Length(); ++i) {
nsPermissionEntry &permEntry = entry->GetPermissions()[i];
nsPermission *perm = new nsPermission(entry->GetHost(),
--- a/extensions/metrics/src/nsLoadCollector.cpp
+++ b/extensions/metrics/src/nsLoadCollector.cpp
@@ -445,17 +445,17 @@ nsLoadCollector::OnAttach()
nsresult rv = progress->AddProgressListener(
this, nsIWebProgress::NOTIFY_STATE_DOCUMENT);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
-/* static */ PLDHashOperator PR_CALLBACK
+/* static */ PLDHashOperator
nsLoadCollector::RemoveDocumentFromMap(const nsIDocument *document,
DocumentEntry &entry, void *userData)
{
nsIDocument *mutable_doc = const_cast<nsIDocument*>(document);
mutable_doc->RemoveObserver(static_cast<nsLoadCollector*>(userData));
return PL_DHASH_REMOVE;
}
--- a/extensions/metrics/src/nsLoadCollector.h
+++ b/extensions/metrics/src/nsLoadCollector.h
@@ -97,17 +97,17 @@ class nsLoadCollector : public nsIMetric
PRUint32 docID;
PRUint32 windowID;
PRBool subframe;
};
~nsLoadCollector();
// Callback for removing a document observer and map entry
- static PLDHashOperator PR_CALLBACK
+ static PLDHashOperator
RemoveDocumentFromMap(const nsIDocument *document,
DocumentEntry &entry, void *userData);
// Hash table mapping nsIRequest objects to their event properties.
nsDataHashtable<nsISupportsHashKey, RequestEntry> mRequestMap;
// Documents we're currently listening to, and their associated ids
nsDataHashtable< nsPtrHashKey<nsIDocument>, DocumentEntry > mDocumentMap;
--- a/extensions/metrics/src/nsMetricsConfig.cpp
+++ b/extensions/metrics/src/nsMetricsConfig.cpp
@@ -409,17 +409,17 @@ nsMetricsConfig::SetEventEnabled(const n
void
nsMetricsConfig::ClearEvents()
{
NS_ASSERTION(mEventSet.IsInitialized(), "nsMetricsConfig::Init not called");
mEventSet.Clear();
}
-/* static */ PLDHashOperator PR_CALLBACK
+/* static */ PLDHashOperator
nsMetricsConfig::CopyKey(nsStringHashKey *entry, void *userData)
{
static_cast<nsTArray<nsString> *>(userData)->
AppendElement(entry->GetKey());
return PL_DHASH_NEXT;
}
void
--- a/extensions/metrics/src/nsMetricsConfig.h
+++ b/extensions/metrics/src/nsMetricsConfig.h
@@ -147,18 +147,17 @@ private:
// Run a callback method for each child element of the given element.
void ForEachChildElement(nsIDOMElement *elem, ForEachChildElementCallback cb);
void ProcessToplevelElement(nsIDOMElement *elem);
void ProcessConfigChild(nsIDOMElement *elem);
void ProcessCollectorElement(nsIDOMElement *elem);
- static PLDHashOperator PR_CALLBACK CopyKey(nsStringHashKey *key,
- void *userData);
+ static PLDHashOperator CopyKey(nsStringHashKey *key, void *userData);
nsTHashtable<nsStringHashKey> mEventSet;
nsDataHashtable<nsStringHashKey,nsString> mNSURIToPrefixMap;
PRInt32 mEventLimit;
PRInt32 mUploadInterval;
PRBool mHasConfig;
};
--- a/extensions/metrics/src/nsMetricsService.cpp
+++ b/extensions/metrics/src/nsMetricsService.cpp
@@ -199,17 +199,17 @@ nsMetricsService::nsMetricsService()
mUploading(PR_FALSE),
mNextWindowID(0),
mRetryCount(0)
{
NS_ASSERTION(!sMetricsService, ">1 MetricsService object created");
sMetricsService = this;
}
-/* static */ PLDHashOperator PR_CALLBACK
+/* static */ PLDHashOperator
nsMetricsService::DetachCollector(const nsAString &key,
nsIMetricsCollector *value, void *userData)
{
value->OnDetach();
return PL_DHASH_NEXT;
}
nsMetricsService::~nsMetricsService()
@@ -768,17 +768,17 @@ struct DisabledCollectorsClosure
// Collectors which are enabled in the new config
const nsTArray<nsString> &enabledCollectors;
// Collector instances which should no longer be enabled
nsTArray< nsCOMPtr<nsIMetricsCollector> > disabledCollectors;
};
-/* static */ PLDHashOperator PR_CALLBACK
+/* static */ PLDHashOperator
nsMetricsService::PruneDisabledCollectors(const nsAString &key,
nsCOMPtr<nsIMetricsCollector> &value,
void *userData)
{
DisabledCollectorsClosure *dc =
static_cast<DisabledCollectorsClosure *>(userData);
// The frozen string API doesn't expose operator==, so we can't use
@@ -792,17 +792,17 @@ nsMetricsService::PruneDisabledCollector
// We didn't find the collector |key| in the list of enabled collectors,
// so move it from the hash table to the disabledCollectors list.
MS_LOG(("Disabling collector %s", NS_ConvertUTF16toUTF8(key).get()));
dc->disabledCollectors.AppendElement(value);
return PL_DHASH_REMOVE;
}
-/* static */ PLDHashOperator PR_CALLBACK
+/* static */ PLDHashOperator
nsMetricsService::NotifyNewLog(const nsAString &key,
nsIMetricsCollector *value, void *userData)
{
value->OnNewLog();
return PL_DHASH_NEXT;
}
void
--- a/extensions/metrics/src/nsMetricsService.h
+++ b/extensions/metrics/src/nsMetricsService.h
@@ -215,26 +215,26 @@ private:
PRBool LoadNewConfig(nsIFile *newConfig, nsIFile *oldConfig);
// Removes the existing data file (metrics.xml)
void RemoveDataFile();
// Generates a random interval, in seconds, between 12 and 36 hours.
PRInt32 GetRandomUploadInterval();
- static PLDHashOperator PR_CALLBACK
+ static PLDHashOperator
PruneDisabledCollectors(const nsAString &key,
nsCOMPtr<nsIMetricsCollector> &value,
void *userData);
- static PLDHashOperator PR_CALLBACK
+ static PLDHashOperator
DetachCollector(const nsAString &key,
nsIMetricsCollector *value, void *userData);
- static PLDHashOperator PR_CALLBACK
+ static PLDHashOperator
NotifyNewLog(const nsAString &key,
nsIMetricsCollector *value, void *userData);
// Helpers to set a pref and then flush the pref file to disk.
static nsresult FlushIntPref(const char *prefName, PRInt32 prefValue);
static nsresult FlushCharPref(const char *prefName, const char *prefValue);
static nsresult FlushClearPref(const char *prefName);
--- a/extensions/metrics/src/nsUICommandCollector.cpp
+++ b/extensions/metrics/src/nsUICommandCollector.cpp
@@ -55,34 +55,34 @@ const nsUICommandCollector::EventHandler
{ "TabMove", &nsUICommandCollector::HandleTabMoveEvent },
{ "popupshowing", &nsUICommandCollector::HandlePopupShowingEvent },
};
NS_IMPL_ISUPPORTS3(nsUICommandCollector, nsIObserver, nsIDOMEventListener,
nsIMetricsCollector)
/* static */
-PLDHashOperator PR_CALLBACK nsUICommandCollector::AddCommandEventListener(
+PLDHashOperator nsUICommandCollector::AddCommandEventListener(
const nsIDOMWindow* key, PRUint32 windowID, void* userArg)
{
nsCOMPtr<nsIDOMEventTarget> windowTarget =
do_QueryInterface(const_cast<nsIDOMWindow *>(key));
if (!windowTarget) {
MS_LOG(("Error casting domeventtarget"));
return PL_DHASH_NEXT;
}
nsUICommandCollector* collector = static_cast<nsUICommandCollector*>
(userArg);
collector->AddEventListeners(windowTarget);
return PL_DHASH_NEXT;
}
/* static */
-PLDHashOperator PR_CALLBACK nsUICommandCollector::RemoveCommandEventListener(
+PLDHashOperator nsUICommandCollector::RemoveCommandEventListener(
const nsIDOMWindow* key, PRUint32 windowID, void* userArg)
{
nsCOMPtr<nsIDOMEventTarget> windowTarget =
do_QueryInterface(const_cast<nsIDOMWindow *>(key));
if (!windowTarget) {
MS_LOG(("Error casting domeventtarget"));
return PL_DHASH_NEXT;
}
--- a/extensions/metrics/src/nsUICommandCollector.h
+++ b/extensions/metrics/src/nsUICommandCollector.h
@@ -55,20 +55,20 @@ class nsUICommandCollector : public nsIO
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIOBSERVER
NS_DECL_NSIDOMEVENTLISTENER
NS_DECL_NSIMETRICSCOLLECTOR
- static PLDHashOperator PR_CALLBACK AddCommandEventListener(
+ static PLDHashOperator AddCommandEventListener(
const nsIDOMWindow* key, PRUint32 windowID, void* userArg);
- static PLDHashOperator PR_CALLBACK RemoveCommandEventListener(
+ static PLDHashOperator RemoveCommandEventListener(
const nsIDOMWindow* key, PRUint32 windowID, void* userArg);
nsUICommandCollector();
// Given a command event, determines the appropriate id and anonid values
// to log. Returns failure if no id or anonid exists for the event target.
nsresult GetEventTargets(nsIDOMEvent *event,
nsString &targetId, nsString &targetAnonId) const;
--- a/extensions/pref/system-pref/src/gconf/nsSystemPrefService.cpp
+++ b/extensions/pref/system-pref/src/gconf/nsSystemPrefService.cpp
@@ -204,17 +204,17 @@ private:
};
struct SysPrefCallbackData {
nsISupports *observer;
PRBool bIsWeakRef;
PRUint32 prefAtom;
};
-PRBool PR_CALLBACK
+PRBool
sysPrefDeleteObserver(void *aElement, void *aData) {
SysPrefCallbackData *pElement =
static_cast<SysPrefCallbackData *>(aElement);
NS_RELEASE(pElement->observer);
nsMemory::Free(pElement);
return PR_TRUE;
}
@@ -581,17 +581,17 @@ GCONF_FUNCS_POINTER_END
// are really read.
//////////////////////////////////////////////////////////////////////////////
static const PrefNamePair sPrefNameMapping[] = {
#include "gconf_pref_list.inc"
{nsnull, nsnull},
};
-PRBool PR_CALLBACK
+PRBool
gconfDeleteObserver(void *aElement, void *aData) {
nsMemory::Free(aElement);
return PR_TRUE;
}
GConfProxy::GConfProxy(nsSystemPrefService *aSysPrefService):
mGConfClient(nsnull),
mGConfLib(nsnull),
--- a/extensions/spellcheck/src/mozPersonalDictionary.cpp
+++ b/extensions/spellcheck/src/mozPersonalDictionary.cpp
@@ -150,17 +150,17 @@ NS_IMETHODIMP mozPersonalDictionary::Loa
mDirty = PR_FALSE;
return res;
}
// A little helper function to add the key to the list.
// This is not threadsafe, and only safe if the consumer does not
// modify the list.
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
AddHostToStringArray(nsUniCharEntry *aEntry, void *aArg)
{
static_cast<nsStringArray*>(aArg)->AppendString(nsDependentString(aEntry->GetKey()));
return PL_DHASH_NEXT;
}
/* void Save (); */
NS_IMETHODIMP mozPersonalDictionary::Save()
--- a/gfx/src/nsDeviceContext.cpp
+++ b/gfx/src/nsDeviceContext.cpp
@@ -65,17 +65,17 @@ DeviceContextImpl::DeviceContextImpl()
mWidget = nsnull;
mFontAliasTable = nsnull;
#ifdef NS_DEBUG
mInitialized = PR_FALSE;
#endif
}
-static PRBool PR_CALLBACK DeleteValue(nsHashKey* aKey, void* aValue, void* closure)
+static PRBool DeleteValue(nsHashKey* aKey, void* aValue, void* closure)
{
delete ((nsString*)aValue);
return PR_TRUE;
}
DeviceContextImpl::~DeviceContextImpl()
{
nsCOMPtr<nsIObserverService> obs(do_GetService("@mozilla.org/observer-service;1"));
--- a/gfx/src/thebes/nsThebesGfxFactory.cpp
+++ b/gfx/src/thebes/nsThebesGfxFactory.cpp
@@ -132,23 +132,23 @@ static const nsModuleComponentInfo compo
"@mozilla.org/gfx/region;1",
nsScriptableRegionConstructor },
{ "image frame",
GFX_IMAGEFRAME_CID,
"@mozilla.org/gfx/image/frame;2",
gfxImageFrameConstructor },
};
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
nsThebesGfxModuleCtor(nsIModule *self)
{
return gfxPlatform::Init();
}
-PR_STATIC_CALLBACK(void)
+static void
nsThebesGfxModuleDtor(nsIModule *self)
{
nsThebesDeviceContext::Shutdown();
gfxPlatform::Shutdown();
}
NS_IMPL_NSGETMODULE_WITH_CTOR_DTOR(nsGfxModule, components,
nsThebesGfxModuleCtor, nsThebesGfxModuleDtor)
--- a/gfx/tests/coverage/nsCoverage.cpp
+++ b/gfx/tests/coverage/nsCoverage.cpp
@@ -247,17 +247,17 @@ nsPoint *pointlist;
/**--------------------------------------------------------------------------------
* Main Handler
*--------------------------------------------------------------------------------
*/
-nsEventStatus PR_CALLBACK HandleEvent(nsGUIEvent *aEvent)
+nsEventStatus HandleEvent(nsGUIEvent *aEvent)
{
nsEventStatus result = nsEventStatus_eIgnore;
switch(aEvent->message) {
case NS_PAINT:
// paint the background
--- a/gfx/thebes/public/gfxWindowsPlatform.h
+++ b/gfx/thebes/public/gfxWindowsPlatform.h
@@ -118,39 +118,39 @@ private:
static int CALLBACK FontEnumProc(const ENUMLOGFONTEXW *lpelfe,
const NEWTEXTMETRICEXW *metrics,
DWORD fontType, LPARAM data);
static int CALLBACK FamilyAddStylesProc(const ENUMLOGFONTEXW *lpelfe,
const NEWTEXTMETRICEXW *nmetrics,
DWORD fontType, LPARAM data);
- static PLDHashOperator PR_CALLBACK FontGetStylesProc(nsStringHashKey::KeyType aKey,
- nsRefPtr<FontFamily>& aFontFamily,
- void* userArg);
+ static PLDHashOperator FontGetStylesProc(nsStringHashKey::KeyType aKey,
+ nsRefPtr<FontFamily>& aFontFamily,
+ void* userArg);
- static PLDHashOperator PR_CALLBACK FontGetCMapDataProc(nsStringHashKey::KeyType aKey,
- nsRefPtr<FontFamily>& aFontFamily,
- void* userArg);
+ static PLDHashOperator FontGetCMapDataProc(nsStringHashKey::KeyType aKey,
+ nsRefPtr<FontFamily>& aFontFamily,
+ void* userArg);
static int CALLBACK FontResolveProc(const ENUMLOGFONTEXW *lpelfe,
const NEWTEXTMETRICEXW *metrics,
DWORD fontType, LPARAM data);
- static PLDHashOperator PR_CALLBACK HashEnumFunc(nsStringHashKey::KeyType aKey,
- nsRefPtr<FontFamily>& aData,
- void* userArg);
+ static PLDHashOperator HashEnumFunc(nsStringHashKey::KeyType aKey,
+ nsRefPtr<FontFamily>& aData,
+ void* userArg);
- static PLDHashOperator PR_CALLBACK FindFontForCharProc(nsStringHashKey::KeyType aKey,
- nsRefPtr<FontFamily>& aFontFamily,
- void* userArg);
+ static PLDHashOperator FindFontForCharProc(nsStringHashKey::KeyType aKey,
+ nsRefPtr<FontFamily>& aFontFamily,
+ void* userArg);
virtual cmsHPROFILE GetPlatformCMSOutputProfile();
- static int PR_CALLBACK PrefChangedCallback(const char*, void*);
+ static int PrefChangedCallback(const char*, void*);
// gfxFontInfoLoader overrides, used to load in font cmaps
virtual void InitLoader();
virtual PRBool RunLoader();
virtual void FinishLoader();
FontTable mFonts;
FontTable mFontAliases;
--- a/gfx/thebes/src/gfxQuartzFontCache.h
+++ b/gfx/thebes/src/gfxQuartzFontCache.h
@@ -225,19 +225,19 @@ public:
void AddOtherFamilyName(MacOSFamilyEntry *aFamilyEntry, nsAString& aOtherFamilyName);
gfxFontEntry* LookupLocalFont(const nsAString& aFontName);
gfxFontEntry* MakePlatformFont(const gfxFontEntry *aProxyEntry, const gfxDownloadedFontData* aFontData);
private:
- static PLDHashOperator PR_CALLBACK FindFontForCharProc(nsStringHashKey::KeyType aKey,
- nsRefPtr<MacOSFamilyEntry>& aFamilyEntry,
- void* userArg);
+ static PLDHashOperator FindFontForCharProc(nsStringHashKey::KeyType aKey,
+ nsRefPtr<MacOSFamilyEntry>& aFamilyEntry,
+ void* userArg);
static gfxQuartzFontCache *sSharedFontCache;
gfxQuartzFontCache();
// initialize font lists
void InitFontList();
void ReadOtherFamilyNamesForFamily(const nsAString& aFamilyName);
@@ -255,25 +255,25 @@ private:
void InitBadUnderlineList();
// eliminate faces which have the same ATSUI id
void EliminateDuplicateFaces(const nsAString& aFamilyName);
// explicitly set font traits for all faces to fixed-pitch
void SetFixedPitch(const nsAString& aFamilyName);
- static PLDHashOperator PR_CALLBACK InitOtherFamilyNamesProc(nsStringHashKey::KeyType aKey,
- nsRefPtr<MacOSFamilyEntry>& aFamilyEntry,
- void* userArg);
+ static PLDHashOperator InitOtherFamilyNamesProc(nsStringHashKey::KeyType aKey,
+ nsRefPtr<MacOSFamilyEntry>& aFamilyEntry,
+ void* userArg);
void GenerateFontListKey(const nsAString& aKeyName, nsAString& aResult);
static void ATSNotification(ATSFontNotificationInfoRef aInfo, void* aUserArg);
- static int PR_CALLBACK PrefChangedCallback(const char *aPrefName, void *closure);
+ static int PrefChangedCallback(const char *aPrefName, void *closure);
- static PLDHashOperator PR_CALLBACK
+ static PLDHashOperator
HashEnumFuncForFamilies(nsStringHashKey::KeyType aKey,
nsRefPtr<MacOSFamilyEntry>& aFamilyEntry,
void* aUserArg);
// gfxFontInfoLoader overrides, used to load in font cmaps
virtual void InitLoader();
virtual PRBool RunLoader();
virtual void FinishLoader();
--- a/gfx/thebes/src/gfxTextRunWordCache.cpp
+++ b/gfx/thebes/src/gfxTextRunWordCache.cpp
@@ -180,17 +180,17 @@ protected:
const nsTArray<DeferredWord>& aDeferredWords,
PRBool aSuccessful);
void RemoveWord(gfxTextRun *aTextRun, PRUint32 aStart,
PRUint32 aEnd, PRUint32 aHash);
nsTHashtable<CacheHashEntry> mCache;
#ifdef DEBUG
- static PLDHashOperator PR_CALLBACK CacheDumpEntry(CacheHashEntry* aEntry, void* userArg);
+ static PLDHashOperator CacheDumpEntry(CacheHashEntry* aEntry, void* userArg);
#endif
};
static PRLogModuleInfo *gWordCacheLog = PR_NewLogModule("wordCache");
static inline PRUint32
HashMix(PRUint32 aHash, PRUnichar aCh)
{
@@ -762,17 +762,17 @@ TextRunWordCache::CacheHashEntry::HashKe
LL_L2UI(fontSetGen, aKey->mUserFontSetGeneration);
return aKey->mStringHash + fontSetGen + (long)aKey->mFontOrGroup + aKey->mAppUnitsPerDevUnit +
aKey->mIsDoubleByteText + aKey->mIsRTL*2 + aKey->mEnabledOptionalLigatures*4 +
aKey->mOptimizeSpeed*8;
}
#ifdef DEBUG
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
TextRunWordCache::CacheDumpEntry(CacheHashEntry* aEntry, void* userArg)
{
FILE* output = static_cast<FILE*>(userArg);
if (!aEntry->mTextRun) {
fprintf(output, "<EMPTY>\n");
return PL_DHASH_NEXT;
}
fprintf(output, "Word at %p:%d => ", static_cast<void*>(aEntry->mTextRun), aEntry->mWordOffset);
--- a/gfx/thebes/src/gfxWindowsPlatform.cpp
+++ b/gfx/thebes/src/gfxWindowsPlatform.cpp
@@ -70,17 +70,17 @@ static const PRUint32 kNumFontsPerSlice
static __inline void
BuildKeyNameFromFontName(nsAString &aName)
{
if (aName.Length() >= LF_FACESIZE)
aName.Truncate(LF_FACESIZE - 1);
ToLowerCase(aName);
}
-int PR_CALLBACK
+int
gfxWindowsPlatform::PrefChangedCallback(const char *aPrefName, void *closure)
{
// XXX this could be made to only clear out the cache for the prefs that were changed
// but it probably isn't that big a deal.
gfxWindowsPlatform *plat = static_cast<gfxWindowsPlatform *>(closure);
plat->mPrefFonts.Clear();
return 0;
}
@@ -149,17 +149,17 @@ gfxWindowsPlatform::FontEnumProc(const E
struct FontListData {
FontListData(const nsACString& aLangGroup, const nsACString& aGenericFamily, nsStringArray& aListOfFonts) :
mLangGroup(aLangGroup), mGenericFamily(aGenericFamily), mStringArray(aListOfFonts) {}
const nsACString& mLangGroup;
const nsACString& mGenericFamily;
nsStringArray& mStringArray;
};
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
gfxWindowsPlatform::HashEnumFunc(nsStringHashKey::KeyType aKey,
nsRefPtr<FontFamily>& aFontFamily,
void* userArg)
{
FontListData *data = (FontListData*)userArg;
// use the first variation for now. This data should be the same
// for all the variations and should probably be moved up to
@@ -279,19 +279,19 @@ gfxWindowsPlatform::UpdateFontList()
return NS_OK;
}
struct FontFamilyListData {
FontFamilyListData(nsTArray<nsRefPtr<FontFamily> >& aFamilyArray)
: mFamilyArray(aFamilyArray)
{}
- static PLDHashOperator PR_CALLBACK AppendFamily(nsStringHashKey::KeyType aKey,
- nsRefPtr<FontFamily>& aFamilyEntry,
- void *aUserArg)
+ static PLDHashOperator AppendFamily(nsStringHashKey::KeyType aKey,
+ nsRefPtr<FontFamily>& aFamilyEntry,
+ void *aUserArg)
{
FontFamilyListData *data = (FontFamilyListData*)aUserArg;
data->mFamilyArray.AppendElement(aFamilyEntry);
return PL_DHASH_NEXT;
}
nsTArray<nsRefPtr<FontFamily> >& mFamilyArray;
};
@@ -438,17 +438,17 @@ struct FontSearch {
ch(aCh), fontToMatch(aFont), matchRank(-1) {
}
PRUint32 ch;
nsRefPtr<gfxWindowsFont> fontToMatch;
PRInt32 matchRank;
nsRefPtr<FontEntry> bestMatch;
};
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
gfxWindowsPlatform::FindFontForCharProc(nsStringHashKey::KeyType aKey,
nsRefPtr<FontFamily>& aFontFamily,
void* userArg)
{
FontSearch *data = (FontSearch*)userArg;
const PRUint32 ch = data->ch;
--- a/intl/locale/src/nsLocale.h
+++ b/intl/locale/src/nsLocale.h
@@ -70,20 +70,20 @@ public:
/* Declare methods from nsILocale */
NS_DECL_NSILOCALE
protected:
NS_IMETHOD AddCategory(const nsAString& category, const nsAString& value);
- static PLHashNumber PR_CALLBACK Hash_HashFunction(const void* key);
- static PRIntn PR_CALLBACK Hash_CompareNSString(const void* s1, const void* s2);
- static PRIntn PR_CALLBACK Hash_EnumerateDelete(PLHashEntry *he, PRIntn hashIndex, void *arg);
- static PRIntn PR_CALLBACK Hash_EnumerateCopy(PLHashEntry *he, PRIntn hashIndex, void *arg);
+ static PLHashNumber Hash_HashFunction(const void* key);
+ static PRIntn Hash_CompareNSString(const void* s1, const void* s2);
+ static PRIntn Hash_EnumerateDelete(PLHashEntry *he, PRIntn hashIndex, void *arg);
+ static PRIntn Hash_EnumerateCopy(PLHashEntry *he, PRIntn hashIndex, void *arg);
PLHashTable* fHashtable;
PRUint32 fCategoryCount;
};
#endif
--- a/ipc/ipcd/client/src/ipcConnectionUnix.cpp
+++ b/ipc/ipcd/client/src/ipcConnectionUnix.cpp
@@ -295,17 +295,17 @@ ConnWrite(ipcConnectionState *s)
}
}
}
PR_Unlock(s->lock);
return rv;
}
-PR_STATIC_CALLBACK(void)
+static void
ConnThread(void *arg)
{
PRInt32 num;
nsresult rv = NS_OK;
ipcConnectionState *s = (ipcConnectionState *) arg;
// we monitor two file descriptors in this thread. the first (at index 0) is
--- a/ipc/ipcd/client/src/ipcModuleFactory.cpp
+++ b/ipc/ipcd/client/src/ipcModuleFactory.cpp
@@ -170,23 +170,23 @@ static const nsModuleComponentInfo compo
ipcDConnectServiceConstructor,
ipcDConnectServiceRegisterProc,
ipcDConnectServiceUnregisterProc },
#endif
};
//-----------------------------------------------------------------------------
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
ipcdclient_init(nsIModule *module)
{
return IPC_Init();
}
-PR_STATIC_CALLBACK(void)
+static void
ipcdclient_shutdown(nsIModule *module)
{
IPC_Shutdown();
}
//-----------------------------------------------------------------------------
// Implement the NSGetModule() exported function for your module
// and the entire implementation of the module object.
--- a/ipc/ipcd/client/src/ipcdclient.cpp
+++ b/ipc/ipcd/client/src/ipcdclient.cpp
@@ -981,17 +981,17 @@ end:
PR_Close(writable);
if (attr)
PR_DestroyProcessAttr(attr);
return rv;
}
/* ------------------------------------------------------------------------- */
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
EnumerateTargetMapAndNotify(const nsID &aKey,
ipcTargetData *aData,
void *aClosure)
{
nsAutoMonitor mon(aData->monitor);
// wake up anyone waiting on this target.
mon.NotifyAll();
--- a/ipc/ipcd/extensions/dconnect/src/ipcDConnectService.cpp
+++ b/ipc/ipcd/extensions/dconnect/src/ipcDConnectService.cpp
@@ -1325,17 +1325,17 @@ SetupPeerInstance(PRUint32 aPeerID, DCon
}
while (NS_SUCCEEDED(rv) && *aInstancePtr == nsnull);
return rv;
}
//-----------------------------------------------------------------------------
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
DestroyDConnectInstance(const void *key,
DConnectInstance *wrapper,
void *userArg)
{
delete wrapper;
return PL_DHASH_NEXT;
}
--- a/ipc/ipcd/extensions/lock/src/module/ipcLockModule.cpp
+++ b/ipc/ipcd/extensions/lock/src/module/ipcLockModule.cpp
@@ -79,35 +79,35 @@ struct ipcLockContext
ipcLockContext(PRUint32 ownerID)
: mOwnerID(ownerID)
, mNextPending(NULL) {}
};
//-----------------------------------------------------------------------------
-PR_STATIC_CALLBACK(void *)
+static void *
ipcLockModule_AllocTable(void *pool, PRSize size)
{
return malloc(size);
}
-PR_STATIC_CALLBACK(void)
+static void
ipcLockModule_FreeTable(void *pool, void *item)
{
free(item);
}
-PR_STATIC_CALLBACK(PLHashEntry *)
+static PLHashEntry *
ipcLockModule_AllocEntry(void *pool, const void *key)
{
return (PLHashEntry *) malloc(sizeof(PLHashEntry));
}
-PR_STATIC_CALLBACK(void)
+static void
ipcLockModule_FreeEntry(void *pool, PLHashEntry *he, PRUintn flag)
{
PL_strfree((char *) he->key);
free(he);
}
static const PLHashAllocOps ipcLockModule_AllocOps = {
ipcLockModule_AllocTable,
@@ -221,17 +221,17 @@ ipcLockModule_ReleaseLock(PRUint32 cid,
ipcLockContext *ctx;
ctx = (ipcLockContext *) PL_HashTableLookup(gLockTable, key);
if (ctx && ipcLockModule_ReleaseLockHelper(cid, key, ctx))
PL_HashTableRemove(gLockTable, key);
}
-PR_STATIC_CALLBACK(PRIntn)
+static PRIntn
ipcLockModule_ReleaseByCID(PLHashEntry *he, PRIntn i, void *arg)
{
PRUint32 cid = *(PRUint32 *) arg;
ipcLockContext *ctx = (ipcLockContext *) he->value;
if (ctx->mOwnerID != cid)
return HT_ENUMERATE_NEXT;
--- a/ipc/ipcd/extensions/lock/test/TestIPCLocks.cpp
+++ b/ipc/ipcd/extensions/lock/test/TestIPCLocks.cpp
@@ -94,17 +94,17 @@ static void RandomSleep(PRUint32 fromMS,
{
PRUint32 ms = fromMS + (PRUint32) ((toMS - fromMS) * ((double) rand() / RAND_MAX));
//LOG("putting thread to sleep for %u ms\n", ms);
PR_Sleep(PR_MillisecondsToInterval(ms));
}
static ipcILockService *gLockService;
-PR_STATIC_CALLBACK(void) TestThread(void *arg)
+static void TestThread(void *arg)
{
const char *lockName = (const char *) arg;
LOG("entering TestThread [lock=%s]\n", lockName);
nsresult rv;
RandomSleep(1000, 1100);
--- a/jpeg/jmorecfg.h
+++ b/jpeg/jmorecfg.h
@@ -211,17 +211,17 @@ typedef unsigned int JDIMENSION;
/* Mozilla mod: make external functions be DLL-able via JRI_PUBLIC_API(),
* and supply extern "C" for C++ users of the C-compiled IJG library.
* (Well, not anymore, but there's still a modification here.)
*/
#include "prtypes.h"
/* a function called through method pointers: */
-#define METHODDEF(type) static type PR_CALLBACK
+#define METHODDEF(type) static type
/* a function used only in its module: */
#define LOCAL(type) static type
PR_BEGIN_EXTERN_C
#define GLOBAL(type) type
#define EXTERN(type) extern type
PR_END_EXTERN_C
--- a/js/jsd/jsd_java.c
+++ b/js/jsd/jsd_java.c
@@ -134,17 +134,17 @@ static Hnetscape_jsdebug_Script*
{
JHandle* tbl = (JHandle*) unhand(controller)->scriptTable;
JHandle* key = _constructInteger(ee,(long)jsdscript);
return (Hnetscape_jsdebug_Script*) _getHash( ee, tbl, key );
}
/***************************************************************************/
-void PR_CALLBACK
+void
_scriptHook( JSDContext* jsdc,
JSDScript* jsdscript,
JSBool creating,
void* callerdata )
{
Hnetscape_jsdebug_Script* script;
ExecEnv* ee = EE();
@@ -216,17 +216,17 @@ void PR_CALLBACK
/* set the Script as invalid */
execute_java_dynamic_method( ee,(JHandle*)script,
"_setInvalid",
"()V" );
}
}
/***************************************************************************/
-PRUintn PR_CALLBACK
+PRUintn
_executionHook( JSDContext* jsdc,
JSDThreadState* jsdstate,
PRUintn type,
void* callerdata )
{
Hnetscape_jsdebug_JSThreadState* threadState;
Hnetscape_jsdebug_Script* script;
JHandle* pcOb;
@@ -335,17 +335,17 @@ PRUintn PR_CALLBACK
if( netscape_jsdebug_JSThreadState_DEBUG_STATE_THROW ==
unhand(threadState)->continueState )
return JSD_HOOK_RETURN_ABORT;
return JSD_HOOK_RETURN_CONTINUE;
}
-PRUintn PR_CALLBACK
+PRUintn
_errorReporter( JSDContext* jsdc,
JSContext* cx,
const char* message,
JSErrorReport* report,
void* callerdata )
{
JHandle* reporter;
JHandle* msg = NULL;
--- a/js/src/prmjtime.cpp
+++ b/js/src/prmjtime.cpp
@@ -224,17 +224,17 @@ NowCalibrate()
}
}
#define CALIBRATIONLOCK_SPINCOUNT 0
#define DATALOCK_SPINCOUNT 4096
#define LASTLOCK_SPINCOUNT 4096
#ifdef JS_THREADSAFE
-static PRStatus PR_CALLBACK
+static PRStatus
NowInit(void)
{
memset(&calibration, 0, sizeof(calibration));
NowCalibrate();
InitializeCriticalSectionAndSpinCount(&calibration.calibration_lock, CALIBRATIONLOCK_SPINCOUNT);
InitializeCriticalSectionAndSpinCount(&calibration.data_lock, DATALOCK_SPINCOUNT);
return PR_SUCCESS;
}
--- a/js/src/xpconnect/src/xpcjsruntime.cpp
+++ b/js/src/xpconnect/src/xpcjsruntime.cpp
@@ -323,17 +323,17 @@ void XPCJSRuntime::TraceJS(JSTracer* trc
if(self->GetXPConnect()->ShouldTraceRoots())
{
// Only trace these if we're not cycle-collecting, the cycle collector
// will do that if we are.
self->TraceXPConnectRoots(trc);
}
}
-PR_STATIC_CALLBACK(void)
+static void
TraceJSObject(PRUint32 aLangID, void *aScriptThing, void *aClosure)
{
if(aLangID == nsIProgrammingLanguage::JAVASCRIPT)
{
JS_CALL_TRACER(static_cast<JSTracer*>(aClosure), aScriptThing,
js_GetGCThingTraceKind(aScriptThing),
"JSObjectHolder");
}
--- a/js/src/xpconnect/src/xpcmodule.cpp
+++ b/js/src/xpconnect/src/xpcmodule.cpp
@@ -103,34 +103,34 @@ static const nsModuleComponentInfo compo
#endif
#endif
#ifdef XPC_IDISPATCH_SUPPORT
,{ nsnull, NS_IDISPATCH_SUPPORT_CID, NS_IDISPATCH_SUPPORT_CONTRACTID,
nsIDispatchSupportConstructor }
#endif
};
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
xpcModuleCtor(nsIModule* self)
{
nsXPConnect::InitStatics();
nsXPCException::InitStatics();
XPCWrappedNativeScope::InitStatics();
XPCPerThreadData::InitStatics();
nsJSRuntimeServiceImpl::InitStatics();
nsXPCThreadJSContextStackImpl::InitStatics();
#ifdef XPC_IDISPATCH_SUPPORT
XPCIDispatchExtension::InitStatics();
#endif
return NS_OK;
}
-PR_STATIC_CALLBACK(void)
+static void
xpcModuleDtor(nsIModule* self)
{
// Release our singletons
nsXPConnect::ReleaseXPConnectSingleton();
nsXPCThreadJSContextStackImpl::FreeSingleton();
nsJSRuntimeServiceImpl::FreeSingleton();
xpc_DestroyJSxIDClassObjects();
#ifdef XPC_IDISPATCH_SUPPORT
--- a/js/src/xpconnect/src/xpcthreadcontext.cpp
+++ b/js/src/xpconnect/src/xpcthreadcontext.cpp
@@ -529,17 +529,17 @@ XPCPerThreadData::~XPCPerThreadData()
if(gLock && !gThreads)
{
PR_DestroyLock(gLock);
gLock = nsnull;
}
}
-PR_STATIC_CALLBACK(void)
+static void
xpc_ThreadDataDtorCB(void* ptr)
{
XPCPerThreadData* data = (XPCPerThreadData*) ptr;
if(data)
delete data;
}
void XPCPerThreadData::TraceJS(JSTracer *trc)
--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -13194,17 +13194,17 @@ nsCSSFrameConstructor::RestyleForRemove(
}
break;
}
}
}
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
CollectRestyles(nsISupports* aContent,
nsCSSFrameConstructor::RestyleData& aData,
void* aRestyleArrayPtr)
{
nsCSSFrameConstructor::RestyleEnumerateData** restyleArrayPtr =
static_cast<nsCSSFrameConstructor::RestyleEnumerateData**>
(aRestyleArrayPtr);
nsCSSFrameConstructor::RestyleEnumerateData* currentRestyle =
--- a/layout/base/nsCSSFrameConstructor.h
+++ b/layout/base/nsCSSFrameConstructor.h
@@ -70,17 +70,17 @@ class nsIFrame;
struct nsGenConInitializer;
struct nsFindFrameHint
{
nsIFrame *mPrimaryFrameForPrevSibling; // weak ref to the primary frame for the content for which we need a frame
nsFindFrameHint() : mPrimaryFrameForPrevSibling(nsnull) { }
};
-typedef void (PR_CALLBACK nsLazyFrameConstructionCallback)
+typedef void (nsLazyFrameConstructionCallback)
(nsIContent* aContent, nsIFrame* aFrame, void* aArg);
class nsFrameConstructorState;
class nsFrameConstructorSaveState;
class nsCSSFrameConstructor
{
public:
--- a/layout/base/nsCounterManager.cpp
+++ b/layout/base/nsCounterManager.cpp
@@ -280,17 +280,17 @@ nsCounterManager::CounterListFor(const n
if (!mNames.Put(aCounterName, counterList)) {
delete counterList;
return nsnull;
}
}
return counterList;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
RecalcDirtyLists(const nsAString& aKey, nsCounterList* aList, void* aClosure)
{
if (aList->IsDirty())
aList->RecalcAll();
return PL_DHASH_NEXT;
}
void
@@ -305,17 +305,17 @@ struct DestroyNodesData {
, mDestroyedAny(PR_FALSE)
{
}
nsIFrame *mFrame;
PRBool mDestroyedAny;
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
DestroyNodesInList(const nsAString& aKey, nsCounterList* aList, void* aClosure)
{
DestroyNodesData *data = static_cast<DestroyNodesData*>(aClosure);
if (aList->DestroyNodesFor(data->mFrame)) {
data->mDestroyedAny = PR_TRUE;
aList->SetDirty();
}
return PL_DHASH_NEXT;
@@ -325,17 +325,17 @@ PRBool
nsCounterManager::DestroyNodesFor(nsIFrame *aFrame)
{
DestroyNodesData data(aFrame);
mNames.EnumerateRead(DestroyNodesInList, &data);
return data.mDestroyedAny;
}
#ifdef DEBUG
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
DumpList(const nsAString& aKey, nsCounterList* aList, void* aClosure)
{
printf("Counter named \"%s\":\n", NS_ConvertUTF16toUTF8(aKey).get());
nsCounterNode *node = aList->First();
if (node) {
PRInt32 i = 0;
do {
--- a/layout/base/nsDocumentViewer.cpp
+++ b/layout/base/nsDocumentViewer.cpp
@@ -2062,25 +2062,25 @@ DocumentViewerImpl::RequestWindowClose(P
mDeferredWindowClose = PR_TRUE;
} else
#endif
*aCanClose = PR_TRUE;
return NS_OK;
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
AppendAgentSheet(nsIStyleSheet *aSheet, void *aData)
{
nsStyleSet *styleSet = static_cast<nsStyleSet*>(aData);
styleSet->AppendStyleSheet(nsStyleSet::eAgentSheet, aSheet);
return PR_TRUE;
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
PrependUserSheet(nsIStyleSheet *aSheet, void *aData)
{
nsStyleSet *styleSet = static_cast<nsStyleSet*>(aData);
styleSet->PrependStyleSheet(nsStyleSet::eUserSheet, aSheet);
return PR_TRUE;
}
nsresult
--- a/layout/base/nsFrameManager.cpp
+++ b/layout/base/nsFrameManager.cpp
@@ -121,17 +121,17 @@
//----------------------------------------------------------------------
struct PlaceholderMapEntry : public PLDHashEntryHdr {
// key (the out of flow frame) can be obtained through placeholder frame
nsPlaceholderFrame *placeholderFrame;
};
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
PlaceholderMapMatchEntry(PLDHashTable *table, const PLDHashEntryHdr *hdr,
const void *key)
{
const PlaceholderMapEntry *entry =
static_cast<const PlaceholderMapEntry*>(hdr);
NS_ASSERTION(entry->placeholderFrame->GetOutOfFlowFrame() !=
(void*)0xdddddddd,
"Dead placeholder in placeholder map");
@@ -158,17 +158,17 @@ struct PrimaryFrameMapEntry : public PLD
// entry.
nsIContent *content;
nsIFrame *frame;
};
// These ops should be used if/when we switch back to a 2-word entry.
// See comment in |PrimaryFrameMapEntry| above.
#if 0
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
PrimaryFrameMapMatchEntry(PLDHashTable *table, const PLDHashEntryHdr *hdr,
const void *key)
{
const PrimaryFrameMapEntry *entry =
static_cast<const PrimaryFrameMapEntry*>(hdr);
return entry->frame->GetContent() == key;
}
@@ -516,17 +516,17 @@ nsFrameManager::UnregisterPlaceholderFra
if (mPlaceholderMap.ops) {
PL_DHashTableOperate(&mPlaceholderMap,
aPlaceholderFrame->GetOutOfFlowFrame(),
PL_DHASH_REMOVE);
}
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
UnregisterPlaceholders(PLDHashTable* table, PLDHashEntryHdr* hdr,
PRUint32 number, void* arg)
{
PlaceholderMapEntry* entry = static_cast<PlaceholderMapEntry*>(hdr);
entry->placeholderFrame->SetOutOfFlowFrame(nsnull);
return PL_DHASH_NEXT;
}
@@ -1823,17 +1823,17 @@ nsFrameManagerBase::UndisplayedMap::Remo
UndisplayedNode* node = (UndisplayedNode*)((*entry)->value);
NS_ASSERTION(node, "null node for non-null entry in UndisplayedMap");
delete node;
PL_HashTableRawRemove(mTable, entry, *entry);
mLastLookup = nsnull; // hashtable may have shifted bucket out from under us
}
}
-PR_STATIC_CALLBACK(PRIntn)
+static PRIntn
RemoveUndisplayedEntry(PLHashEntry* he, PRIntn i, void* arg)
{
UndisplayedNode* node = (UndisplayedNode*)(he->value);
delete node;
// Remove and free this entry and continue enumerating
return HT_ENUMERATE_REMOVE | HT_ENUMERATE_NEXT;
}
--- a/layout/base/nsIFocusEventSuppressor.h
+++ b/layout/base/nsIFocusEventSuppressor.h
@@ -34,17 +34,17 @@
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef nsIFocusEventSuppressor_h___
#define nsIFocusEventSuppressor_h___
#include "nsISupports.h"
-typedef void (*PR_CALLBACK nsFocusEventSuppressorCallback)(PRBool aSuppress);
+typedef void (* nsFocusEventSuppressorCallback)(PRBool aSuppress);
#define NS_NSIFOCUSEVENTSUPPRESSORSERVICE_IID \
{ 0x8aae5cee, 0x59ab, 0x42d4, \
{ 0xa3, 0x76, 0xbf, 0x63, 0x54, 0x04, 0xc7, 0x98 } }
class nsIFocusEventSuppressorService : public nsISupports
{
public:
--- a/layout/base/nsPresContext.cpp
+++ b/layout/base/nsPresContext.cpp
@@ -106,17 +106,17 @@ MakeColorPref(const char *colstr)
// 4.x stored RGB color values as a string rather than as an int,
// thus we need to do this conversion
PR_sscanf(colstr, "#%02x%02x%02x", &red, &green, &blue);
colorref = NS_RGB(red, green, blue);
return colorref;
}
-int PR_CALLBACK
+int
nsPresContext::PrefChangedCallback(const char* aPrefName, void* instance_data)
{
nsPresContext* presContext = (nsPresContext*)instance_data;
NS_ASSERTION(nsnull != presContext, "bad instance data");
if (nsnull != presContext) {
presContext->PreferenceChanged(aPrefName);
}
@@ -144,17 +144,17 @@ IsVisualCharset(const nsCString& aCharse
}
else {
return PR_FALSE; // logical text type
}
}
#endif // IBMBIDI
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
destroy_loads(const void * aKey, nsCOMPtr<nsImageLoader>& aData, void* closure)
{
aData->Destroy();
return PL_DHASH_NEXT;
}
static NS_DEFINE_CID(kLookAndFeelCID, NS_LOOKANDFEEL_CID);
#include "nsContentCID.h"
@@ -293,17 +293,17 @@ NS_IMPL_CYCLE_COLLECTION_CLASS(nsPresCon
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsPresContext)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIObserver)
NS_INTERFACE_MAP_ENTRY(nsIObserver)
NS_INTERFACE_MAP_END
NS_IMPL_CYCLE_COLLECTING_ADDREF(nsPresContext)
NS_IMPL_CYCLE_COLLECTING_RELEASE(nsPresContext)
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
TraverseImageLoader(const void * aKey, nsCOMPtr<nsImageLoader>& aData,
void* aClosure)
{
nsCycleCollectionTraversalCallback *cb =
static_cast<nsCycleCollectionTraversalCallback*>(aClosure);
cb->NoteXPCOMChild(aData);
@@ -1022,17 +1022,17 @@ static void SetImgAnimModeOnImgReq(imgIR
aImgReq->GetImage(getter_AddRefs(imgCon));
if (imgCon) {
imgCon->SetAnimationMode(aMode);
}
}
}
// Enumeration call back for HashTable
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
set_animation_mode(const void * aKey, nsCOMPtr<nsImageLoader>& aData, void* closure)
{
imgIRequest* imgReq = aData->GetRequest();
SetImgAnimModeOnImgReq(imgReq, (PRUint16)NS_PTR_TO_INT32(closure));
return PL_DHASH_NEXT;
}
// IMPORTANT: Assumption is that all images for a Presentation
--- a/layout/base/nsPresContext.h
+++ b/layout/base/nsPresContext.h
@@ -752,20 +752,20 @@ protected:
friend class nsRunnableMethod<nsPresContext>;
NS_HIDDEN_(void) ThemeChangedInternal();
NS_HIDDEN_(void) SysColorChangedInternal();
NS_HIDDEN_(void) SetImgAnimations(nsIContent *aParent, PRUint16 aMode);
NS_HIDDEN_(void) GetDocumentColorPreferences();
NS_HIDDEN_(void) PreferenceChanged(const char* aPrefName);
- static NS_HIDDEN_(int) PR_CALLBACK PrefChangedCallback(const char*, void*);
+ static NS_HIDDEN_(int) PrefChangedCallback(const char*, void*);
NS_HIDDEN_(void) UpdateAfterPreferencesChanged();
- static NS_HIDDEN_(void) PR_CALLBACK PrefChangedUpdateTimerCallback(nsITimer *aTimer, void *aClosure);
+ static NS_HIDDEN_(void) PrefChangedUpdateTimerCallback(nsITimer *aTimer, void *aClosure);
NS_HIDDEN_(void) GetUserPreferences();
NS_HIDDEN_(void) GetFontPreferences();
NS_HIDDEN_(void) UpdateCharSet(const nsAFlatCString& aCharSet);
// IMPORTANT: The ownership implicit in the following member variables
// has been explicitly checked. If you add any members to this class,
--- a/layout/base/nsPresShell.cpp
+++ b/layout/base/nsPresShell.cpp
@@ -370,36 +370,36 @@ public:
void SetDumpFrameCounts(PRBool aVal) { mDumpFrameCounts = aVal; }
void SetDumpFrameByFrameCounts(PRBool aVal) { mDumpFrameByFrameCounts = aVal; }
void SetPaintFrameCounts(PRBool aVal) { mPaintFrameByFrameCounts = aVal; }
protected:
void DisplayTotals(PRUint32 aTotal, PRUint32 * aDupArray, char * aTitle);
void DisplayHTMLTotals(PRUint32 aTotal, PRUint32 * aDupArray, char * aTitle);
- PR_STATIC_CALLBACK(PRIntn) RemoveItems(PLHashEntry *he, PRIntn i, void *arg);
- PR_STATIC_CALLBACK(PRIntn) RemoveIndiItems(PLHashEntry *he, PRIntn i, void *arg);
+ static PRIntn RemoveItems(PLHashEntry *he, PRIntn i, void *arg);
+ static PRIntn RemoveIndiItems(PLHashEntry *he, PRIntn i, void *arg);
void CleanUp();
// stdout Output Methods
- PR_STATIC_CALLBACK(PRIntn) DoSingleTotal(PLHashEntry *he, PRIntn i, void *arg);
- PR_STATIC_CALLBACK(PRIntn) DoSingleIndi(PLHashEntry *he, PRIntn i, void *arg);
+ static PRIntn DoSingleTotal(PLHashEntry *he, PRIntn i, void *arg);
+ static PRIntn DoSingleIndi(PLHashEntry *he, PRIntn i, void *arg);
void DoGrandTotals();
void DoIndiTotalsTree();
// HTML Output Methods
- PR_STATIC_CALLBACK(PRIntn) DoSingleHTMLTotal(PLHashEntry *he, PRIntn i, void *arg);
+ static PRIntn DoSingleHTMLTotal(PLHashEntry *he, PRIntn i, void *arg);
void DoGrandHTMLTotals();
// Zero Out the Totals
- PR_STATIC_CALLBACK(PRIntn) DoClearTotals(PLHashEntry *he, PRIntn i, void *arg);
+ static PRIntn DoClearTotals(PLHashEntry *he, PRIntn i, void *arg);
// Displays the Diff Totals
- PR_STATIC_CALLBACK(PRIntn) DoDisplayDiffTotals(PLHashEntry *he, PRIntn i, void *arg);
+ static PRIntn DoDisplayDiffTotals(PLHashEntry *he, PRIntn i, void *arg);
PLHashTable * mCounts;
PLHashTable * mIndiFrameCounts;
FILE * mFD;
PRBool mDumpFrameCounts;
PRBool mDumpFrameByFrameCounts;
PRBool mPaintFrameByFrameCounts;
@@ -6064,17 +6064,17 @@ StopVideoInstance(PresShell *aShell, nsI
nsIAtom* frameType = frame->GetType();
if (frameType == nsGkAtoms::HTMLVideoFrame) {
frame->Freeze();
}
}
#endif
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
FreezeSubDocument(nsIDocument *aDocument, void *aData)
{
nsIPresShell *shell = aDocument->GetPrimaryShell();
if (shell)
shell->Freeze();
return PR_TRUE;
}
@@ -6119,17 +6119,17 @@ StartVideoInstance(PresShell *aShell, ns
nsIAtom* frameType = frame->GetType();
if (frameType == nsGkAtoms::HTMLVideoFrame) {
frame->Thaw();
}
}
#endif
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
ThawSubDocument(nsIDocument *aDocument, void *aData)
{
nsIPresShell *shell = aDocument->GetPrimaryShell();
if (shell)
shell->Thaw();
return PR_TRUE;
}
@@ -6478,19 +6478,19 @@ PresShell::ClearReflowEventStatus()
#ifdef MOZ_XUL
/*
* It's better to add stuff to the |DidSetStyleContext| method of the
* relevant frames than adding it here. These methods should (ideally,
* anyway) go away.
*/
// Return value says whether to walk children.
-typedef PRBool (* PR_CALLBACK frameWalkerFn)(nsIFrame *aFrame, void *aClosure);
+typedef PRBool (* frameWalkerFn)(nsIFrame *aFrame, void *aClosure);
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
ReResolveMenusAndTrees(nsIFrame *aFrame, void *aClosure)
{
// Trees have a special style cache that needs to be flushed when
// the theme changes.
nsCOMPtr<nsITreeBoxObject> treeBox(do_QueryInterface(aFrame));
if (treeBox)
treeBox->ClearStyleAndImageCaches();
@@ -6498,17 +6498,17 @@ ReResolveMenusAndTrees(nsIFrame *aFrame,
// sub-content, since doing so slows menus to a crawl. That means we
// have to special-case them on a skin switch, and ensure that the
// popup frames just get destroyed completely.
if (aFrame && aFrame->GetType() == nsGkAtoms::menuFrame)
(static_cast<nsMenuFrame *>(aFrame))->CloseMenu(PR_TRUE);
return PR_TRUE;
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
ReframeImageBoxes(nsIFrame *aFrame, void *aClosure)
{
nsStyleChangeList *list = static_cast<nsStyleChangeList*>(aClosure);
if (aFrame->GetType() == nsGkAtoms::imageBoxFrame) {
list->AppendChange(aFrame, aFrame->GetContent(),
NS_STYLE_HINT_FRAMECHANGE);
return PR_FALSE; // don't walk descendants
}
--- a/layout/build/nsLayoutModule.cpp
+++ b/layout/build/nsLayoutModule.cpp
@@ -253,17 +253,17 @@ static NS_DEFINE_CID(kWindowCommandTable
NS_IMETHODIMP
NS_NewXULContentBuilder(nsISupports* aOuter, REFNSIID aIID, void** aResult);
NS_IMETHODIMP
NS_NewXULTreeBuilder(nsISupports* aOuter, REFNSIID aIID, void** aResult);
#endif
-PR_STATIC_CALLBACK(nsresult) Initialize(nsIModule* aSelf);
+static nsresult Initialize(nsIModule* aSelf);
static void Shutdown();
#ifdef MOZ_XTF
#include "nsIXTFService.h"
#include "nsIXMLContentBuilder.h"
#endif
#include "nsGeolocation.h"
@@ -321,17 +321,17 @@ LayoutShutdownObserver::Observe(nsISuppo
//-----------------------------------------------------------------------------
static PRBool gInitialized = PR_FALSE;
// Perform our one-time intialization for this module
// static
-nsresult PR_CALLBACK
+nsresult
Initialize(nsIModule* aSelf)
{
NS_PRECONDITION(!gInitialized, "module already initialized");
if (gInitialized) {
return NS_OK;
}
NS_ASSERTION(sizeof(PtrBits) == sizeof(void *),
--- a/layout/generic/nsFrameList.cpp
+++ b/layout/generic/nsFrameList.cpp
@@ -322,18 +322,17 @@ nsFrameList::GetLength() const
nsIFrame* frame = mFirstChild;
while (frame) {
count++;
frame = frame->GetNextSibling();
}
return count;
}
-static int PR_CALLBACK CompareByContentOrder(const void* aF1, const void* aF2,
- void* aDummy)
+static int CompareByContentOrder(const void* aF1, const void* aF2, void* aDummy)
{
const nsIFrame* f1 = static_cast<const nsIFrame*>(aF1);
const nsIFrame* f2 = static_cast<const nsIFrame*>(aF2);
if (f1->GetContent() != f2->GetContent()) {
return nsLayoutUtils::CompareTreePosition(f1->GetContent(), f2->GetContent());
}
if (f1 == f2) {
--- a/layout/generic/nsHTMLReflowState.cpp
+++ b/layout/generic/nsHTMLReflowState.cpp
@@ -1541,17 +1541,17 @@ nsHTMLReflowState::ComputeContainingBloc
mStylePosition->mHeight.GetUnit() == eStyleUnit_Percent) {
aContainingBlockHeight = CalcQuirkContainingBlockHeight(aContainingBlockRS);
}
}
}
}
// Prefs callback to pick up changes
-PR_STATIC_CALLBACK(int)
+static int
PrefsChanged(const char *aPrefName, void *instance)
{
sBlinkIsAllowed =
nsContentUtils::GetBoolPref("browser.blink_allowed", sBlinkIsAllowed);
return 0; /* PREF_OK */
}
--- a/layout/generic/nsIntervalSet.h
+++ b/layout/generic/nsIntervalSet.h
@@ -41,20 +41,20 @@
#ifndef nsIntervalSet_h___
#define nsIntervalSet_h___
#include "prtypes.h"
#include "nsCoord.h"
#include "nsDebug.h"
typedef void *
-(* PR_CALLBACK IntervalSetAlloc)(size_t aBytes, void *aClosure);
+(* IntervalSetAlloc)(size_t aBytes, void *aClosure);
typedef void
-(* PR_CALLBACK IntervalSetFree) (size_t aBytes, void *aPtr, void *aClosure);
+(* IntervalSetFree) (size_t aBytes, void *aPtr, void *aClosure);
/*
* A list-based class (hopefully tree-based when I get around to it)
* for representing a set of ranges on a number-line.
*/
class nsIntervalSet {
public:
--- a/layout/generic/nsSpaceManager.cpp
+++ b/layout/generic/nsSpaceManager.cpp
@@ -86,24 +86,24 @@ nsSpaceManager::BandList::Clear()
PR_INIT_CLIST(this);
}
}
/////////////////////////////////////////////////////////////////////////////
// PresShell Arena allocate callback (for nsIntervalSet use below)
-PR_STATIC_CALLBACK(void*)
+static void*
PSArenaAllocCB(size_t aSize, void* aClosure)
{
return static_cast<nsIPresShell*>(aClosure)->AllocateFrame(aSize);
}
// PresShell Arena free callback (for nsIntervalSet use below)
-PR_STATIC_CALLBACK(void)
+static void
PSArenaFreeCB(size_t aSize, void* aPtr, void* aClosure)
{
static_cast<nsIPresShell*>(aClosure)->FreeFrame(aSize, aPtr);
}
/////////////////////////////////////////////////////////////////////////////
// nsSpaceManager
--- a/layout/style/nsCSSLoader.cpp
+++ b/layout/style/nsCSSLoader.cpp
@@ -328,17 +328,17 @@ CSSLoaderImpl::SetCaseSensitive(PRBool a
NS_IMETHODIMP
CSSLoaderImpl::SetCompatibilityMode(nsCompatibility aCompatMode)
{
mCompatMode = aCompatMode;
return NS_OK;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
CollectNonAlternates(nsURIAndPrincipalHashKey *aKey,
SheetLoadData* &aData,
void* aClosure)
{
NS_PRECONDITION(aData, "Must have a data");
NS_PRECONDITION(aClosure, "Must have an array");
// Note that we don't want to affect what the selected style set is,
@@ -2141,17 +2141,17 @@ nsresult NS_NewCSSLoader(nsICSSLoader**
{
CSSLoaderImpl* it = new CSSLoaderImpl();
NS_ENSURE_TRUE(it, NS_ERROR_OUT_OF_MEMORY);
return CallQueryInterface(it, aLoader);
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
StopLoadingSheetCallback(nsURIAndPrincipalHashKey* aKey,
SheetLoadData*& aData,
void* aClosure)
{
NS_PRECONDITION(aData, "Must have a data!");
NS_PRECONDITION(aClosure, "Must have a loader");
aData->mIsLoading = PR_FALSE; // we will handle the removal right here
@@ -2208,17 +2208,17 @@ struct StopLoadingSheetsByURIClosure {
CSSLoaderImpl::LoadDataArray& aArray) :
uri(aURI), array(aArray)
{}
nsIURI* uri;
CSSLoaderImpl::LoadDataArray& array;
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
StopLoadingSheetByURICallback(nsURIAndPrincipalHashKey* aKey,
SheetLoadData*& aData,
void* aClosure)
{
NS_PRECONDITION(aData, "Must have a data!");
NS_PRECONDITION(aClosure, "Must have a loader");
StopLoadingSheetsByURIClosure* closure =
@@ -2323,17 +2323,17 @@ CSSLoaderImpl::AddObserver(nsICSSLoaderO
}
NS_IMETHODIMP_(void)
CSSLoaderImpl::RemoveObserver(nsICSSLoaderObserver* aObserver)
{
mObservers.RemoveElement(aObserver);
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
CollectLoadDatas(nsURIAndPrincipalHashKey *aKey,
SheetLoadData* &aData,
void* aClosure)
{
static_cast<CSSLoaderImpl::LoadDataArray*>(aClosure)->AppendElement(aData);
return PL_DHASH_REMOVE;
}
--- a/layout/style/nsCSSParser.cpp
+++ b/layout/style/nsCSSParser.cpp
@@ -587,22 +587,22 @@ protected:
// All data from successfully parsed properties are placed into |mData|.
nsCSSExpandedDataBlock mData;
#ifdef DEBUG
PRPackedBool mScannerInited;
#endif
};
-PR_STATIC_CALLBACK(void) AppendRuleToArray(nsICSSRule* aRule, void* aArray)
+static void AppendRuleToArray(nsICSSRule* aRule, void* aArray)
{
static_cast<nsCOMArray<nsICSSRule>*>(aArray)->AppendObject(aRule);
}
-PR_STATIC_CALLBACK(void) AppendRuleToSheet(nsICSSRule* aRule, void* aParser)
+static void AppendRuleToSheet(nsICSSRule* aRule, void* aParser)
{
CSSParserImpl* parser = (CSSParserImpl*) aParser;
parser->AppendRule(aRule);
}
nsresult
NS_NewCSSParser(nsICSSParser** aInstancePtrResult)
{
--- a/layout/style/nsCSSRuleProcessor.cpp
+++ b/layout/style/nsCSSRuleProcessor.cpp
@@ -137,47 +137,46 @@ struct RuleValue {
// Rule hash table
//
// Uses any of the sets of ops below.
struct RuleHashTableEntry : public PLDHashEntryHdr {
RuleValue *mRules; // linked list of |RuleValue|, null-terminated
};
-PR_STATIC_CALLBACK(PLDHashNumber)
+static PLDHashNumber
RuleHash_CIHashKey(PLDHashTable *table, const void *key)
{
nsIAtom *atom = const_cast<nsIAtom*>(static_cast<const nsIAtom*>(key));
nsAutoString str;
atom->ToString(str);
ToUpperCase(str);
return HashString(str);
}
typedef nsIAtom*
-(* PR_CALLBACK RuleHashGetKey) (PLDHashTable *table,
- const PLDHashEntryHdr *entry);
+(* RuleHashGetKey) (PLDHashTable *table, const PLDHashEntryHdr *entry);
struct RuleHashTableOps {
PLDHashTableOps ops;
// Extra callback to avoid duplicating the matchEntry callback for
// each table. (There used to be a getKey callback in
// PLDHashTableOps.)
RuleHashGetKey getKey;
};
inline const RuleHashTableOps*
ToLocalOps(const PLDHashTableOps *aOps)
{
return (const RuleHashTableOps*)
(((const char*) aOps) - offsetof(RuleHashTableOps, ops));
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
RuleHash_CIMatchEntry(PLDHashTable *table, const PLDHashEntryHdr *hdr,
const void *key)
{
nsIAtom *match_atom = const_cast<nsIAtom*>(static_cast<const nsIAtom*>
(key));
// Use our extra |getKey| callback to avoid code duplication.
nsIAtom *entry_atom = ToLocalOps(table->ops)->getKey(table, hdr);
@@ -187,59 +186,59 @@ RuleHash_CIMatchEntry(PLDHashTable *tabl
const char *match_str, *entry_str;
match_atom->GetUTF8String(&match_str);
entry_atom->GetUTF8String(&entry_str);
return (nsCRT::strcasecmp(entry_str, match_str) == 0);
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
RuleHash_CSMatchEntry(PLDHashTable *table, const PLDHashEntryHdr *hdr,
const void *key)
{
nsIAtom *match_atom = const_cast<nsIAtom*>(static_cast<const nsIAtom*>
(key));
// Use our extra |getKey| callback to avoid code duplication.
nsIAtom *entry_atom = ToLocalOps(table->ops)->getKey(table, hdr);
return match_atom == entry_atom;
}
-PR_STATIC_CALLBACK(nsIAtom*)
+static nsIAtom*
RuleHash_TagTable_GetKey(PLDHashTable *table, const PLDHashEntryHdr *hdr)
{
const RuleHashTableEntry *entry =
static_cast<const RuleHashTableEntry*>(hdr);
return entry->mRules->mSelector->mTag;
}
-PR_STATIC_CALLBACK(nsIAtom*)
+static nsIAtom*
RuleHash_ClassTable_GetKey(PLDHashTable *table, const PLDHashEntryHdr *hdr)
{
const RuleHashTableEntry *entry =
static_cast<const RuleHashTableEntry*>(hdr);
return entry->mRules->mSelector->mClassList->mAtom;
}
-PR_STATIC_CALLBACK(nsIAtom*)
+static nsIAtom*
RuleHash_IdTable_GetKey(PLDHashTable *table, const PLDHashEntryHdr *hdr)
{
const RuleHashTableEntry *entry =
static_cast<const RuleHashTableEntry*>(hdr);
return entry->mRules->mSelector->mIDList->mAtom;
}
-PR_STATIC_CALLBACK(PLDHashNumber)
+static PLDHashNumber
RuleHash_NameSpaceTable_HashKey(PLDHashTable *table, const void *key)
{
return NS_PTR_TO_INT32(key);
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
RuleHash_NameSpaceTable_MatchEntry(PLDHashTable *table,
const PLDHashEntryHdr *hdr,
const void *key)
{
const RuleHashTableEntry *entry =
static_cast<const RuleHashTableEntry*>(hdr);
return NS_PTR_TO_INT32(key) ==
@@ -658,17 +657,17 @@ void RuleHash::EnumerateTagRules(nsIAtom
//--------------------------------
// Attribute selectors hash table.
struct AttributeSelectorEntry : public PLDHashEntryHdr {
nsIAtom *mAttribute;
nsVoidArray *mSelectors;
};
-PR_STATIC_CALLBACK(void)
+static void
AttributeSelectorClearEntry(PLDHashTable *table, PLDHashEntryHdr *hdr)
{
AttributeSelectorEntry *entry = static_cast<AttributeSelectorEntry*>(hdr);
delete entry->mSelectors;
memset(entry, 0, table->entrySize);
}
static const PLDHashTableOps AttributeSelectorOps = {
@@ -1973,17 +1972,17 @@ IsSiblingOperator(PRUnichar oper)
struct StateEnumData {
StateEnumData(StateRuleProcessorData *aData)
: data(aData), change(nsReStyleHint(0)) {}
StateRuleProcessorData *data;
nsReStyleHint change;
};
-PR_STATIC_CALLBACK(PRBool) StateEnumFunc(void* aSelector, void* aData)
+static PRBool StateEnumFunc(void* aSelector, void* aData)
{
StateEnumData *enumData = static_cast<StateEnumData*>(aData);
StateRuleProcessorData *data = enumData->data;
nsCSSSelector* selector = static_cast<nsCSSSelector*>(aSelector);
nsReStyleHint possibleChange = IsSiblingOperator(selector->mOperator) ?
eReStyle_LaterSiblings : eReStyle_Self;
@@ -2027,17 +2026,17 @@ struct AttributeEnumData {
AttributeEnumData(AttributeRuleProcessorData *aData)
: data(aData), change(nsReStyleHint(0)) {}
AttributeRuleProcessorData *data;
nsReStyleHint change;
};
-PR_STATIC_CALLBACK(PRBool) AttributeEnumFunc(void* aSelector, void* aData)
+static PRBool AttributeEnumFunc(void* aSelector, void* aData)
{
AttributeEnumData *enumData = static_cast<AttributeEnumData*>(aData);
AttributeRuleProcessorData *data = enumData->data;
nsCSSSelector* selector = static_cast<nsCSSSelector*>(aSelector);
nsReStyleHint possibleChange = IsSiblingOperator(selector->mOperator) ?
eReStyle_LaterSiblings : eReStyle_Self;
@@ -2239,23 +2238,23 @@ struct PerWeightData {
PRInt32 mWeight;
RuleValue* mRules; // linked list (reverse order)
};
struct RuleByWeightEntry : public PLDHashEntryHdr {
PerWeightData data; // mWeight is key, mRules are value
};
-PR_STATIC_CALLBACK(PLDHashNumber)
+static PLDHashNumber
HashIntKey(PLDHashTable *table, const void *key)
{
return PLDHashNumber(NS_PTR_TO_INT32(key));
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
MatchWeightEntry(PLDHashTable *table, const PLDHashEntryHdr *hdr,
const void *key)
{
const RuleByWeightEntry *entry = (const RuleByWeightEntry *)hdr;
return entry->data.mWeight == NS_PTR_TO_INT32(key);
}
static PLDHashTableOps gRulesByWeightOps = {
@@ -2492,18 +2491,18 @@ nsCSSRuleProcessor::CascadeSheetRulesInt
}
if (!sheet->mInner->mOrderedRules.EnumerateForwards(InsertRuleByWeight, data))
return PR_FALSE;
}
return PR_TRUE;
}
-PR_STATIC_CALLBACK(int) CompareWeightData(const void* aArg1, const void* aArg2,
- void* closure)
+static int CompareWeightData(const void* aArg1, const void* aArg2,
+ void* closure)
{
const PerWeightData* arg1 = static_cast<const PerWeightData*>(aArg1);
const PerWeightData* arg2 = static_cast<const PerWeightData*>(aArg2);
return arg1->mWeight - arg2->mWeight; // put lower weight first
}
struct FillWeightArrayData {
@@ -2512,17 +2511,17 @@ struct FillWeightArrayData {
mWeightArray(aArrayData)
{
}
PRInt32 mIndex;
PerWeightData* mWeightArray;
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
FillWeightArray(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg)
{
FillWeightArrayData* data = static_cast<FillWeightArrayData*>(arg);
const RuleByWeightEntry *entry = (const RuleByWeightEntry *)hdr;
data->mWeightArray[data->mIndex++] = entry->data;
--- a/layout/style/nsCSSScanner.cpp
+++ b/layout/style/nsCSSScanner.cpp
@@ -263,17 +263,17 @@ nsCSSScanner::SetLowLevelError(nsresult
NS_ASSERTION(aErrorCode != NS_OK, "SetLowLevelError() used to clear error");
NS_ASSERTION(mLowLevelError == NS_OK, "there is already a low-level error");
mLowLevelError = aErrorCode;
}
#ifdef CSS_REPORT_PARSE_ERRORS
#define CSS_ERRORS_PREF "layout.css.report_errors"
-PR_STATIC_CALLBACK(int)
+static int
CSSErrorsPrefChanged(const char *aPref, void *aClosure)
{
gReportErrors = nsContentUtils::GetBoolPref(CSS_ERRORS_PREF, PR_TRUE);
return NS_OK;
}
#endif
/* static */ PRBool
--- a/layout/style/nsCSSStyleSheet.cpp
+++ b/layout/style/nsCSSStyleSheet.cpp
@@ -1560,17 +1560,17 @@ void nsCSSStyleSheet::List(FILE* out, PR
child->List(out, aIndent + 1);
}
fputs("Rules in source order:\n", out);
ListRules(mInner->mOrderedRules, out, aIndent);
}
#endif
-static PRBool PR_CALLBACK
+static PRBool
EnumClearRuleCascades(void* aProcessor, void* aData)
{
nsCSSRuleProcessor* processor =
static_cast<nsCSSRuleProcessor*>(aProcessor);
processor->ClearRuleCascades();
return PR_TRUE;
}
--- a/layout/style/nsHTMLStyleSheet.cpp
+++ b/layout/style/nsHTMLStyleSheet.cpp
@@ -297,35 +297,35 @@ nsHTMLStyleSheet::TableUngroupedColRule:
return NS_OK;
}
// -----------------------------------------------------------
struct MappedAttrTableEntry : public PLDHashEntryHdr {
nsMappedAttributes *mAttributes;
};
-PR_STATIC_CALLBACK(PLDHashNumber)
+static PLDHashNumber
MappedAttrTable_HashKey(PLDHashTable *table, const void *key)
{
nsMappedAttributes *attributes =
static_cast<nsMappedAttributes*>(const_cast<void*>(key));
return attributes->HashValue();
}
-PR_STATIC_CALLBACK(void)
+static void
MappedAttrTable_ClearEntry(PLDHashTable *table, PLDHashEntryHdr *hdr)
{
MappedAttrTableEntry *entry = static_cast<MappedAttrTableEntry*>(hdr);
entry->mAttributes->DropStyleSheetReference();
memset(entry, 0, sizeof(MappedAttrTableEntry));
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
MappedAttrTable_MatchEntry(PLDHashTable *table, const PLDHashEntryHdr *hdr,
const void *key)
{
nsMappedAttributes *attributes =
static_cast<nsMappedAttributes*>(const_cast<void*>(key));
const MappedAttrTableEntry *entry =
static_cast<const MappedAttrTableEntry*>(hdr);
--- a/layout/style/nsICSSParser.h
+++ b/layout/style/nsICSSParser.h
@@ -57,17 +57,17 @@ class nsMediaList;
class nsIPrincipal;
struct nsCSSSelectorList;
#define NS_ICSS_PARSER_IID \
{ 0xad4a3778, 0xdae0, 0x4640, \
{ 0xb2, 0x5a, 0x24, 0xff, 0x09, 0xc3, 0x70, 0xef } }
// Rule processing function
-typedef void (*PR_CALLBACK RuleAppendFunc) (nsICSSRule* aRule, void* aData);
+typedef void (* RuleAppendFunc) (nsICSSRule* aRule, void* aData);
// Interface to the css parser.
class nsICSSParser : public nsISupports {
public:
NS_DECLARE_STATIC_IID_ACCESSOR(NS_ICSS_PARSER_IID)
// Set a style sheet for the parser to fill in. The style sheet must
// implement the nsICSSStyleSheet interface. Null can be passed in to clear
--- a/layout/style/nsIStyleRuleProcessor.h
+++ b/layout/style/nsIStyleRuleProcessor.h
@@ -233,17 +233,17 @@ struct AttributeRuleProcessorData : publ
* @see nsIStyleRule (for significantly more detailed comments)
*/
class nsIStyleRuleProcessor : public nsISupports {
public:
NS_DECLARE_STATIC_IID_ACCESSOR(NS_ISTYLE_RULE_PROCESSOR_IID)
// Shorthand for:
// nsCOMArray<nsIStyleRuleProcessor>::nsCOMArrayEnumFunc
- typedef PRBool (* PR_CALLBACK EnumFunc)(nsIStyleRuleProcessor*, void*);
+ typedef PRBool (* EnumFunc)(nsIStyleRuleProcessor*, void*);
/**
* Find the |nsIStyleRule|s matching the given content node and
* position the given |nsRuleWalker| at the |nsRuleNode| in the rule
* tree representing that ordered list of rules (with higher
* precedence being farther from the root of the lexicographic tree).
*/
NS_IMETHOD RulesMatching(ElementRuleProcessorData* aData) = 0;
--- a/layout/style/nsMediaFeatures.cpp
+++ b/layout/style/nsMediaFeatures.cpp
@@ -54,26 +54,26 @@ static const PRInt32 kOrientationKeyword
};
static const PRInt32 kScanKeywords[] = {
eCSSKeyword_progressive, NS_STYLE_SCAN_PROGRESSIVE,
eCSSKeyword_interlace, NS_STYLE_SCAN_INTERLACE,
eCSSKeyword_UNKNOWN, -1
};
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
GetWidth(nsPresContext* aPresContext, nsCSSValue& aResult)
{
nscoord width = aPresContext->GetVisibleArea().width;
float pixelWidth = aPresContext->AppUnitsToFloatCSSPixels(width);
aResult.SetFloatValue(pixelWidth, eCSSUnit_Pixel);
return NS_OK;
}
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
GetHeight(nsPresContext* aPresContext, nsCSSValue& aResult)
{
nscoord height = aPresContext->GetVisibleArea().height;
float pixelHeight = aPresContext->AppUnitsToFloatCSSPixels(height);
aResult.SetFloatValue(pixelHeight, eCSSUnit_Pixel);
return NS_OK;
}
@@ -88,73 +88,73 @@ GetDeviceContextFor(nsPresContext* aPres
nsCOMPtr<nsIDocShell>(do_QueryInterface(
nsCOMPtr<nsISupports>(aPresContext->GetContainer()))));
if (!ctx) {
ctx = aPresContext->DeviceContext();
}
return ctx;
}
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
GetDeviceWidth(nsPresContext* aPresContext, nsCSSValue& aResult)
{
// XXX: I'm not sure if this is really the right thing for print:
// do we want to include unprintable areas / page margins?
nsIDeviceContext *dx = GetDeviceContextFor(aPresContext);
nscoord width, height;
dx->GetDeviceSurfaceDimensions(width, height);
float pixelWidth = aPresContext->AppUnitsToFloatCSSPixels(width);
aResult.SetFloatValue(pixelWidth, eCSSUnit_Pixel);
return NS_OK;
}
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
GetDeviceHeight(nsPresContext* aPresContext, nsCSSValue& aResult)
{
// XXX: I'm not sure if this is really the right thing for print:
// do we want to include unprintable areas / page margins?
nsIDeviceContext *dx = GetDeviceContextFor(aPresContext);
nscoord width, height;
dx->GetDeviceSurfaceDimensions(width, height);
float pixelHeight = aPresContext->AppUnitsToFloatCSSPixels(height);
aResult.SetFloatValue(pixelHeight, eCSSUnit_Pixel);
return NS_OK;
}
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
GetOrientation(nsPresContext* aPresContext, nsCSSValue& aResult)
{
nsSize size = aPresContext->GetVisibleArea().Size();
PRInt32 orientation;
if (size.width > size.height) {
orientation = NS_STYLE_ORIENTATION_LANDSCAPE;
} else {
// Per spec, square viewports should be 'portrait'
orientation = NS_STYLE_ORIENTATION_PORTRAIT;
}
aResult.SetIntValue(orientation, eCSSUnit_Enumerated);
return NS_OK;
}
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
GetAspectRatio(nsPresContext* aPresContext, nsCSSValue& aResult)
{
nsRefPtr<nsCSSValue::Array> a = nsCSSValue::Array::Create(2);
NS_ENSURE_TRUE(a, NS_ERROR_OUT_OF_MEMORY);
nsSize size = aPresContext->GetVisibleArea().Size();
a->Item(0).SetIntValue(size.width, eCSSUnit_Integer);
a->Item(1).SetIntValue(size.height, eCSSUnit_Integer);
aResult.SetArrayValue(a, eCSSUnit_Array);
return NS_OK;
}
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
GetDeviceAspectRatio(nsPresContext* aPresContext, nsCSSValue& aResult)
{
nsRefPtr<nsCSSValue::Array> a = nsCSSValue::Array::Create(2);
NS_ENSURE_TRUE(a, NS_ERROR_OUT_OF_MEMORY);
// XXX: I'm not sure if this is really the right thing for print:
// do we want to include unprintable areas / page margins?
nsIDeviceContext *dx = GetDeviceContextFor(aPresContext);
@@ -163,17 +163,17 @@ GetDeviceAspectRatio(nsPresContext* aPre
a->Item(0).SetIntValue(width, eCSSUnit_Integer);
a->Item(1).SetIntValue(height, eCSSUnit_Integer);
aResult.SetArrayValue(a, eCSSUnit_Array);
return NS_OK;
}
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
GetColor(nsPresContext* aPresContext, nsCSSValue& aResult)
{
// FIXME: This implementation is bogus. nsThebesDeviceContext
// doesn't provide reliable information (should be fixed in bug
// 424386).
// FIXME: On a monochrome device, return 0!
nsIDeviceContext *dx = GetDeviceContextFor(aPresContext);
PRUint32 depth;
@@ -186,59 +186,59 @@ GetColor(nsPresContext* aPresContext, ns
// The spec says to use bits *per color component*, so divide by 3,
// and round down, since the spec says to use the smallest when the
// color components differ.
depth /= 3;
aResult.SetIntValue(PRInt32(depth), eCSSUnit_Integer);
return NS_OK;
}
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
GetColorIndex(nsPresContext* aPresContext, nsCSSValue& aResult)
{
// We should return zero if the device does not use a color lookup
// table. Stuart says that our handling of displays with 8-bit
// color is bad enough that we never change the lookup table to
// match what we're trying to display, so perhaps we should always
// return zero. Given that there isn't any better information
// exposed, we don't have much other choice.
aResult.SetIntValue(0, eCSSUnit_Integer);
return NS_OK;
}
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
GetMonochrome(nsPresContext* aPresContext, nsCSSValue& aResult)
{
// For color devices we should return 0.
// FIXME: On a monochrome device, return the actual color depth, not
// 0!
aResult.SetIntValue(0, eCSSUnit_Integer);
return NS_OK;
}
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
GetResolution(nsPresContext* aPresContext, nsCSSValue& aResult)
{
// Resolution values are in device pixels, not CSS pixels.
nsIDeviceContext *dx = GetDeviceContextFor(aPresContext);
float dpi = float(dx->AppUnitsPerInch()) / float(dx->AppUnitsPerDevPixel());
aResult.SetFloatValue(dpi, eCSSUnit_Inch);
return NS_OK;
}
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
GetScan(nsPresContext* aPresContext, nsCSSValue& aResult)
{
// Since Gecko doesn't support the 'tv' media type, the 'scan'
// feature is never present.
aResult.Reset();
return NS_OK;
}
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
GetGrid(nsPresContext* aPresContext, nsCSSValue& aResult)
{
// Gecko doesn't support grid devices (e.g., ttys), so the 'grid'
// feature is always 0.
aResult.SetIntValue(0, eCSSUnit_Integer);
return NS_OK;
}
--- a/layout/style/nsMediaFeatures.h
+++ b/layout/style/nsMediaFeatures.h
@@ -42,18 +42,17 @@
#include "nscore.h"
class nsIAtom;
class nsPresContext;
class nsCSSValue;
typedef nsresult
-(* PR_CALLBACK nsMediaFeatureValueGetter)(nsPresContext* aPresContext,
- nsCSSValue& aResult);
+(* nsMediaFeatureValueGetter)(nsPresContext* aPresContext, nsCSSValue& aResult);
struct nsMediaFeature {
nsIAtom **mName; // extra indirection to point to nsGkAtoms members
enum RangeType { eMinMaxAllowed, eMinMaxNotAllowed };
RangeType mRangeType;
enum ValueType {
--- a/layout/style/nsRuleNode.cpp
+++ b/layout/style/nsRuleNode.cpp
@@ -76,27 +76,27 @@
* For storage of an |nsRuleNode|'s children in a PLDHashTable.
*/
struct ChildrenHashEntry : public PLDHashEntryHdr {
// key is |mRuleNode->GetKey()|
nsRuleNode *mRuleNode;
};
-/* static */ PR_CALLBACK PLDHashNumber
+/* static */ PLDHashNumber
nsRuleNode::ChildrenHashHashKey(PLDHashTable *aTable, const void *aKey)
{
const nsRuleNode::Key *key =
static_cast<const nsRuleNode::Key*>(aKey);
// Disagreement on importance and level for the same rule is extremely
// rare, so hash just on the rule.
return PL_DHashVoidPtrKeyStub(aTable, key->mRule);
}
-/* static */ PR_CALLBACK PRBool
+/* static */ PRBool
nsRuleNode::ChildrenHashMatchEntry(PLDHashTable *aTable,
const PLDHashEntryHdr *aHdr,
const void *aKey)
{
const ChildrenHashEntry *entry =
static_cast<const ChildrenHashEntry*>(aHdr);
const nsRuleNode::Key *key =
static_cast<const nsRuleNode::Key*>(aKey);
@@ -597,17 +597,17 @@ SetFactor(const nsCSSValue& aValue, floa
// (which comes from the presShell) to perform the allocation.
void*
nsRuleNode::operator new(size_t sz, nsPresContext* aPresContext) CPP_THROW_NEW
{
// Check the recycle list first.
return aPresContext->AllocateFromShell(sz);
}
-/* static */ PR_CALLBACK PLDHashOperator
+/* static */ PLDHashOperator
nsRuleNode::EnqueueRuleNodeChildren(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg)
{
ChildrenHashEntry *entry = static_cast<ChildrenHashEntry*>(hdr);
nsRuleNode ***destroyQueueTail = static_cast<nsRuleNode***>(arg);
**destroyQueueTail = entry->mRuleNode;
*destroyQueueTail = &entry->mRuleNode->mNextSibling;
return PL_DHASH_NEXT;
@@ -814,18 +814,18 @@ struct PropertyCheckData {
};
/*
* a callback function that that can revise the result of
* CheckSpecifiedProperties before finishing; aResult is the current
* result, and it returns the revised one.
*/
typedef nsRuleNode::RuleDetail
- (* PR_CALLBACK CheckCallbackFn)(const nsRuleDataStruct& aData,
- nsRuleNode::RuleDetail aResult);
+ (* CheckCallbackFn)(const nsRuleDataStruct& aData,
+ nsRuleNode::RuleDetail aResult);
/* the information for all the properties in a style struct */
struct StructCheckData {
const PropertyCheckData* props;
PRInt32 nprops;
CheckCallbackFn callback;
};
@@ -864,17 +864,17 @@ ExamineCSSRect(const nsCSSRect* aRect,
NS_PRECONDITION(aRect, "Must have a rect");
NS_FOR_CSS_SIDES(side) {
ExamineCSSValue(aRect->*(nsCSSRect::sides[side]),
aSpecifiedCount, aInheritedCount);
}
}
-PR_STATIC_CALLBACK(nsRuleNode::RuleDetail)
+static nsRuleNode::RuleDetail
CheckFontCallback(const nsRuleDataStruct& aData,
nsRuleNode::RuleDetail aResult)
{
const nsRuleDataFont& fontData =
static_cast<const nsRuleDataFont&>(aData);
// em, ex, percent, 'larger', and 'smaller' values on font-size depend
// on the parent context's font-size
@@ -905,17 +905,17 @@ CheckFontCallback(const nsRuleDataStruct
aResult = nsRuleNode::eRulePartialMixed;
else if (aResult == nsRuleNode::eRuleFullReset)
aResult = nsRuleNode::eRuleFullMixed;
}
return aResult;
}
-PR_STATIC_CALLBACK(nsRuleNode::RuleDetail)
+static nsRuleNode::RuleDetail
CheckColorCallback(const nsRuleDataStruct& aData,
nsRuleNode::RuleDetail aResult)
{
const nsRuleDataColor& colorData =
static_cast<const nsRuleDataColor&>(aData);
// currentColor values for color require inheritance
if (colorData.mColor.GetUnit() == eCSSUnit_EnumColor &&
@@ -5170,17 +5170,17 @@ void
nsRuleNode::Mark()
{
for (nsRuleNode *node = this;
node && !(node->mDependentBits & NS_RULE_NODE_GC_MARK);
node = node->mParent)
node->mDependentBits |= NS_RULE_NODE_GC_MARK;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
SweepRuleNodeChildren(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg)
{
ChildrenHashEntry *entry = static_cast<ChildrenHashEntry*>(hdr);
if (entry->mRuleNode->Sweep())
return PL_DHASH_REMOVE; // implies NEXT, unless |ed with STOP
return PL_DHASH_NEXT;
}
--- a/layout/style/nsRuleNode.h
+++ b/layout/style/nsRuleNode.h
@@ -356,27 +356,27 @@ private:
}
PRBool operator!=(const Key& aOther) const
{
return !(*this == aOther);
}
};
- static PR_CALLBACK PLDHashNumber
+ static PLDHashNumber
ChildrenHashHashKey(PLDHashTable *aTable, const void *aKey);
- static PR_CALLBACK PRBool
+ static PRBool
ChildrenHashMatchEntry(PLDHashTable *aTable,
const PLDHashEntryHdr *aHdr,
const void *aKey);
static PLDHashTableOps ChildrenHashOps;
- static PR_CALLBACK PLDHashOperator
+ static PLDHashOperator
EnqueueRuleNodeChildren(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg);
Key GetKey() const {
return Key(mRule, GetLevel(), IsImportantRule());
}
// The children of this node are stored in either a hashtable or list
--- a/layout/svg/base/src/nsSVGOuterSVGFrame.cpp
+++ b/layout/svg/base/src/nsSVGOuterSVGFrame.cpp
@@ -380,17 +380,17 @@ nsSVGOuterSVGFrame::Reflow(nsPresContext
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
("exit nsSVGOuterSVGFrame::Reflow: size=%d,%d",
aDesiredSize.width, aDesiredSize.height));
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
return NS_OK;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
ReflowForeignObject(nsVoidPtrHashKey *aEntry, void* aUserArg)
{
static_cast<nsSVGForeignObjectFrame*>
(const_cast<void*>(aEntry->GetKey()))->MaybeReflowFromOuterSVGFrame();
return PL_DHASH_NEXT;
}
NS_IMETHODIMP
--- a/layout/svg/base/src/nsSVGUtils.cpp
+++ b/layout/svg/base/src/nsSVGUtils.cpp
@@ -160,17 +160,17 @@ 190, 192, 194, 196, 198, 200, 202, 204,
206, 208, 210, 212, 214, 216, 218, 220,
222, 224, 226, 229, 231, 233, 235, 237,
239, 242, 244, 246, 248, 250, 253, 255
};
static PRBool gSVGEnabled;
static const char SVG_PREF_STR[] = "svg.enabled";
-PR_STATIC_CALLBACK(int)
+static int
SVGPrefChanged(const char *aPref, void *aClosure)
{
PRBool prefVal = nsContentUtils::GetBoolPref(SVG_PREF_STR);
if (prefVal == gSVGEnabled)
return 0;
gSVGEnabled = prefVal;
if (gSVGEnabled)
--- a/layout/tables/SpanningCellSorter.cpp
+++ b/layout/tables/SpanningCellSorter.cpp
@@ -72,23 +72,23 @@ SpanningCellSorter::HashTableOps = {
HashTableHashKey,
HashTableMatchEntry,
PL_DHashMoveEntryStub,
PL_DHashClearEntryStub,
PL_DHashFinalizeStub,
nsnull
};
-/* static */ PR_CALLBACK PLDHashNumber
+/* static */ PLDHashNumber
SpanningCellSorter::HashTableHashKey(PLDHashTable *table, const void *key)
{
return NS_PTR_TO_INT32(key);
}
-/* static */ PR_CALLBACK PRBool
+/* static */ PRBool
SpanningCellSorter::HashTableMatchEntry(PLDHashTable *table,
const PLDHashEntryHdr *hdr,
const void *key)
{
const HashTableEntry *entry = static_cast<const HashTableEntry*>(hdr);
return NS_PTR_TO_INT32(key) == entry->mColSpan;
}
@@ -129,17 +129,17 @@ SpanningCellSorter::AddCell(PRInt32 aCol
i->next = entry->mItems;
entry->mItems = i;
}
return PR_TRUE;
}
-/* static */ PR_CALLBACK PLDHashOperator
+/* static */ PLDHashOperator
SpanningCellSorter::FillSortedArray(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg)
{
HashTableEntry *entry = static_cast<HashTableEntry*>(hdr);
HashTableEntry **sh = static_cast<HashTableEntry**>(arg);
sh[number] = entry;
--- a/layout/tables/SpanningCellSorter.h
+++ b/layout/tables/SpanningCellSorter.h
@@ -94,23 +94,23 @@ private:
PLDHashTable mHashTable;
struct HashTableEntry : public PLDHashEntryHdr {
PRInt32 mColSpan;
Item *mItems;
};
static PLDHashTableOps HashTableOps;
- PR_STATIC_CALLBACK(PLDHashNumber)
+ static PLDHashNumber
HashTableHashKey(PLDHashTable *table, const void *key);
- PR_STATIC_CALLBACK(PRBool)
+ static PRBool
HashTableMatchEntry(PLDHashTable *table, const PLDHashEntryHdr *hdr,
const void *key);
- PR_STATIC_CALLBACK(PLDHashOperator)
+ static PLDHashOperator
FillSortedArray(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg);
static int SortArray(const void *a, const void *b, void *closure);
/* state used only during enumeration */
PRUint32 mEnumerationIndex; // into mArray or mSortedHashTable
HashTableEntry **mSortedHashTable;
--- a/layout/xul/base/src/nsMenuPopupFrame.cpp
+++ b/layout/xul/base/src/nsMenuPopupFrame.cpp
@@ -555,17 +555,17 @@ nsMenuPopupFrame::InitializePopupWithAnc
mPopupAlignment = POPUPALIGNMENT_NONE;
mScreenXPos = aXPos;
mScreenYPos = aYPos;
mXPos = aXPos;
mYPos = aYPos;
}
}
-void PR_CALLBACK
+void
LazyGeneratePopupDone(nsIContent* aPopup, nsIFrame* aFrame, void* aArg)
{
// be safe and check the frame type
if (aFrame->GetType() == nsGkAtoms::menuPopupFrame) {
nsWeakFrame weakFrame(aFrame);
nsMenuPopupFrame* popupFrame = static_cast<nsMenuPopupFrame*>(aFrame);
nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
--- a/layout/xul/base/src/tree/src/nsTreeBodyFrame.cpp
+++ b/layout/xul/base/src/tree/src/nsTreeBodyFrame.cpp
@@ -109,17 +109,17 @@
#ifdef IBMBIDI
#include "nsBidiPresUtils.h"
#endif
static NS_DEFINE_CID(kWidgetCID, NS_CHILD_CID);
// Enumeration function that cancels all the image requests in our cache
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
CancelImageRequest(const nsAString& aKey,
nsTreeImageCacheEntry aEntry, void* aData)
{
aEntry.request->Cancel(NS_BINDING_ABORTED);
return PL_DHASH_NEXT;
}
//
--- a/layout/xul/base/src/tree/src/nsTreeStyleCache.cpp
+++ b/layout/xul/base/src/tree/src/nsTreeStyleCache.cpp
@@ -111,27 +111,27 @@ nsTreeStyleCache::GetStyleContext(nsICSS
return nsnull;
}
mCache->Put(currState, result);
}
return result;
}
-PRBool PR_CALLBACK
+PRBool
nsTreeStyleCache::DeleteDFAState(nsHashKey *aKey,
void *aData,
void *closure)
{
nsDFAState* entry = static_cast<nsDFAState*>(aData);
delete entry;
return PR_TRUE;
}
-PRBool PR_CALLBACK
+PRBool
nsTreeStyleCache::ReleaseStyleContext(nsHashKey *aKey,
void *aData,
void *closure)
{
nsStyleContext* context = static_cast<nsStyleContext*>(aData);
context->Release();
return PR_TRUE;
}
--- a/layout/xul/base/src/tree/src/nsTreeStyleCache.h
+++ b/layout/xul/base/src/tree/src/nsTreeStyleCache.h
@@ -103,19 +103,19 @@ public:
nsStyleContext* GetStyleContext(nsICSSPseudoComparator* aComparator,
nsPresContext* aPresContext,
nsIContent* aContent,
nsStyleContext* aContext,
nsIAtom* aPseudoElement,
nsISupportsArray* aInputWord);
- static PRBool PR_CALLBACK DeleteDFAState(nsHashKey *aKey, void *aData, void *closure);
+ static PRBool DeleteDFAState(nsHashKey *aKey, void *aData, void *closure);
- static PRBool PR_CALLBACK ReleaseStyleContext(nsHashKey *aKey, void *aData, void *closure);
+ static PRBool ReleaseStyleContext(nsHashKey *aKey, void *aData, void *closure);
protected:
// A transition table for a deterministic finite automaton. The DFA
// takes as its input a single pseudoelement and an ordered set of properties.
// It transitions on an input word that is the concatenation of the pseudoelement supplied
// with the properties in the array.
//
// It transitions from state to state by looking up entries in the transition table (which is
--- a/modules/libjar/nsJAR.cpp
+++ b/modules/libjar/nsJAR.cpp
@@ -107,17 +107,17 @@ nsJARManifestItem::~nsJARManifestItem()
// Delete digests if necessary
PR_FREEIF(calculatedSectionDigest);
PR_FREEIF(storedEntryDigest);
}
//----------------------------------------------
// nsJAR constructor/destructor
//----------------------------------------------
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
DeleteManifestEntry(nsHashKey* aKey, void* aData, void* closure)
{
//-- deletes an entry in mManifestData.
delete (nsJARManifestItem*)aData;
return PR_TRUE;
}
// The following initialization makes a guess of 10 entries per jarfile.
@@ -1089,17 +1089,17 @@ nsZipReaderCache::Init(PRUint32 cacheSiz
os->AddObserver(this, "chrome-flush-caches", PR_TRUE);
}
// ignore failure of the observer registration.
mLock = PR_NewLock();
return mLock ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
-static PRBool PR_CALLBACK
+static PRBool
DropZipReaderCache(nsHashKey *aKey, void *aData, void* closure)
{
nsJAR* zip = (nsJAR*)aData;
zip->SetZipReaderCache(nsnull);
return PR_TRUE;
}
nsZipReaderCache::~nsZipReaderCache()
@@ -1163,17 +1163,17 @@ nsZipReaderCache::GetZip(nsIFile* zipFil
PRBool collision = mZips.Put(&key, static_cast<nsIZipReader*>(zip)); // AddRefs to 2
NS_ASSERTION(!collision, "horked");
}
*result = zip;
return rv;
}
-static PRBool PR_CALLBACK
+static PRBool
FindOldestZip(nsHashKey *aKey, void *aData, void* closure)
{
nsJAR** oldestPtr = (nsJAR**)closure;
nsJAR* oldest = *oldestPtr;
nsJAR* current = (nsJAR*)aData;
PRIntervalTime currentReleaseTime = current->GetReleaseTime();
if (currentReleaseTime != PR_INTERVAL_NO_TIMEOUT) {
if (oldest == nsnull ||
@@ -1181,17 +1181,17 @@ FindOldestZip(nsHashKey *aKey, void *aDa
*oldestPtr = current;
}
}
return PR_TRUE;
}
struct ZipFindData {nsJAR* zip; PRBool found;};
-static PRBool PR_CALLBACK
+static PRBool
FindZip(nsHashKey *aKey, void *aData, void* closure)
{
ZipFindData* find_data = (ZipFindData*)closure;
if (find_data->zip == (nsJAR*)aData) {
find_data->found = PR_TRUE;
return PR_FALSE;
}
@@ -1257,17 +1257,17 @@ nsZipReaderCache::ReleaseZip(nsJAR* zip)
nsCStringKey key(path);
PRBool removed = mZips.Remove(&key); // Releases
NS_ASSERTION(removed, "botched");
return NS_OK;
}
-static PRBool PR_CALLBACK
+static PRBool
FindFlushableZip(nsHashKey *aKey, void *aData, void* closure)
{
nsHashKey** flushableKeyPtr = (nsHashKey**)closure;
nsJAR* current = (nsJAR*)aData;
if (current->GetReleaseTime() != PR_INTERVAL_NO_TIMEOUT) {
*flushableKeyPtr = aKey;
current->SetZipReaderCache(nsnull);
--- a/modules/libjar/nsJARFactory.cpp
+++ b/modules/libjar/nsJARFactory.cpp
@@ -93,16 +93,16 @@ static const nsModuleComponentInfo compo
{ NS_JARURI_CLASSNAME, // needed only for fastload
NS_JARURI_CID,
nsnull,
nsJARURIConstructor
}
};
// Jar module shutdown hook
-static void PR_CALLBACK nsJarShutdown(nsIModule *module)
+static void nsJarShutdown(nsIModule *module)
{
// Release cached buffers from zlib allocator
delete gZlibAllocator;
NS_IF_RELEASE(gJarHandler);
}
NS_IMPL_NSGETMODULE_WITH_DTOR(nsJarModule, components, nsJarShutdown)
--- a/modules/libjar/nsZipArchive.cpp
+++ b/modules/libjar/nsZipArchive.cpp
@@ -441,32 +441,32 @@ void ProcessWindowsMessages()
// The interesting question is when should be free this ?
// - memory pressure should be one.
// - after startup of navigator
// - after startup of mail
// In general, this allocator should be enabled before
// we startup and disabled after we startup if memory is a concern.
//***********************************************************
-PR_STATIC_CALLBACK(void *)
+static void *
zlibAlloc(void *opaque, uInt items, uInt size)
{
nsRecyclingAllocator *zallocator = (nsRecyclingAllocator *)opaque;
if (zallocator) {
// Bump up x4 allocations
PRUint32 realitems = items;
if (size == 4 && items < BY4ALLOC_ITEMS)
realitems = BY4ALLOC_ITEMS;
return zallocator->Calloc(realitems, size);
}
else
return calloc(items, size);
}
-PR_STATIC_CALLBACK(void)
+static void
zlibFree(void *opaque, void *ptr)
{
nsRecyclingAllocator *zallocator = (nsRecyclingAllocator *)opaque;
if (zallocator)
zallocator->Free(ptr);
else
free(ptr);
return;
--- a/modules/libpr0n/build/nsImageModule.cpp
+++ b/modules/libpr0n/build/nsImageModule.cpp
@@ -305,24 +305,24 @@ static const nsModuleComponentInfo compo
nsXBMDecoderConstructor, },
{ "XBM Decoder",
NS_XBMDECODER_CID,
"@mozilla.org/image/decoder;2?type=image/xbm",
nsXBMDecoderConstructor, },
#endif
};
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
imglib_Initialize(nsIModule* aSelf)
{
imgLoader::InitCache();
return NS_OK;
}
-PR_STATIC_CALLBACK(void)
+static void
imglib_Shutdown(nsIModule* aSelf)
{
imgLoader::Shutdown();
}
NS_IMPL_NSGETMODULE_WITH_CTOR_DTOR(nsImageLib2Module, components,
imglib_Initialize, imglib_Shutdown)
--- a/modules/libpr0n/decoders/icon/nsIconModule.cpp
+++ b/modules/libpr0n/decoders/icon/nsIconModule.cpp
@@ -105,23 +105,23 @@ static const nsModuleComponentInfo compo
{ "Icon Protocol Handler",
NS_ICONPROTOCOL_CID,
NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "moz-icon",
nsIconProtocolHandlerConstructor
}
};
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
IconDecoderModuleCtor(nsIModule* aSelf)
{
return NS_OK;
}
-PR_STATIC_CALLBACK(void)
+static void
IconDecoderModuleDtor(nsIModule* aSelf)
{
#ifdef MOZ_WIDGET_GTK2
nsIconChannel::Shutdown();
#endif
}
NS_IMPL_NSGETMODULE_WITH_CTOR_DTOR(nsIconDecoderModule, components,
--- a/modules/libpref/src/nsPrefBranch.cpp
+++ b/modules/libpref/src/nsPrefBranch.cpp
@@ -70,20 +70,20 @@ struct EnumerateData {
struct PrefCallbackData {
nsPrefBranch *pBranch;
nsIObserver *pObserver;
nsIWeakReference *pWeakRef;
};
// Prototypes
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
pref_enumChild(PLDHashTable *table, PLDHashEntryHdr *heh,
PRUint32 i, void *arg);
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
NotifyObserver(const char *newpref, void *data);
/*
* Constructor/Destructor
*/
nsPrefBranch::nsPrefBranch(const char *aPrefRoot, PRBool aDefaultBranch)
: mObservers(nsnull)
@@ -719,17 +719,17 @@ NS_IMETHODIMP nsPrefBranch::Observe(nsIS
{
// watch for xpcom shutdown and free our observers to eliminate any cyclic references
if (!nsCRT::strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
freeObserverList();
}
return NS_OK;
}
-PR_STATIC_CALLBACK(nsresult) NotifyObserver(const char *newpref, void *data)
+static nsresult NotifyObserver(const char *newpref, void *data)
{
PrefCallbackData *pData = (PrefCallbackData *)data;
// remove any root this string may contain so as to not confuse the observer
// by passing them something other than what they passed us as a topic
PRUint32 len = pData->pBranch->GetRootLength();
nsCAutoString suffix(newpref + len);
@@ -860,17 +860,17 @@ nsresult nsPrefBranch::getValidatedPrefN
if (NS_FAILED(rv) || !enabled)
return NS_ERROR_FAILURE;
}
*_retval = fullPref;
return NS_OK;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
pref_enumChild(PLDHashTable *table, PLDHashEntryHdr *heh,
PRUint32 i, void *arg)
{
PrefHashEntry *he = static_cast<PrefHashEntry*>(heh);
EnumerateData *d = reinterpret_cast<EnumerateData *>(arg);
if (PL_strncmp(he->key, d->parent, PL_strlen(d->parent)) == 0) {
d->pref_list->AppendElement((void*)he->key);
}
--- a/modules/libpref/src/nsSharedPrefHandler.cpp
+++ b/modules/libpref/src/nsSharedPrefHandler.cpp
@@ -61,18 +61,18 @@ nsSharedPrefHandler *gSharedPrefHandler
#define kPrefsTSQueueName NS_LITERAL_CSTRING("prefs")
#define kExceptionListFileName NS_LITERAL_CSTRING("nonshared.txt")
const char kExceptionListCommentChar = '#';
const PRUint32 kCurrentPrefsTransactionDataVersion = 1;
// Static function prototypes
-static PRBool PR_CALLBACK enumFind(void* aElement, void *aData);
-static PRBool PR_CALLBACK enumFree(void* aElement, void *aData);
+static PRBool enumFind(void* aElement, void *aData);
+static PRBool enumFree(void* aElement, void *aData);
static PRInt32 ReadLine(FILE* inStm, nsACString& destString);
//****************************************************************************
// Transaction Format for kCurrentPrefsTransactionDataVersion
//****************************************************************************
/*
@@ -358,25 +358,25 @@ NS_IMETHODIMP nsSharedPrefHandler::OnFlu
mPrefService->SavePrefFileInternal(nsnull);
return NS_OK;
}
//*****************************************************************************
// Static functions
//*****************************************************************************
-static PRBool PR_CALLBACK enumFind(void* aElement, void *aData)
+static PRBool enumFind(void* aElement, void *aData)
{
char *elemStr = static_cast<char*>(aElement);
char *searchStr = static_cast<char*>(aData);
// return PR_FALSE for a match and to stop search
return (strncmp(elemStr, searchStr, strlen(elemStr)) != 0);
}
-static PRBool PR_CALLBACK enumFree(void* aElement, void *aData)
+static PRBool enumFree(void* aElement, void *aData)
{
if (aElement)
nsMemory::Free(aElement);
return PR_TRUE;
}
static PRInt32 ReadLine(FILE* inStm, nsACString& destString)
{
--- a/modules/libpref/src/prefapi.cpp
+++ b/modules/libpref/src/prefapi.cpp
@@ -80,32 +80,32 @@
#ifdef XP_BEOS
#include "Alert.h"
#endif
#define BOGUS_DEFAULT_INT_PREF_VALUE (-5632)
#define BOGUS_DEFAULT_BOOL_PREF_VALUE (-2)
-PR_STATIC_CALLBACK(void)
+static void
clearPrefEntry(PLDHashTable *table, PLDHashEntryHdr *entry)
{
PrefHashEntry *pref = static_cast<PrefHashEntry *>(entry);
if (pref->flags & PREF_STRING)
{
PR_FREEIF(pref->defaultPref.stringVal);
PR_FREEIF(pref->userPref.stringVal);
}
// don't need to free this as it's allocated in memory owned by
// gPrefNameArena
pref->key = nsnull;
memset(entry, 0, table->entrySize);
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
matchPrefEntry(PLDHashTable*, const PLDHashEntryHdr* entry,
const void* key)
{
const PrefHashEntry *prefEntry =
static_cast<const PrefHashEntry*>(entry);
if (prefEntry->key == key) return PR_TRUE;
@@ -371,17 +371,17 @@ pref_savePref(PLDHashTable *table, PLDHa
argData->prefArray[i] = ToNewCString(NS_LITERAL_CSTRING("user_pref(\"") +
prefName +
NS_LITERAL_CSTRING("\", ") +
prefValue +
NS_LITERAL_CSTRING(");"));
return PL_DHASH_NEXT;
}
-int PR_CALLBACK
+int
pref_CompareStrings(const void *v1, const void *v2, void *unused)
{
char *s1 = *(char**) v1;
char *s2 = *(char**) v2;
if (!s1)
{
if (!s2)
@@ -513,17 +513,17 @@ nsresult PREF_GetBoolPref(const char *pr
*return_value = pref->userPref.boolVal;
rv = NS_OK;
}
}
return rv;
}
/* Delete a branch. Used for deleting mime types */
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
pref_DeleteItem(PLDHashTable *table, PLDHashEntryHdr *heh, PRUint32 i, void *arg)
{
PrefHashEntry* he = static_cast<PrefHashEntry*>(heh);
const char *to_delete = (const char *) arg;
int len = PL_strlen(to_delete);
/* note if we're deleting "ldap" then we want to delete "ldap.xxx"
and "ldap" (if such a leaf node exists) but not "ldap_1.xxx" */
@@ -582,17 +582,17 @@ PREF_ClearUserPref(const char *pref_name
if (gCallbacksEnabled)
pref_DoCallback(pref_name);
gDirty = PR_TRUE;
rv = NS_OK;
}
return rv;
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
pref_ClearUserPref(PLDHashTable *table, PLDHashEntryHdr *he, PRUint32,
void *arg)
{
PrefHashEntry *pref = static_cast<PrefHashEntry*>(he);
PLDHashOperator nextOp = PL_DHASH_NEXT;
if (PREF_HAS_USER_VALUE(pref))
--- a/modules/libpref/src/prefapi_private_data.h
+++ b/modules/libpref/src/prefapi_private_data.h
@@ -46,9 +46,9 @@ enum pref_SaveTypes { SAVE_NONSHARED, SA
struct pref_saveArgs {
char **prefArray;
pref_SaveTypes saveTypes;
};
PLDHashOperator
pref_savePref(PLDHashTable *table, PLDHashEntryHdr *heh, PRUint32 i, void *arg);
-int PR_CALLBACK pref_CompareStrings(const void *v1, const void *v2, void* unused);
+int pref_CompareStrings(const void *v1, const void *v2, void* unused);
--- a/modules/oji/src/lcglue.cpp
+++ b/modules/oji/src/lcglue.cpp
@@ -82,17 +82,17 @@ public:
}
private:
PRUintn mIndex;
PRBool mValid;
};
-static void PR_CALLBACK detach_JVMContext(void* storage)
+static void detach_JVMContext(void* storage)
{
JVMContext* context = reinterpret_cast<JVMContext*>(storage);
JNIEnv* proxyEnv = context->proxyEnv;
if (proxyEnv != NULL) {
DeleteProxyJNI(proxyEnv);
context->proxyEnv = NULL;
}
--- a/modules/oji/src/nsJVMConfigManagerUnix.cpp
+++ b/modules/oji/src/nsJVMConfigManagerUnix.cpp
@@ -57,27 +57,27 @@
// Implementation of nsJVMConfigManagerUnix
NS_IMPL_ISUPPORTS1(nsJVMConfigManagerUnix, nsIJVMConfigManager)
nsJVMConfigManagerUnix::nsJVMConfigManagerUnix()
{
InitJVMConfigList();
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
FreeJVMConfig(nsHashKey *aKey, void *aData, void* aClosure)
{
nsJVMConfig* config = static_cast<nsJVMConfig *>(aData);
NS_IF_RELEASE(config);
return PR_TRUE;
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
AppendJVMConfig(nsHashKey *aKey, void *aData, void* aClosure)
{
nsJVMConfig* config = static_cast<nsJVMConfig *>(aData);
nsIMutableArray *array = static_cast<nsIMutableArray *>(aClosure);
NS_ENSURE_TRUE(config && array, PR_FALSE);
array->AppendElement(config, PR_FALSE);
return PR_TRUE;
--- a/modules/oji/src/nsJVMManager.cpp
+++ b/modules/oji/src/nsJVMManager.cpp
@@ -269,17 +269,17 @@ nsJVMManager::Notify(void* address)
}
NS_METHOD
nsJVMManager::NotifyAll(void* address)
{
return (PR_CNotifyAll(address) == PR_SUCCESS ? NS_OK : NS_ERROR_FAILURE);
}
-static void PR_CALLBACK thread_starter(void* arg)
+static void thread_starter(void* arg)
{
nsIRunnable* runnable = (nsIRunnable*) arg;
if (runnable != NULL) {
runnable->Run();
}
}
NS_METHOD
--- a/modules/plugin/base/src/nsJSNPRuntime.cpp
+++ b/modules/plugin/base/src/nsJSNPRuntime.cpp
@@ -987,25 +987,25 @@ nsJSObjWrapper::NP_Construct(NPObject *n
class JSObjWrapperHashEntry : public PLDHashEntryHdr
{
public:
nsJSObjWrapper *mJSObjWrapper;
};
-PR_STATIC_CALLBACK(PLDHashNumber)
+static PLDHashNumber
JSObjWrapperHash(PLDHashTable *table, const void *key)
{
const nsJSObjWrapperKey *e = static_cast<const nsJSObjWrapperKey *>(key);
return (PLDHashNumber)((PRWord)e->mJSObj ^ (PRWord)e->mNpp) >> 2;
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
JSObjWrapperHashMatchEntry(PLDHashTable *table, const PLDHashEntryHdr *entry,
const void *key)
{
const nsJSObjWrapperKey *objWrapperKey =
static_cast<const nsJSObjWrapperKey *>(key);
const JSObjWrapperHashEntry *e =
static_cast<const JSObjWrapperHashEntry *>(entry);
@@ -1751,17 +1751,17 @@ nsNPObjWrapper::GetNewOrUsed(NPP npp, JS
// The new JSObject now holds on to npobj
_retainobject(npobj);
return obj;
}
// PLDHashTable enumeration callbacks for destruction code.
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
JSObjWrapperPluginDestroyedCallback(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg)
{
JSObjWrapperHashEntry *entry = (JSObjWrapperHashEntry *)hdr;
nsJSObjWrapper *npobj = entry->mJSObjWrapper;
if (npobj->mNpp == arg) {
@@ -1787,17 +1787,17 @@ JSObjWrapperPluginDestroyedCallback(PLDH
// Struct for passing an NPP and a JSContext to
// NPObjWrapperPluginDestroyedCallback
struct NppAndCx
{
NPP npp;
JSContext *cx;
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
NPObjWrapperPluginDestroyedCallback(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg)
{
NPObjWrapperHashEntry *entry = (NPObjWrapperHashEntry *)hdr;
NppAndCx *nppcx = reinterpret_cast<NppAndCx *>(arg);
if (entry->mNpp == nppcx->npp) {
// Prevent invalidate() and deallocate() from touching the hash
--- a/modules/plugin/base/src/nsPluginHostImpl.cpp
+++ b/modules/plugin/base/src/nsPluginHostImpl.cpp
@@ -4964,17 +4964,17 @@ struct pluginFileinDirectory
pluginFileinDirectory()
{
mModTime = LL_ZERO;
}
};
// QuickSort callback for comparing the modification time of two files
// if the times are the same, compare the filenames
-static int PR_CALLBACK ComparePluginFileInDirectory (const void *v1, const void *v2, void *)
+static int ComparePluginFileInDirectory (const void *v1, const void *v2, void *)
{
const pluginFileinDirectory* pfd1 = static_cast<const pluginFileinDirectory*>(v1);
const pluginFileinDirectory* pfd2 = static_cast<const pluginFileinDirectory*>(v2);
PRInt32 result = 0;
if (LL_EQ(pfd1->mModTime, pfd2->mModTime))
result = Compare(pfd1->mFilename, pfd2->mFilename, nsCaseInsensitiveStringComparator());
else if (LL_CMP(pfd1->mModTime, >, pfd2->mModTime))
--- a/netwerk/base/src/nsBaseChannel.cpp
+++ b/netwerk/base/src/nsBaseChannel.cpp
@@ -42,17 +42,17 @@
#include "nsMimeTypes.h"
#include "nsIOService.h"
#include "nsIHttpEventSink.h"
#include "nsIHttpChannel.h"
#include "nsIChannelEventSink.h"
#include "nsIStreamConverterService.h"
#include "nsIContentSniffer.h"
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
CopyProperties(const nsAString &key, nsIVariant *data, void *closure)
{
nsIWritablePropertyBag *bag =
static_cast<nsIWritablePropertyBag *>(closure);
bag->SetProperty(key, data);
return PL_DHASH_NEXT;
}
--- a/netwerk/base/src/nsDirectoryIndexStream.cpp
+++ b/netwerk/base/src/nsDirectoryIndexStream.cpp
@@ -86,19 +86,17 @@ nsDirectoryIndexStream::nsDirectoryIndex
if (! gLog)
gLog = PR_NewLogModule("nsDirectoryIndexStream");
#endif
PR_LOG(gLog, PR_LOG_DEBUG,
("nsDirectoryIndexStream[%p]: created", this));
}
-static int PR_CALLBACK compare(nsIFile* aElement1,
- nsIFile* aElement2,
- void* aData)
+static int compare(nsIFile* aElement1, nsIFile* aElement2, void* aData)
{
if (!NS_IsNativeUTF8()) {
// don't check for errors, because we can't report them anyway
nsAutoString name1, name2;
aElement1->GetLeafName(name1);
aElement2->GetLeafName(name2);
// Note - we should do the collation to do sorting. Why don't we?
--- a/netwerk/base/src/nsIOThreadPool.cpp
+++ b/netwerk/base/src/nsIOThreadPool.cpp
@@ -80,17 +80,17 @@ public:
NS_DECL_NSIOBSERVER
nsresult Init();
void Shutdown();
private:
virtual ~nsIOThreadPool();
- PR_STATIC_CALLBACK(void) ThreadFunc(void *);
+ static void ThreadFunc(void *);
// mLock protects all (exceptions during Init and Shutdown)
PRLock *mLock;
PRCondVar *mIdleThreadCV; // notified to wake up an idle thread
PRCondVar *mExitThreadCV; // notified when a thread exits
PRUint32 mNumThreads; // number of active + idle threads
PRUint32 mNumIdleThreads; // number of idle threads
PRCList mEventQ; // queue of PLEvent structs
--- a/netwerk/base/src/nsLoadGroup.cpp
+++ b/netwerk/base/src/nsLoadGroup.cpp
@@ -76,37 +76,37 @@ public:
RequestMapEntry(nsIRequest *aRequest) :
mKey(aRequest)
{
}
nsCOMPtr<nsIRequest> mKey;
};
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
RequestHashMatchEntry(PLDHashTable *table, const PLDHashEntryHdr *entry,
const void *key)
{
const RequestMapEntry *e =
static_cast<const RequestMapEntry *>(entry);
const nsIRequest *request = static_cast<const nsIRequest *>(key);
return e->mKey == request;
}
-PR_STATIC_CALLBACK(void)
+static void
RequestHashClearEntry(PLDHashTable *table, PLDHashEntryHdr *entry)
{
RequestMapEntry *e = static_cast<RequestMapEntry *>(entry);
// An entry is being cleared, let the entry do its own cleanup.
e->~RequestMapEntry();
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
RequestHashInitEntry(PLDHashTable *table, PLDHashEntryHdr *entry,
const void *key)
{
const nsIRequest *const_request = static_cast<const nsIRequest *>(key);
nsIRequest *request = const_cast<nsIRequest *>(const_request);
// Initialize the entry with placement new
new (entry) RequestMapEntry(request);
@@ -117,17 +117,17 @@ RequestHashInitEntry(PLDHashTable *table
static void
RescheduleRequest(nsIRequest *aRequest, PRInt32 delta)
{
nsCOMPtr<nsISupportsPriority> p = do_QueryInterface(aRequest);
if (p)
p->AdjustPriority(delta);
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
RescheduleRequests(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg)
{
RequestMapEntry *e = static_cast<RequestMapEntry *>(hdr);
PRInt32 *delta = static_cast<PRInt32 *>(arg);
RescheduleRequest(e->mKey, *delta);
return PL_DHASH_NEXT;
@@ -239,17 +239,17 @@ nsLoadGroup::GetStatus(nsresult *status)
return mDefaultLoadRequest->GetStatus(status);
*status = mStatus;
return NS_OK;
}
// PLDHashTable enumeration callback that appends strong references to
// all nsIRequest to an nsVoidArray.
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
AppendRequestsToVoidArray(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg)
{
RequestMapEntry *e = static_cast<RequestMapEntry *>(hdr);
nsVoidArray *array = static_cast<nsVoidArray *>(arg);
nsIRequest *request = e->mKey;
NS_ASSERTION(request, "What? Null key in pldhash entry?");
@@ -262,17 +262,17 @@ AppendRequestsToVoidArray(PLDHashTable *
NS_ADDREF(request);
return PL_DHASH_NEXT;
}
// nsVoidArray enumeration callback that releases all items in the
// nsVoidArray
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
ReleaseVoidArrayItems(void *aElement, void *aData)
{
nsISupports *s = static_cast<nsISupports *>(aElement);
NS_RELEASE(s);
return PR_TRUE;
}
@@ -701,17 +701,17 @@ nsLoadGroup::RemoveRequest(nsIRequest *r
}
}
return rv;
}
// PLDHashTable enumeration callback that appends all items in the
// hash to an nsISupportsArray.
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
AppendRequestsToISupportsArray(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg)
{
RequestMapEntry *e = static_cast<RequestMapEntry *>(hdr);
nsISupportsArray *array = static_cast<nsISupportsArray *>(arg);
PRBool ok = array->AppendElement(e->mKey);
--- a/netwerk/base/src/nsProtocolProxyService.cpp
+++ b/netwerk/base/src/nsProtocolProxyService.cpp
@@ -1036,17 +1036,17 @@ nsProtocolProxyService::UnregisterFilter
}
last = iter;
}
// No need to throw an exception in this case.
return NS_OK;
}
-PRBool PR_CALLBACK
+PRBool
nsProtocolProxyService::CleanupFilterArray(void *aElement, void *aData)
{
if (aElement)
delete (HostInfo *) aElement;
return PR_TRUE;
}
--- a/netwerk/base/src/nsProtocolProxyService.h
+++ b/netwerk/base/src/nsProtocolProxyService.h
@@ -285,17 +285,17 @@ protected:
* The URI to test.
* @param defaultPort
* The default port for the given URI.
*
* @return True if the URI can use the specified proxy.
*/
NS_HIDDEN_(PRBool) CanUseProxy(nsIURI *uri, PRInt32 defaultPort);
- static PRBool PR_CALLBACK CleanupFilterArray(void *aElement, void *aData);
+ static PRBool CleanupFilterArray(void *aElement, void *aData);
public:
// The Sun Forte compiler and others implement older versions of the
// C++ standard's rules on access and nested classes. These structs
// need to be public in order to deal with those compilers.
struct HostInfoIP {
PRUint16 family;
--- a/netwerk/build/nsNetModule.cpp
+++ b/netwerk/build/nsNetModule.cpp
@@ -593,25 +593,25 @@ CreateNewNSTXTToHTMLConvFactory(nsISuppo
return rv;
}
///////////////////////////////////////////////////////////////////////////////
// Module implementation for the net library
// Net module startup hook
-PR_STATIC_CALLBACK(nsresult) nsNetStartup(nsIModule *neckoModule)
+static nsresult nsNetStartup(nsIModule *neckoModule)
{
gNetStrings = new nsNetStrings();
return gNetStrings ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
// Net module shutdown hook
-static void PR_CALLBACK nsNetShutdown(nsIModule *neckoModule)
+static void nsNetShutdown(nsIModule *neckoModule)
{
// Release the url parser that the stdurl is holding.
nsStandardURL::ShutdownGlobalObjects();
// Release buffer cache
NS_IF_RELEASE(nsIOService::gBufferCache);
// Release global state used by the URL helper module.
--- a/netwerk/cache/src/nsCacheEntry.cpp
+++ b/netwerk/cache/src/nsCacheEntry.cpp
@@ -495,42 +495,42 @@ nsCacheEntryHashTable::VisitEntries( PLD
PL_DHashTableEnumerate(&table, etor, arg);
}
/**
* hash table operation callback functions
*/
-PLDHashNumber PR_CALLBACK
+PLDHashNumber
nsCacheEntryHashTable::HashKey( PLDHashTable *table, const void *key)
{
return PL_DHashStringKey(table,((nsCString *)key)->get());
}
-PRBool PR_CALLBACK
+PRBool
nsCacheEntryHashTable::MatchEntry(PLDHashTable * /* table */,
const PLDHashEntryHdr * hashEntry,
const void * key)
{
NS_ASSERTION(key != nsnull, "### nsCacheEntryHashTable::MatchEntry : null key");
nsCacheEntry *cacheEntry = ((nsCacheEntryHashTableEntry *)hashEntry)->cacheEntry;
return cacheEntry->mKey->Equals(*(nsCString *)key);
}
-void PR_CALLBACK
+void
nsCacheEntryHashTable::MoveEntry(PLDHashTable * /* table */,
const PLDHashEntryHdr *from,
PLDHashEntryHdr *to)
{
((nsCacheEntryHashTableEntry *)to)->cacheEntry =
((nsCacheEntryHashTableEntry *)from)->cacheEntry;
}
-void PR_CALLBACK
+void
nsCacheEntryHashTable::ClearEntry(PLDHashTable * /* table */,
PLDHashEntryHdr * hashEntry)
{
((nsCacheEntryHashTableEntry *)hashEntry)->cacheEntry = 0;
}
--- a/netwerk/cache/src/nsCacheEntry.h
+++ b/netwerk/cache/src/nsCacheEntry.h
@@ -294,40 +294,40 @@ public:
nsCacheEntry *GetEntry( const nsCString * key);
nsresult AddEntry( nsCacheEntry *entry);
void RemoveEntry( nsCacheEntry *entry);
void VisitEntries( PLDHashEnumerator etor, void *arg);
private:
// PLDHashTable operation callbacks
- static PLDHashNumber PR_CALLBACK HashKey( PLDHashTable *table, const void *key);
+ static PLDHashNumber HashKey( PLDHashTable *table, const void *key);
- static PRBool PR_CALLBACK MatchEntry( PLDHashTable * table,
- const PLDHashEntryHdr * entry,
- const void * key);
+ static PRBool MatchEntry( PLDHashTable * table,
+ const PLDHashEntryHdr * entry,
+ const void * key);
- static void PR_CALLBACK MoveEntry( PLDHashTable *table,
- const PLDHashEntryHdr *from,
- PLDHashEntryHdr *to);
+ static void MoveEntry( PLDHashTable *table,
+ const PLDHashEntryHdr *from,
+ PLDHashEntryHdr *to);
- static void PR_CALLBACK ClearEntry( PLDHashTable *table, PLDHashEntryHdr *entry);
+ static void ClearEntry( PLDHashTable *table, PLDHashEntryHdr *entry);
- static void PR_CALLBACK Finalize( PLDHashTable *table);
+ static void Finalize( PLDHashTable *table);
static
- PLDHashOperator PR_CALLBACK FreeCacheEntries(PLDHashTable * table,
- PLDHashEntryHdr * hdr,
- PRUint32 number,
- void * arg);
+ PLDHashOperator FreeCacheEntries(PLDHashTable * table,
+ PLDHashEntryHdr * hdr,
+ PRUint32 number,
+ void * arg);
static
- PLDHashOperator PR_CALLBACK VisitEntry(PLDHashTable * table,
- PLDHashEntryHdr * hdr,
- PRUint32 number,
- void * arg);
+ PLDHashOperator VisitEntry(PLDHashTable * table,
+ PLDHashEntryHdr * hdr,
+ PRUint32 number,
+ void * arg);
// member variables
static PLDHashTableOps ops;
PLDHashTable table;
PRBool initialized;
};
#endif // _nsCacheEntry_h_
--- a/netwerk/cache/src/nsCacheService.cpp
+++ b/netwerk/cache/src/nsCacheService.cpp
@@ -1937,17 +1937,17 @@ nsCacheService::ClearDoomList()
void
nsCacheService::ClearActiveEntries()
{
mActiveEntries.VisitEntries(DeactivateAndClearEntry, nsnull);
mActiveEntries.Shutdown();
}
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
nsCacheService::DeactivateAndClearEntry(PLDHashTable * table,
PLDHashEntryHdr * hdr,
PRUint32 number,
void * arg)
{
nsCacheEntry * entry = ((nsCacheEntryHashTableEntry *)hdr)->cacheEntry;
NS_ASSERTION(entry, "### active entry = nsnull!");
gService->ClearPendingRequests(entry);
@@ -1968,17 +1968,17 @@ nsCacheService::DoomActiveEntries()
mActiveEntries.VisitEntries(RemoveActiveEntry, &array);
PRUint32 count = array.Count();
for (PRUint32 i=0; i < count; ++i)
DoomEntry_Internal((nsCacheEntry *) array[i]);
}
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
nsCacheService::RemoveActiveEntry(PLDHashTable * table,
PLDHashEntryHdr * hdr,
PRUint32 number,
void * arg)
{
nsCacheEntry * entry = ((nsCacheEntryHashTableEntry *)hdr)->cacheEntry;
NS_ASSERTION(entry, "### active entry = nsnull!");
--- a/netwerk/cache/src/nsCacheService.h
+++ b/netwerk/cache/src/nsCacheService.h
@@ -208,25 +208,25 @@ private:
nsresult ProcessPendingRequests(nsCacheEntry * entry);
void ClearPendingRequests(nsCacheEntry * entry);
void ClearDoomList(void);
void ClearActiveEntries(void);
void DoomActiveEntries(void);
static
- PLDHashOperator PR_CALLBACK DeactivateAndClearEntry(PLDHashTable * table,
- PLDHashEntryHdr * hdr,
- PRUint32 number,
- void * arg);
+ PLDHashOperator DeactivateAndClearEntry(PLDHashTable * table,
+ PLDHashEntryHdr * hdr,
+ PRUint32 number,
+ void * arg);
static
- PLDHashOperator PR_CALLBACK RemoveActiveEntry(PLDHashTable * table,
- PLDHashEntryHdr * hdr,
- PRUint32 number,
- void * arg);
+ PLDHashOperator RemoveActiveEntry(PLDHashTable * table,
+ PLDHashEntryHdr * hdr,
+ PRUint32 number,
+ void * arg);
#if defined(PR_LOGGING)
void LogCacheStatistics();
#endif
/**
* Data Members
*/
--- a/netwerk/cache/src/nsDeleteDir.cpp
+++ b/netwerk/cache/src/nsDeleteDir.cpp
@@ -36,17 +36,17 @@
*
* ***** END LICENSE BLOCK ***** */
#include "nsDeleteDir.h"
#include "nsIFile.h"
#include "nsString.h"
#include "prthread.h"
-PR_STATIC_CALLBACK(void) DeleteDirThreadFunc(void *arg)
+static void DeleteDirThreadFunc(void *arg)
{
nsIFile *dir = static_cast<nsIFile *>(arg);
dir->Remove(PR_TRUE);
NS_RELEASE(dir);
}
nsresult DeleteDir(nsIFile *dirIn, PRBool moveToTrash, PRBool sync)
{
--- a/netwerk/cache/src/nsDiskCacheBinding.cpp
+++ b/netwerk/cache/src/nsDiskCacheBinding.cpp
@@ -55,42 +55,42 @@
#pragma mark HASHTABLE CALLBACKS
#endif
struct HashTableEntry : PLDHashEntryHdr {
nsDiskCacheBinding * mBinding;
};
-static PLDHashNumber PR_CALLBACK
+static PLDHashNumber
HashKey( PLDHashTable *table, const void *key)
{
return (PLDHashNumber) NS_PTR_TO_INT32(key);
}
-static PRBool PR_CALLBACK
+static PRBool
MatchEntry(PLDHashTable * /* table */,
const PLDHashEntryHdr * header,
const void * key)
{
HashTableEntry * hashEntry = (HashTableEntry *) header;
return (hashEntry->mBinding->mRecord.HashNumber() == (PLDHashNumber) NS_PTR_TO_INT32(key));
}
-static void PR_CALLBACK
+static void
MoveEntry(PLDHashTable * /* table */,
const PLDHashEntryHdr * src,
PLDHashEntryHdr * dst)
{
((HashTableEntry *)dst)->mBinding = ((HashTableEntry *)src)->mBinding;
}
-static void PR_CALLBACK
+static void
ClearEntry(PLDHashTable * /* table */,
PLDHashEntryHdr * header)
{
((HashTableEntry *)header)->mBinding = nsnull;
}
/******************************************************************************
@@ -359,17 +359,17 @@ nsDiskCacheBindery::RemoveBinding(nsDisk
PR_REMOVE_AND_INIT_LINK(binding);
}
/**
* ActiveBinding : PLDHashTable enumerate function to verify active bindings
*/
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
ActiveBinding(PLDHashTable * table,
PLDHashEntryHdr * hdr,
PRUint32 number,
void * arg)
{
nsDiskCacheBinding * binding = ((HashTableEntry *)hdr)->mBinding;
NS_ASSERTION(binding, "### disk cache binding = nsnull!");
--- a/netwerk/cache/src/nsMemoryCacheDevice.cpp
+++ b/netwerk/cache/src/nsMemoryCacheDevice.cpp
@@ -479,17 +479,17 @@ nsMemoryCacheDevice::SetCapacity(PRInt32
{
PRInt32 hardLimit = capacity * 1024; // convert k into bytes
PRInt32 softLimit = (hardLimit * 9) / 10;
AdjustMemoryLimits(softLimit, hardLimit);
}
#ifdef DEBUG
-static PLDHashOperator PR_CALLBACK
+static PLDHashOperator
CountEntry(PLDHashTable * table, PLDHashEntryHdr * hdr, PRUint32 number, void * arg)
{
PRInt32 *entryCount = (PRInt32 *)arg;
++(*entryCount);
return PL_DHASH_NEXT;
}
void
--- a/netwerk/cookie/src/nsCookieService.cpp
+++ b/netwerk/cookie/src/nsCookieService.cpp
@@ -333,17 +333,17 @@ LogSuccess(PRBool aSetCookie, nsIURI *aH
*
* these functions return:
* < 0 if the first element should come before the second element,
* 0 if the first element may come before or after the second element,
* > 0 if the first element should come after the second element.
******************************************************************************/
// comparison function for sorting cookies before sending to a server.
-PR_STATIC_CALLBACK(int)
+static int
compareCookiesForSending(const void *aElement1,
const void *aElement2,
void *aData)
{
const nsCookie *cookie1 = static_cast<const nsCookie*>(aElement1);
const nsCookie *cookie2 = static_cast<const nsCookie*>(aElement2);
// compare by cookie path length in accordance with RFC2109
@@ -806,17 +806,17 @@ struct nsGetEnumeratorData
nsGetEnumeratorData(nsCOMArray<nsICookie> *aArray, PRInt64 aTime)
: array(aArray)
, currentTime(aTime) {}
nsCOMArray<nsICookie> *array;
PRInt64 currentTime;
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
COMArrayCallback(nsCookieEntry *aEntry,
void *aArg)
{
nsGetEnumeratorData *data = static_cast<nsGetEnumeratorData *>(aArg);
for (nsCookie *cookie = aEntry->Head(); cookie; cookie = cookie->Next()) {
// only append non-expired cookies
if (cookie->Expiry() > data->currentTime)
@@ -2008,17 +2008,17 @@ void
nsCookieService::RemoveAllFromMemory()
{
// clearing the hashtable will call each nsCookieEntry's dtor,
// which releases all their respective children.
mHostTable.Clear();
mCookieCount = 0;
}
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
removeExpiredCallback(nsCookieEntry *aEntry,
void *aArg)
{
const PRInt64 ¤tTime = *static_cast<PRInt64*>(aArg);
for (nsListIter iter(aEntry, nsnull, aEntry->Head()); iter.current; ) {
if (iter.current->Expiry() <= currentTime)
// remove from list. this takes care of updating the iterator for us
nsCookieService::gCookieService->RemoveCookieFromList(iter);
@@ -2266,17 +2266,17 @@ nsCookieService::UpdateCookieInList(nsCo
if (NS_FAILED(rv)) {
NS_WARNING("db update failed!");
COOKIE_LOGSTRING(PR_LOG_WARNING, ("UpdateCookieInList(): updating db gave error %x", rv));
}
}
}
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
findOldestCallback(nsCookieEntry *aEntry,
void *aArg)
{
nsEnumerationData *data = static_cast<nsEnumerationData*>(aArg);
for (nsListIter iter(aEntry, nsnull, aEntry->Head()); iter.current; ++iter) {
// check if we've found the oldest cookie so far
if (data->oldestTime > iter.current->LastAccessed()) {
data->oldestTime = iter.current->LastAccessed();
--- a/netwerk/cookie/src/nsCookieService.h
+++ b/netwerk/cookie/src/nsCookieService.h
@@ -206,12 +206,12 @@ class nsCookieService : public nsICookie
PRUint16 mMaxNumberOfCookies;
PRUint16 mMaxCookiesPerHost;
// private static member, used to cache a ptr to nsCookieService,
// so we can make nsCookieService a singleton xpcom object.
static nsCookieService *gCookieService;
// this callback needs access to member functions
- friend PLDHashOperator PR_CALLBACK removeExpiredCallback(nsCookieEntry *aEntry, void *aArg);
+ friend PLDHashOperator removeExpiredCallback(nsCookieEntry *aEntry, void *aArg);
};
#endif // nsCookieService_h__
--- a/netwerk/dns/src/nsHostResolver.cpp
+++ b/netwerk/dns/src/nsHostResolver.cpp
@@ -204,46 +204,46 @@ nsHostRecord::~nsHostRecord()
//----------------------------------------------------------------------------
struct nsHostDBEnt : PLDHashEntryHdr
{
nsHostRecord *rec;
};
-PR_STATIC_CALLBACK(PLDHashNumber)
+static PLDHashNumber
HostDB_HashKey(PLDHashTable *table, const void *key)
{
const nsHostKey *hk = static_cast<const nsHostKey *>(key);
return PL_DHashStringKey(table, hk->host) ^ hk->flags ^ hk->af;
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
HostDB_MatchEntry(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key)
{
const nsHostDBEnt *he = static_cast<const nsHostDBEnt *>(entry);
const nsHostKey *hk = static_cast<const nsHostKey *>(key);
return !strcmp(he->rec->host, hk->host) &&
he->rec->flags == hk->flags &&
he->rec->af == hk->af;
}
-PR_STATIC_CALLBACK(void)
+static void
HostDB_MoveEntry(PLDHashTable *table,
const PLDHashEntryHdr *from,
PLDHashEntryHdr *to)
{
static_cast<nsHostDBEnt *>(to)->rec =
static_cast<const nsHostDBEnt *>(from)->rec;
}
-PR_STATIC_CALLBACK(void)
+static void
HostDB_ClearEntry(PLDHashTable *table,
PLDHashEntryHdr *entry)
{
LOG(("evicting record\n"));
nsHostDBEnt *he = static_cast<nsHostDBEnt *>(entry);
#if defined(DEBUG) && defined(PR_LOGGING)
if (!he->rec->addr_info)
LOG(("%s: => no addr_info\n", he->rec->host));
@@ -263,17 +263,17 @@ HostDB_ClearEntry(PLDHashTable *table,
PR_NetAddrToString(&addr, buf, sizeof(buf));
LOG((" %s\n", buf));
}
}
#endif
NS_RELEASE(he->rec);
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
HostDB_InitEntry(PLDHashTable *table,
PLDHashEntryHdr *entry,
const void *key)
{
nsHostDBEnt *he = static_cast<nsHostDBEnt *>(entry);
nsHostRecord::Create(static_cast<const nsHostKey *>(key), &he->rec);
return PR_TRUE;
}
@@ -285,17 +285,17 @@ static PLDHashTableOps gHostDB_ops =
HostDB_HashKey,
HostDB_MatchEntry,
HostDB_MoveEntry,
HostDB_ClearEntry,
PL_DHashFinalizeStub,
HostDB_InitEntry,
};
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
HostDB_RemoveEntry(PLDHashTable *table,
PLDHashEntryHdr *hdr,
PRUint32 number,
void *arg)
{
return PL_DHASH_REMOVE;
}
@@ -671,17 +671,17 @@ nsHostResolver::OnLookupComplete(nsHostR
}
}
NS_RELEASE(rec);
}
//----------------------------------------------------------------------------
-void PR_CALLBACK
+void
nsHostResolver::ThreadFunc(void *arg)
{
LOG(("nsHostResolver::ThreadFunc entering\n"));
#if defined(RES_RETRY_ON_FAILURE)
nsResState rs;
#endif
nsHostResolver *resolver = (nsHostResolver *) arg;
--- a/netwerk/dns/src/nsHostResolver.h
+++ b/netwerk/dns/src/nsHostResolver.h
@@ -216,17 +216,17 @@ private:
nsHostResolver(PRUint32 maxCacheEntries=50, PRUint32 maxCacheLifetime=1);
~nsHostResolver();
nsresult Init();
nsresult IssueLookup(nsHostRecord *);
PRBool GetHostToLookup(nsHostRecord **);
void OnLookupComplete(nsHostRecord *, nsresult, PRAddrInfo *);
- PR_STATIC_CALLBACK(void) ThreadFunc(void *);
+ static void ThreadFunc(void *);
PRUint32 mMaxCacheEntries;
PRUint32 mMaxCacheLifetime;
PRLock *mLock;
PRCondVar *mIdleThreadCV; // non-null if idle thread
PRBool mHaveIdleThread;
PRUint32 mThreadCount;
PLDHashTable mDB;
--- a/netwerk/protocol/http/src/nsHttp.cpp
+++ b/netwerk/protocol/http/src/nsHttp.cpp
@@ -86,26 +86,26 @@ NewHeapAtom(const char *value) {
// add this heap atom to the list of all heap atoms
a->next = sHeapAtoms;
sHeapAtoms = a;
return a;
}
// Hash string ignore case, based on PL_HashString
-PR_STATIC_CALLBACK(PLDHashNumber)
+static PLDHashNumber
StringHash(PLDHashTable *table, const void *key)
{
PLDHashNumber h = 0;
for (const char *s = reinterpret_cast<const char*>(key); *s; ++s)
h = PR_ROTATE_LEFT32(h, 4) ^ nsCRT::ToLower(*s);
return h;
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
StringCompare(PLDHashTable *table, const PLDHashEntryHdr *entry,
const void *testKey)
{
const void *entryKey =
reinterpret_cast<const PLDHashEntryStub *>(entry)->key;
return PL_strcasecmp(reinterpret_cast<const char *>(entryKey),
reinterpret_cast<const char *>(testKey)) == 0;
--- a/netwerk/protocol/http/src/nsHttpAuthCache.h
+++ b/netwerk/protocol/http/src/nsHttpAuthCache.h
@@ -248,20 +248,20 @@ public:
private:
nsHttpAuthNode *LookupAuthNode(const char *scheme,
const char *host,
PRInt32 port,
nsCString &key);
// hash table allocation functions
- static void* PR_CALLBACK AllocTable(void *, PRSize size);
- static void PR_CALLBACK FreeTable(void *, void *item);
- static PLHashEntry* PR_CALLBACK AllocEntry(void *, const void *key);
- static void PR_CALLBACK FreeEntry(void *, PLHashEntry *he, PRUintn flag);
+ static void* AllocTable(void *, PRSize size);
+ static void FreeTable(void *, void *item);
+ static PLHashEntry* AllocEntry(void *, const void *key);
+ static void FreeEntry(void *, PLHashEntry *he, PRUintn flag);
static PLHashAllocOps gHashAllocOps;
private:
PLHashTable *mDB; // "host:port" --> nsHttpAuthNode
};
#endif // nsHttpAuthCache_h__
--- a/netwerk/protocol/http/src/nsHttpChannel.cpp
+++ b/netwerk/protocol/http/src/nsHttpChannel.cpp
@@ -2525,17 +2525,17 @@ nsHttpChannel::ClearBogusContentEncoding
mResponseHead->ClearHeader(nsHttp::Content_Encoding);
}
}
//-----------------------------------------------------------------------------
// nsHttpChannel <redirect>
//-----------------------------------------------------------------------------
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
CopyProperties(const nsAString& aKey, nsIVariant *aData, void *aClosure)
{
nsIWritablePropertyBag* bag = static_cast<nsIWritablePropertyBag*>
(aClosure);
bag->SetProperty(aKey, aData);
return PL_DHASH_NEXT;
}
--- a/netwerk/protocol/http/src/nsHttpConnectionMgr.cpp
+++ b/netwerk/protocol/http/src/nsHttpConnectionMgr.cpp
@@ -288,29 +288,29 @@ nsHttpConnectionMgr::ProcessPendingQ(nsH
if (NS_FAILED(rv))
NS_RELEASE(ci);
return rv;
}
//-----------------------------------------------------------------------------
// enumeration callbacks
-PRIntn PR_CALLBACK
+PRIntn
nsHttpConnectionMgr::ProcessOneTransactionCB(nsHashKey *key, void *data, void *closure)
{
nsHttpConnectionMgr *self = (nsHttpConnectionMgr *) closure;
nsConnectionEntry *ent = (nsConnectionEntry *) data;
if (self->ProcessPendingQForEntry(ent))
return kHashEnumerateStop;
return kHashEnumerateNext;
}
-PRIntn PR_CALLBACK
+PRIntn
nsHttpConnectionMgr::PurgeOneIdleConnectionCB(nsHashKey *key, void *data, void *closure)
{
nsHttpConnectionMgr *self = (nsHttpConnectionMgr *) closure;
nsConnectionEntry *ent = (nsConnectionEntry *) data;
if (ent->mIdleConns.Count() > 0) {
nsHttpConnection *conn = (nsHttpConnection *) ent->mIdleConns[0];
ent->mIdleConns.RemoveElementAt(0);
@@ -318,17 +318,17 @@ nsHttpConnectionMgr::PurgeOneIdleConnect
NS_RELEASE(conn);
self->mNumIdleConns--;
return kHashEnumerateStop;
}
return kHashEnumerateNext;
}
-PRIntn PR_CALLBACK
+PRIntn
nsHttpConnectionMgr::PruneDeadConnectionsCB(nsHashKey *key, void *data, void *closure)
{
nsHttpConnectionMgr *self = (nsHttpConnectionMgr *) closure;
nsConnectionEntry *ent = (nsConnectionEntry *) data;
LOG((" pruning [ci=%s]\n", ent->mConnInfo->HashKey().get()));
PRInt32 count = ent->mIdleConns.Count();
@@ -366,17 +366,17 @@ nsHttpConnectionMgr::PruneDeadConnection
// else, use this opportunity to compact our arrays...
ent->mIdleConns.Compact();
ent->mActiveConns.Compact();
ent->mPendingQ.Compact();
return kHashEnumerateNext;
}
-PRIntn PR_CALLBACK
+PRIntn
nsHttpConnectionMgr::ShutdownPassCB(nsHashKey *key, void *data, void *closure)
{
nsHttpConnectionMgr *self = (nsHttpConnectionMgr *) closure;
nsConnectionEntry *ent = (nsConnectionEntry *) data;
nsHttpTransaction *trans;
nsHttpConnection *conn;
--- a/netwerk/protocol/http/src/nsHttpConnectionMgr.h
+++ b/netwerk/protocol/http/src/nsHttpConnectionMgr.h
@@ -199,20 +199,20 @@ private:
PRUint16 mMaxPersistConnsPerProxy;
PRUint16 mMaxRequestDelay; // in seconds
PRUint16 mMaxPipelinedRequests;
//-------------------------------------------------------------------------
// NOTE: these members are only accessed on the socket transport thread
//-------------------------------------------------------------------------
- static PRIntn PR_CALLBACK ProcessOneTransactionCB(nsHashKey *, void *, void *);
- static PRIntn PR_CALLBACK PurgeOneIdleConnectionCB(nsHashKey *, void *, void *);
- static PRIntn PR_CALLBACK PruneDeadConnectionsCB(nsHashKey *, void *, void *);
- static PRIntn PR_CALLBACK ShutdownPassCB(nsHashKey *, void *, void *);
+ static PRIntn ProcessOneTransactionCB(nsHashKey *, void *, void *);
+ static PRIntn PurgeOneIdleConnectionCB(nsHashKey *, void *, void *);
+ static PRIntn PruneDeadConnectionsCB(nsHashKey *, void *, void *);
+ static PRIntn ShutdownPassCB(nsHashKey *, void *, void *);
PRBool ProcessPendingQForEntry(nsConnectionEntry *);
PRBool AtActiveConnectionLimit(nsConnectionEntry *, PRUint8 caps);
void GetConnection(nsConnectionEntry *, PRUint8 caps, nsHttpConnection **);
nsresult DispatchTransaction(nsConnectionEntry *, nsAHttpTransaction *,
PRUint8 caps, nsHttpConnection *);
PRBool BuildPipeline(nsConnectionEntry *, nsAHttpTransaction *, nsHttpPipeline **);
nsresult ProcessNewTransaction(nsHttpTransaction *);
--- a/netwerk/socket/base/nsSOCKSIOLayer.cpp
+++ b/netwerk/socket/base/nsSOCKSIOLayer.cpp
@@ -586,17 +586,17 @@ ConnectSOCKS4(PRFileDesc *fd, const PRNe
return NS_ERROR_FAILURE;
}
return NS_OK;
}
-static PRStatus PR_CALLBACK
+static PRStatus
nsSOCKSIOLayerConnect(PRFileDesc *fd, const PRNetAddr *addr, PRIntervalTime /*timeout*/)
{
PRStatus status;
nsSOCKSSocketInfo * info = (nsSOCKSSocketInfo*) fd->secret;
if (info == NULL) return PR_FAILURE;
@@ -724,79 +724,79 @@ nsSOCKSIOLayerConnect(PRFileDesc *fd, co
PR_SetSocketOption(fd, &sockopt);
// we're set-up and connected.
// this socket can be used as normal now.
return PR_SUCCESS;
}
-static PRStatus PR_CALLBACK
+static PRStatus
nsSOCKSIOLayerClose(PRFileDesc *fd)
{
nsSOCKSSocketInfo * info = (nsSOCKSSocketInfo*) fd->secret;
PRDescIdentity id = PR_GetLayersIdentity(fd);
if (info && id == nsSOCKSIOLayerIdentity)
{
NS_RELEASE(info);
fd->identity = PR_INVALID_IO_LAYER;
}
return fd->lower->methods->close(fd->lower);
}
-static PRFileDesc* PR_CALLBACK
+static PRFileDesc*
nsSOCKSIOLayerAccept(PRFileDesc *fd, PRNetAddr *addr, PRIntervalTime timeout)
{
// TODO: implement SOCKS support for accept
return fd->lower->methods->accept(fd->lower, addr, timeout);
}
-static PRInt32 PR_CALLBACK
+static PRInt32
nsSOCKSIOLayerAcceptRead(PRFileDesc *sd, PRFileDesc **nd, PRNetAddr **raddr, void *buf, PRInt32 amount, PRIntervalTime timeout)
{
// TODO: implement SOCKS support for accept, then read from it
return sd->lower->methods->acceptread(sd->lower, nd, raddr, buf, amount, timeout);
}
-static PRStatus PR_CALLBACK
+static PRStatus
nsSOCKSIOLayerBind(PRFileDesc *fd, const PRNetAddr *addr)
{
// TODO: implement SOCKS support for bind (very similar to connect)
return fd->lower->methods->bind(fd->lower, addr);
}
-static PRStatus PR_CALLBACK
+static PRStatus
nsSOCKSIOLayerGetName(PRFileDesc *fd, PRNetAddr *addr)
{
nsSOCKSSocketInfo * info = (nsSOCKSSocketInfo*) fd->secret;
if (info != NULL && addr != NULL) {
if (info->GetExternalProxyAddr(&addr) == NS_OK)
return PR_SUCCESS;
}
return PR_FAILURE;
}
-static PRStatus PR_CALLBACK
+static PRStatus
nsSOCKSIOLayerGetPeerName(PRFileDesc *fd, PRNetAddr *addr)
{
nsSOCKSSocketInfo * info = (nsSOCKSSocketInfo*) fd->secret;
if (info != NULL && addr != NULL) {
if (info->GetDestinationAddr(&addr) == NS_OK)
return PR_SUCCESS;
}
return PR_FAILURE;
}
-static PRStatus PR_CALLBACK
+static PRStatus
nsSOCKSIOLayerListen(PRFileDesc *fd, PRIntn backlog)
{
// TODO: implement SOCKS support for listen
return fd->lower->methods->listen(fd->lower, backlog);
}
// add SOCKS IO layer to an existing socket
nsresult
--- a/netwerk/streamconv/src/nsStreamConverterService.cpp
+++ b/netwerk/streamconv/src/nsStreamConverterService.cpp
@@ -80,17 +80,17 @@ nsStreamConverterService::nsStreamConver
}
nsStreamConverterService::~nsStreamConverterService() {
NS_ASSERTION(mAdjacencyList, "init wasn't called, or the retval was ignored");
delete mAdjacencyList;
}
// Delete all the entries in the adjacency list
-static PRBool PR_CALLBACK DeleteAdjacencyEntry(nsHashKey *aKey, void *aData, void* closure) {
+static PRBool DeleteAdjacencyEntry(nsHashKey *aKey, void *aData, void* closure) {
SCTableData *entry = (SCTableData*)aData;
NS_ASSERTION(entry->key && entry->data.edges, "malformed adjacency list entry");
delete entry->key;
delete entry->data.edges;
delete entry;
return PR_TRUE;
}
@@ -254,17 +254,17 @@ nsStreamConverterService::ParseFromTo(co
aToRes.Assign(toStr);
return NS_OK;
}
// nsObjectHashtable enumerator functions.
// Initializes the BFS state table.
-static PRBool PR_CALLBACK InitBFSTable(nsHashKey *aKey, void *aData, void* closure) {
+static PRBool InitBFSTable(nsHashKey *aKey, void *aData, void* closure) {
NS_ASSERTION((SCTableData*)aData, "no data in the table enumeration");
nsHashtable *BFSTable = (nsHashtable*)closure;
if (!BFSTable) return PR_FALSE;
BFSState *state = new BFSState;
if (!state) return PR_FALSE;
@@ -279,17 +279,17 @@ static PRBool PR_CALLBACK InitBFSTable(n
}
data->data.state = state;
BFSTable->Put(aKey, data);
return PR_TRUE;
}
// cleans up the BFS state table
-static PRBool PR_CALLBACK DeleteBFSEntry(nsHashKey *aKey, void *aData, void *closure) {
+static PRBool DeleteBFSEntry(nsHashKey *aKey, void *aData, void *closure) {
SCTableData *data = (SCTableData*)aData;
BFSState *state = data->data.state;
delete state;
data->key = nsnull;
delete data;
return PR_TRUE;
}
--- a/parser/htmlparser/src/nsExpatDriver.cpp
+++ b/parser/htmlparser/src/nsExpatDriver.cpp
@@ -68,139 +68,139 @@ static const PRUnichar kUTF16[] = { 'U',
#ifdef PR_LOGGING
static PRLogModuleInfo *gExpatDriverLog = PR_NewLogModule("expatdriver");
#endif
/***************************** EXPAT CALL BACKS ******************************/
// The callback handlers that get called from the expat parser.
-PR_STATIC_CALLBACK(void)
+static void
Driver_HandleXMLDeclaration(void *aUserData,
const XML_Char *aVersion,
const XML_Char *aEncoding,
int aStandalone)
{
NS_ASSERTION(aUserData, "expat driver should exist");
if (aUserData) {
nsExpatDriver* driver = static_cast<nsExpatDriver*>(aUserData);
driver->HandleXMLDeclaration(aVersion, aEncoding, aStandalone);
}
}
-PR_STATIC_CALLBACK(void)
+static void
Driver_HandleStartElement(void *aUserData,
const XML_Char *aName,
const XML_Char **aAtts)
{
NS_ASSERTION(aUserData, "expat driver should exist");
if (aUserData) {
static_cast<nsExpatDriver*>(aUserData)->HandleStartElement(aName,
aAtts);
}
}
-PR_STATIC_CALLBACK(void)
+static void
Driver_HandleEndElement(void *aUserData,
const XML_Char *aName)
{
NS_ASSERTION(aUserData, "expat driver should exist");
if (aUserData) {
static_cast<nsExpatDriver*>(aUserData)->HandleEndElement(aName);
}
}
-PR_STATIC_CALLBACK(void)
+static void
Driver_HandleCharacterData(void *aUserData,
const XML_Char *aData,
int aLength)
{
NS_ASSERTION(aUserData, "expat driver should exist");
if (aUserData) {
nsExpatDriver* driver = static_cast<nsExpatDriver*>(aUserData);
driver->HandleCharacterData(aData, PRUint32(aLength));
}
}
-PR_STATIC_CALLBACK(void)
+static void
Driver_HandleComment(void *aUserData,
const XML_Char *aName)
{
NS_ASSERTION(aUserData, "expat driver should exist");
if(aUserData) {
static_cast<nsExpatDriver*>(aUserData)->HandleComment(aName);
}
}
-PR_STATIC_CALLBACK(void)
+static void
Driver_HandleProcessingInstruction(void *aUserData,
const XML_Char *aTarget,
const XML_Char *aData)
{
NS_ASSERTION(aUserData, "expat driver should exist");
if (aUserData) {
nsExpatDriver* driver = static_cast<nsExpatDriver*>(aUserData);
driver->HandleProcessingInstruction(aTarget, aData);
}
}
-PR_STATIC_CALLBACK(void)
+static void
Driver_HandleDefault(void *aUserData,
const XML_Char *aData,
int aLength)
{
NS_ASSERTION(aUserData, "expat driver should exist");
if (aUserData) {
nsExpatDriver* driver = static_cast<nsExpatDriver*>(aUserData);
driver->HandleDefault(aData, PRUint32(aLength));
}
}
-PR_STATIC_CALLBACK(void)
+static void
Driver_HandleStartCdataSection(void *aUserData)
{
NS_ASSERTION(aUserData, "expat driver should exist");
if (aUserData) {
static_cast<nsExpatDriver*>(aUserData)->HandleStartCdataSection();
}
}
-PR_STATIC_CALLBACK(void)
+static void
Driver_HandleEndCdataSection(void *aUserData)
{
NS_ASSERTION(aUserData, "expat driver should exist");
if (aUserData) {
static_cast<nsExpatDriver*>(aUserData)->HandleEndCdataSection();
}
}
-PR_STATIC_CALLBACK(void)
+static void
Driver_HandleStartDoctypeDecl(void *aUserData,
const XML_Char *aDoctypeName,
const XML_Char *aSysid,
const XML_Char *aPubid,
int aHasInternalSubset)
{
NS_ASSERTION(aUserData, "expat driver should exist");
if (aUserData) {
static_cast<nsExpatDriver*>(aUserData)->
HandleStartDoctypeDecl(aDoctypeName, aSysid, aPubid, !!aHasInternalSubset);
}
}
-PR_STATIC_CALLBACK(void)
+static void
Driver_HandleEndDoctypeDecl(void *aUserData)
{
NS_ASSERTION(aUserData, "expat driver should exist");
if (aUserData) {
static_cast<nsExpatDriver*>(aUserData)->HandleEndDoctypeDecl();
}
}
-PR_STATIC_CALLBACK(int)
+static int
Driver_HandleExternalEntityRef(void *aExternalEntityRefHandler,
const XML_Char *aOpenEntityNames,
const XML_Char *aBase,
const XML_Char *aSystemId,
const XML_Char *aPublicId)
{
NS_ASSERTION(aExternalEntityRefHandler, "expat driver should exist");
if (!aExternalEntityRefHandler) {
@@ -209,54 +209,54 @@ Driver_HandleExternalEntityRef(void *aEx
nsExpatDriver* driver = static_cast<nsExpatDriver*>
(aExternalEntityRefHandler);
return driver->HandleExternalEntityRef(aOpenEntityNames, aBase, aSystemId,
aPublicId);
}
-PR_STATIC_CALLBACK(void)
+static void
Driver_HandleStartNamespaceDecl(void *aUserData,
const XML_Char *aPrefix,
const XML_Char *aUri)
{
NS_ASSERTION(aUserData, "expat driver should exist");
if (aUserData) {
static_cast<nsExpatDriver*>(aUserData)->
HandleStartNamespaceDecl(aPrefix, aUri);
}
}
-PR_STATIC_CALLBACK(void)
+static void
Driver_HandleEndNamespaceDecl(void *aUserData,
const XML_Char *aPrefix)
{
NS_ASSERTION(aUserData, "expat driver should exist");
if (aUserData) {
static_cast<nsExpatDriver*>(aUserData)->
HandleEndNamespaceDecl(aPrefix);
}
}
-PR_STATIC_CALLBACK(void)
+static void
Driver_HandleNotationDecl(void *aUserData,
const XML_Char *aNotationName,
const XML_Char *aBase,
const XML_Char *aSysid,
const XML_Char *aPubid)
{
NS_ASSERTION(aUserData, "expat driver should exist");
if (aUserData) {
static_cast<nsExpatDriver*>(aUserData)->
HandleNotationDecl(aNotationName, aBase, aSysid, aPubid);
}
}
-PR_STATIC_CALLBACK(void)
+static void
Driver_HandleUnparsedEntityDecl(void *aUserData,
const XML_Char *aEntityName,
const XML_Char *aBase,
const XML_Char *aSysid,
const XML_Char *aPubid,
const XML_Char *aNotationName)
{
NS_ASSERTION(aUserData, "expat driver should exist");
--- a/parser/htmlparser/src/nsHTMLEntities.cpp
+++ b/parser/htmlparser/src/nsHTMLEntities.cpp
@@ -49,35 +49,35 @@ struct EntityNode {
PRInt32 mUnicode;
};
struct EntityNodeEntry : public PLDHashEntryHdr
{
const EntityNode* node;
};
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
matchNodeString(PLDHashTable*, const PLDHashEntryHdr* aHdr,
const void* key)
{
const EntityNodeEntry* entry = static_cast<const EntityNodeEntry*>(aHdr);
const char* str = static_cast<const char*>(key);
return (nsCRT::strcmp(entry->node->mStr, str) == 0);
}
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
matchNodeUnicode(PLDHashTable*, const PLDHashEntryHdr* aHdr,
const void* key)
{
const EntityNodeEntry* entry = static_cast<const EntityNodeEntry*>(aHdr);
const PRInt32 ucode = NS_PTR_TO_INT32(key);
return (entry->node->mUnicode == ucode);
}
-PR_STATIC_CALLBACK(PLDHashNumber)
+static PLDHashNumber
hashUnicodeValue(PLDHashTable*, const void* key)
{
// key is actually the unicode value
return PLDHashNumber(NS_PTR_TO_INT32(key));
}
static const PLDHashTableOps EntityToUnicodeOps = {
--- a/parser/htmlparser/src/nsHTMLTags.cpp
+++ b/parser/htmlparser/src/nsHTMLTags.cpp
@@ -285,35 +285,35 @@ const PRUnichar* const nsHTMLTags::sTagU
nsIAtom* nsHTMLTags::sTagAtomTable[eHTMLTag_userdefined - 1];
PRInt32 nsHTMLTags::gTableRefCount;
PLHashTable* nsHTMLTags::gTagTable;
PLHashTable* nsHTMLTags::gTagAtomTable;
// PRUnichar* -> id hash
-PR_STATIC_CALLBACK(PLHashNumber)
+static PLHashNumber
HTMLTagsHashCodeUCPtr(const void *key)
{
const PRUnichar *str = (const PRUnichar *)key;
return nsCRT::HashCode(str);
}
-PR_STATIC_CALLBACK(PRIntn)
+static PRIntn
HTMLTagsKeyCompareUCPtr(const void *key1, const void *key2)
{
const PRUnichar *str1 = (const PRUnichar *)key1;
const PRUnichar *str2 = (const PRUnichar *)key2;
return nsCRT::strcmp(str1, str2) == 0;
}
// nsIAtom* -> id hash
-PR_STATIC_CALLBACK(PLHashNumber)
+static PLHashNumber
HTMLTagsHashCodeAtom(const void *key)
{
return NS_PTR_TO_INT32(key) >> 2;
}
#define NS_HTMLTAG_NAME_MAX_LENGTH 10
// static
--- a/parser/htmlparser/src/nsParserModule.cpp
+++ b/parser/htmlparser/src/nsParserModule.cpp
@@ -111,17 +111,17 @@ static const nsModuleComponentInfo gComp
NS_SAXXMLREADER_CID,
NS_SAXXMLREADER_CONTRACTID,
nsSAXXMLReaderConstructor
}
};
static PRBool gInitialized = PR_FALSE;
-PR_STATIC_CALLBACK(nsresult)
+static nsresult
Initialize(nsIModule* aSelf)
{
if (!gInitialized) {
nsresult rv = nsHTMLTags::AddRefTable();
NS_ENSURE_SUCCESS(rv, rv);
rv = nsHTMLEntities::AddRefTable();
if (NS_FAILED(rv)) {
@@ -137,17 +137,17 @@ Initialize(nsIModule* aSelf)
#ifdef DEBUG
nsHTMLTags::TestTagTable();
#endif
return nsParser::Init();
}
-PR_STATIC_CALLBACK(void)
+static void
Shutdown(nsIModule* aSelf)
{
if (gInitialized) {
nsHTMLTags::ReleaseTable();
nsHTMLEntities::ReleaseTable();
nsDTDContext::ReleaseGlobalObjects();
nsParser::Shutdown();
CNewlineToken::FreeNewline();
--- a/rdf/base/src/nsInMemoryDataSource.cpp
+++ b/rdf/base/src/nsInMemoryDataSource.cpp
@@ -140,17 +140,17 @@ public:
PL_DHashTableEnumerate(aAssertion->u.hash.mPropertyHash,
DeletePropertyHashEntry, &aAllocator);
PL_DHashTableDestroy(aAssertion->u.hash.mPropertyHash);
aAssertion->u.hash.mPropertyHash = nsnull;
}
aAssertion->~Assertion();
aAllocator.Free(aAssertion, sizeof(*aAssertion)); }
- static PLDHashOperator PR_CALLBACK
+ static PLDHashOperator
DeletePropertyHashEntry(PLDHashTable* aTable, PLDHashEntryHdr* aHdr,
PRUint32 aNumber, void* aArg);
Assertion(nsIRDFResource* aSource, // normal assertion
nsIRDFResource* aProperty,
nsIRDFNode* aTarget,
PRBool aTruthValue);
Assertion(nsIRDFResource* aSource); // PLDHashTable assertion variant
@@ -271,17 +271,17 @@ Assertion::~Assertion()
NS_RELEASE(mSource);
if (!mHashEntry)
{
NS_RELEASE(u.as.mProperty);
NS_RELEASE(u.as.mTarget);
}
}
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
Assertion::DeletePropertyHashEntry(PLDHashTable* aTable, PLDHashEntryHdr* aHdr,
PRUint32 aNumber, void* aArg)
{
Entry* entry = reinterpret_cast<Entry*>(aHdr);
nsFixedSizeAllocator* allocator = static_cast<nsFixedSizeAllocator*>(aArg);
Assertion* as = entry->mAssertions;
while (as) {
@@ -322,21 +322,21 @@ protected:
nsCOMArray<nsIRDFObserver> mObservers;
PRUint32 mNumObservers;
// VisitFoo needs to block writes, [Un]Assert only allowed
// during mReadCount == 0
PRUint32 mReadCount;
- static PLDHashOperator PR_CALLBACK
+ static PLDHashOperator
DeleteForwardArcsEntry(PLDHashTable* aTable, PLDHashEntryHdr* aHdr,
PRUint32 aNumber, void* aArg);
- static PLDHashOperator PR_CALLBACK
+ static PLDHashOperator
ResourceEnumerator(PLDHashTable* aTable, PLDHashEntryHdr* aHdr,
PRUint32 aNumber, void* aArg);
friend class InMemoryArcsEnumeratorImpl;
friend class InMemoryAssertionEnumeratorImpl;
friend class InMemoryResourceEnumeratorImpl; // b/c it needs to enumerate mForwardArcs
// Thread-safe writer implementation methods.
@@ -373,17 +373,17 @@ public:
// nsIRDFPurgeableDataSource methods
NS_DECL_NSIRDFPURGEABLEDATASOURCE
// rdfIDataSource methods
NS_DECL_RDFIDATASOURCE
protected:
- static PLDHashOperator PR_CALLBACK
+ static PLDHashOperator
SweepForwardArcsEntries(PLDHashTable* aTable, PLDHashEntryHdr* aHdr,
PRUint32 aNumber, void* aArg);
public:
// Implementation methods
Assertion*
GetForwardArcs(nsIRDFResource* u) {
PLDHashEntryHdr* hdr = PL_DHashTableOperate(&mForwardArcs, u, PL_DHASH_LOOKUP);
@@ -656,17 +656,17 @@ private:
nsCOMPtr<nsISupportsArray> mHashArcs;
InMemoryArcsEnumeratorImpl(InMemoryDataSource* aDataSource,
nsIRDFResource* aSource,
nsIRDFNode* aTarget);
virtual ~InMemoryArcsEnumeratorImpl();
- static PLDHashOperator PR_CALLBACK
+ static PLDHashOperator
ArcEnumerator(PLDHashTable* aTable, PLDHashEntryHdr* aHdr,
PRUint32 aNumber, void* aArg);
public:
// nsISupports interface
NS_DECL_ISUPPORTS
// nsISimpleEnumerator interface
@@ -690,17 +690,17 @@ public:
// Grab the pool from the datasource; since we keep the
// datasource alive, this has to be safe.
nsFixedSizeAllocator& pool = aEnumerator->mDataSource->mAllocator;
aEnumerator->~InMemoryArcsEnumeratorImpl();
pool.Free(aEnumerator, sizeof(*aEnumerator)); }
};
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
InMemoryArcsEnumeratorImpl::ArcEnumerator(PLDHashTable* aTable,
PLDHashEntryHdr* aHdr,
PRUint32 aNumber, void* aArg)
{
Entry* entry = reinterpret_cast<Entry*>(aHdr);
nsISupportsArray* resources = static_cast<nsISupportsArray*>(aArg);
resources->AppendElement(entry->mNode);
@@ -959,17 +959,17 @@ InMemoryDataSource::~InMemoryDataSource(
if (mReverseArcs.ops)
PL_DHashTableFinish(&mReverseArcs);
PR_LOG(gLog, PR_LOG_NOTICE,
("InMemoryDataSource(%p): destroyed.", this));
}
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
InMemoryDataSource::DeleteForwardArcsEntry(PLDHashTable* aTable, PLDHashEntryHdr* aHdr,
PRUint32 aNumber, void* aArg)
{
Entry* entry = reinterpret_cast<Entry*>(aHdr);
nsFixedSizeAllocator* allocator = static_cast<nsFixedSizeAllocator*>(aArg);
Assertion* as = entry->mAssertions;
while (as) {
@@ -1780,17 +1780,17 @@ InMemoryDataSource::ArcLabelsOut(nsIRDFR
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(result);
*aResult = result;
return NS_OK;
}
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
InMemoryDataSource::ResourceEnumerator(PLDHashTable* aTable,
PLDHashEntryHdr* aHdr,
PRUint32 aNumber, void* aArg)
{
Entry* entry = reinterpret_cast<Entry*>(aHdr);
nsISupportsArray* resources = static_cast<nsISupportsArray*>(aArg);
resources->AppendElement(entry->mNode);
@@ -2043,17 +2043,17 @@ InMemoryDataSource::Sweep()
doomed->mNext = doomed->u.as.mInvNext = nsnull;
doomed->Release(mAllocator);
}
return NS_OK;
}
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
InMemoryDataSource::SweepForwardArcsEntries(PLDHashTable* aTable,
PLDHashEntryHdr* aHdr,
PRUint32 aNumber, void* aArg)
{
PLDHashOperator result = PL_DHASH_NEXT;
Entry* entry = reinterpret_cast<Entry*>(aHdr);
SweepInfo* info = static_cast<SweepInfo*>(aArg);
@@ -2146,17 +2146,17 @@ public:
VisitorClosure(rdfITripleVisitor* aVisitor) :
mVisitor(aVisitor),
mRv(NS_OK)
{}
rdfITripleVisitor* mVisitor;
nsresult mRv;
};
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
SubjectEnumerator(PLDHashTable* aTable, PLDHashEntryHdr* aHdr,
PRUint32 aNumber, void* aArg) {
Entry* entry = reinterpret_cast<Entry*>(aHdr);
VisitorClosure* closure = static_cast<VisitorClosure*>(aArg);
nsresult rv;
nsCOMPtr<nsIRDFNode> subject = do_QueryInterface(entry->mNode, &rv);
NS_ENSURE_SUCCESS(rv, PL_DHASH_NEXT);
@@ -2188,17 +2188,17 @@ class TriplesInnerClosure
{
public:
TriplesInnerClosure(nsIRDFNode* aSubject, VisitorClosure* aClosure) :
mSubject(aSubject), mOuter(aClosure) {}
nsIRDFNode* mSubject;
VisitorClosure* mOuter;
};
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
TriplesInnerEnumerator(PLDHashTable* aTable, PLDHashEntryHdr* aHdr,
PRUint32 aNumber, void* aArg) {
Entry* entry = reinterpret_cast<Entry*>(aHdr);
Assertion* assertion = entry->mAssertions;
TriplesInnerClosure* closure =
static_cast<TriplesInnerClosure*>(aArg);
while (assertion) {
NS_ASSERTION(!assertion->mHashEntry, "shouldn't have to hashes");
@@ -2209,17 +2209,17 @@ TriplesInnerEnumerator(PLDHashTable* aTa
assertion->u.as.mTruthValue);
if (NS_FAILED(cls->mRv) || cls->mRv == NS_RDF_STOP_VISIT) {
return PL_DHASH_STOP;
}
assertion = assertion->mNext;
}
return PL_DHASH_NEXT;
}
-PLDHashOperator PR_CALLBACK
+PLDHashOperator
TriplesEnumerator(PLDHashTable* aTable, PLDHashEntryHdr* aHdr,
PRUint32 aNumber, void* aArg) {
Entry* entry = reinterpret_cast<Entry*>(aHdr);
VisitorClosure* closure = static_cast<VisitorClosure*>(aArg);
nsresult rv;
nsCOMPtr<nsIRDFNode> subject = do_QueryInterface(entry->mNode, &rv);
NS_ENSURE_SUCCESS(rv, PL_DHASH_NEXT);
--- a/rdf/base/src/nsRDFService.cpp
+++ b/rdf/base/src/nsRDFService.cpp
@@ -106,47 +106,47 @@ static PRLogModuleInfo* gLog = nsnull;
#endif
class BlobImpl;
// These functions are copied from nsprpub/lib/ds/plhash.c, with one
// change to free the key in DataSourceFreeEntry.
// XXX sigh, why were DefaultAllocTable et. al. declared static, anyway?
-static void * PR_CALLBACK
+static void *
DataSourceAllocTable(void *pool, PRSize size)
{
#if defined(XP_MAC)
#pragma unused (pool)
#endif
return PR_MALLOC(size);
}
-static void PR_CALLBACK
+static void
DataSourceFreeTable(void *pool, void *item)
{
#if defined(XP_MAC)
#pragma unused (pool)
#endif
PR_Free(item);
}
-static PLHashEntry * PR_CALLBACK
+static PLHashEntry *
DataSourceAllocEntry(void *pool, const void *key)
{
#if defined(XP_MAC)
#pragma unused (pool,key)
#endif
return PR_NEW(PLHashEntry);
}
-static void PR_CALLBACK
+static void
DataSourceFreeEntry(void *pool, PLHashEntry *he, PRUintn flag)
{
#if defined(XP_MAC)
#pragma unused (pool)
#endif
if (flag == HT_FREE_ENTRY) {
PL_strfree((char*) he->key);
@@ -163,23 +163,23 @@ static PLHashAllocOps dataSourceHashAllo
//
// For the mResources hashtable.
//
struct ResourceHashEntry : public PLDHashEntryHdr {
const char *mKey;
nsIRDFResource *mResource;
- static PLDHashNumber PR_CALLBACK
+ static PLDHashNumber
HashKey(PLDHashTable *table, const void *key)
{
return nsCRT::HashCode(static_cast<const char *>(key));
}
- static PRBool PR_CALLBACK
+ static PRBool
MatchEntry(PLDHashTable *table, const PLDHashEntryHdr *hdr,
const void *key)
{
const ResourceHashEntry *entry =
static_cast<const ResourceHashEntry *>(hdr);
return 0 == nsCRT::strcmp(static_cast<const char *>(key),
entry->mKey);
@@ -201,23 +201,23 @@ static PLDHashTableOps gResourceTableOps
//
// For the mLiterals hashtable.
//
struct LiteralHashEntry : public PLDHashEntryHdr {
nsIRDFLiteral *mLiteral;
const PRUnichar *mKey;
- static PLDHashNumber PR_CALLBACK
+ static PLDHashNumber
HashKey(PLDHashTable *table, const void *key)
{
return nsCRT::HashCode(static_cast<const PRUnichar *>(key));
}
- static PRBool PR_CALLBACK
+ static PRBool
MatchEntry(PLDHashTable *table, const PLDHashEntryHdr *hdr,
const void *key)
{
const LiteralHashEntry *entry =
static_cast<const LiteralHashEntry *>(hdr);
return 0 == nsCRT::strcmp(static_cast<const PRUnichar *>(key),
entry->mKey);
@@ -239,23 +239,23 @@ static PLDHashTableOps gLiteralTableOps
//
// For the mInts hashtable.
//
struct IntHashEntry : public PLDHashEntryHdr {
nsIRDFInt *mInt;
PRInt32 mKey;
- static PLDHashNumber PR_CALLBACK
+ static PLDHashNumber
HashKey(PLDHashTable *table, const void *key)
{
return PLDHashNumber(*static_cast<const PRInt32 *>(key));
}
- static PRBool PR_CALLBACK
+ static PRBool
MatchEntry(PLDHashTable *table, const PLDHashEntryHdr *hdr,
const void *key)
{
const IntHashEntry *entry =
static_cast<const IntHashEntry *>(hdr);
return *static_cast<const PRInt32 *>(key) == entry->mKey;
}
@@ -276,32 +276,32 @@ static PLDHashTableOps gIntTableOps = {
//
// For the mDates hashtable.
//
struct DateHashEntry : public PLDHashEntryHdr {
nsIRDFDate *mDate;
PRTime mKey;
- static PLDHashNumber PR_CALLBACK
+ static PLDHashNumber
HashKey(PLDHashTable *table, const void *key)
{
// xor the low 32 bits with the high 32 bits.
PRTime t = *static_cast<const PRTime *>(key);
PRInt64 h64, l64;
LL_USHR(h64, t, 32);
l64 = LL_INIT(0, 0xffffffff);
LL_AND(l64, l64, t);
PRInt32 h32, l32;
LL_L2I(h32, h64);
LL_L2I(l32, l64);
return PLDHashNumber(l32 ^ h32);
}
- static PRBool PR_CALLBACK
+ static PRBool
MatchEntry(PLDHashTable *table, const PLDHashEntryHdr *hdr,
const void *key)
{
const DateHashEntry *entry =
static_cast<const DateHashEntry *>(hdr);
return LL_EQ(*static_cast<const PRTime *>(key), entry->mKey);
}
@@ -395,30 +395,30 @@ BlobImpl::GetLength(PRInt32 *aResult)
// ----------------------------------------------------------------------
//
// For the mBlobs hashtable.
//
struct BlobHashEntry : public PLDHashEntryHdr {
BlobImpl *mBlob;
- static PLDHashNumber PR_CALLBACK
+ static PLDHashNumber
HashKey(PLDHashTable *table, const void *key)
{
const BlobImpl::Data *data =
static_cast<const BlobImpl::Data *>(key);
const PRUint8 *p = data->mBytes, *limit = p + data->mLength;
PLDHashNumber h = 0;
for ( ; p < limit; ++p)
h = PR_ROTATE_LEFT32(h, 4) ^ *p;
return h;
}
- static PRBool PR_CALLBACK
+ static PRBool
MatchEntry(PLDHashTable *table, const PLDHashEntryHdr *hdr,
const void *key)
{
const BlobHashEntry *entry =
static_cast<const BlobHashEntry *>(hdr);
const BlobImpl::Data *left = &entry->mBlob->mData;
--- a/testing/mochitest/ssltunnel/ssltunnel.cpp
+++ b/testing/mochitest/ssltunnel/ssltunnel.cpp
@@ -220,17 +220,17 @@ bool ConnectSocket(PRFileDesc *fd, const
/*
* Handle an incoming client connection. The server thread has already
* accepted the connection, so we just need to connect to the remote
* port and then proxy data back and forth.
* The data parameter is a connection_info_t*, and must be deleted
* by this function.
*/
-void PR_CALLBACK HandleConnection(void* data)
+void HandleConnection(void* data)
{
connection_info_t* ci = static_cast<connection_info_t*>(data);
PRIntervalTime connect_timeout = PR_SecondsToInterval(2);
PRIntervalTime short_timeout = PR_MillisecondsToInterval(250);
AutoFD other_sock(PR_NewTCPSocket());
bool client_done = false;
bool client_error = false;
@@ -428,17 +428,17 @@ void PR_CALLBACK HandleConnection(void*
}
/*
* Start listening for SSL connections on a specified port, handing
* them off to client threads after accepting the connection.
* The data parameter is a server_info_t*, owned by the calling
* function.
*/
-void PR_CALLBACK StartServer(void* data)
+void StartServer(void* data)
{
server_info_t* si = static_cast<server_info_t*>(data);
//TODO: select ciphers?
AutoFD listen_socket(PR_NewTCPSocket());
if (!listen_socket) {
fprintf(stderr, "failed to create socket\n");
SignalShutdown();
@@ -637,17 +637,17 @@ int parseConfigFile(const char* filePath
if (any_host_cert_mapping && !do_http_proxy)
{
printf("Warning: any host-specific certificate configurations are ignored, add httpproxy:1 to allow them\n");
}
return 0;
}
-PRIntn PR_CALLBACK freeHashItems(PLHashEntry *he, PRIntn i, void *arg)
+PRIntn freeHashItems(PLHashEntry *he, PRIntn i, void *arg)
{
delete [] (char*)he->key;
delete [] (char*)he->value;
return HT_ENUMERATE_REMOVE;
}
int main(int argc, char** argv)
{
--- a/toolkit/components/filepicker/src/nsFileView.cpp
+++ b/toolkit/components/filepicker/src/nsFileView.cpp
@@ -889,46 +889,46 @@ nsFileView::ReverseArray(nsISupportsArra
for (PRUint32 i = 0; i < count/2; ++i) {
nsCOMPtr<nsISupports> element = dont_AddRef(aArray->ElementAt(i));
nsCOMPtr<nsISupports> element2 = dont_AddRef(aArray->ElementAt(count-i-1));
aArray->ReplaceElementAt(element2, i);
aArray->ReplaceElementAt(element, count-i-1);
}
}
-PR_STATIC_CALLBACK(int)
+static int
SortNameCallback(const void* aElement1, const void* aElement2, void* aContext)
{
nsIFile* file1 = *static_cast<nsIFile* const *>(aElement1);
nsIFile* file2 = *static_cast<nsIFile* const *>(aElement2);
nsAutoString leafName1, leafName2;
file1->GetLeafName(leafName1);
file2->GetLeafName(leafName2);
return Compare(leafName1, leafName2);
}
-PR_STATIC_CALLBACK(int)
+static int
SortSizeCallback(const void* aElement1, const void* aElement2, void* aContext)
{
nsIFile* file1 = *static_cast<nsIFile* const *>(aElement1);
nsIFile* file2 = *static_cast<nsIFile* const *>(aElement2);
PRInt64 size1, size2;
file1->GetFileSize(&size1);
file2->GetFileSize(&size2);
if (LL_EQ(size1, size2))
return 0;
return (LL_CMP(size1, <, size2) ? -1 : 1);
}
-PR_STATIC_CALLBACK(int)
+static int
SortDateCallback(const void* aElement1, const void* aElement2, void* aContext)
{
nsIFile* file1 = *static_cast<nsIFile* const *>(aElement1);
nsIFile* file2 = *static_cast<nsIFile* const *>(aElement2);
PRInt64 time1, time2;
file1->GetLastModifiedTime(&time1);
file2->GetLastModifiedTime(&time2);
--- a/toolkit/components/places/src/nsFaviconService.cpp
+++ b/toolkit/components/places/src/nsFaviconService.cpp
@@ -837,17 +837,17 @@ nsFaviconService::GetFaviconLinkForIcon(
NS_ENSURE_SUCCESS(rv, rv);
}
return GetFaviconLinkForIconString(spec, aOutputURI);
}
// nsFaviconService::AddFailedFavicon
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
ExpireFailedFaviconsCallback(nsCStringHashKey::KeyType aKey,
PRUint32& aData,
void* userArg)
{
PRUint32* threshold = reinterpret_cast<PRUint32*>(userArg);
if (aData < *threshold)
return PL_DHASH_REMOVE;
return PL_DHASH_NEXT;
--- a/toolkit/components/places/src/nsMorkHistoryImporter.cpp
+++ b/toolkit/components/places/src/nsMorkHistoryImporter.cpp
@@ -89,17 +89,17 @@ SwapBytes(PRUnichar *buffer)
{
for (PRUnichar *b = buffer; *b; ++b) {
PRUnichar c = *b;
*b = (c << 8) | ((c >> 8) & 0xff);
}
}
// Enumerator callback to add a table row to history
-static PLDHashOperator PR_CALLBACK
+static PLDHashOperator
AddToHistoryCB(const nsCSubstring &aRowID,
const nsTArray<nsCString> *aValues,
void *aData)
{
TableReadClosure *data = static_cast<TableReadClosure*>(aData);
const nsMorkReader *reader = data->reader;
nsCString values[kColumnCount];
const PRInt32 *columnIndexes = data->columnIndexes;
--- a/toolkit/components/places/src/nsNavBookmarks.cpp
+++ b/toolkit/components/places/src/nsNavBookmarks.cpp
@@ -737,17 +737,17 @@ nsNavBookmarks::RecursiveAddBookmarkHash
// Call this when a bookmark is removed. It will see if the bookmark still
// exists anywhere in the system, and, if not, remove all references to it
// in the bookmark hashtable.
//
// The callback takes a pointer to what bookmark is being removed (as
// an Int64 history page ID) as the userArg and removes all redirect
// destinations that reference it.
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
RemoveBookmarkHashCallback(nsTrimInt64HashKey::KeyType aKey,
PRInt64& aPlaceId, void* aUserArg)
{
const PRInt64* removeThisOne = reinterpret_cast<const PRInt64*>(aUserArg);
if (aPlaceId == *removeThisOne)
return PL_DHASH_REMOVE;
return PL_DHASH_NEXT;
}
--- a/toolkit/components/places/src/nsNavHistory.cpp
+++ b/toolkit/components/places/src/nsNavHistory.cpp
@@ -4541,17 +4541,17 @@ nsNavHistory::SetURIGeckoFlags(nsIURI* a
// nsNavHistory::AddDocumentRedirect
//
// This adds a redirect mapping from the destination of the redirect to the
// source, time, and type. This mapping is used by GetRedirectFor when we
// get a page added to reconstruct the redirects that happened when a page
// is visited. See GetRedirectFor for more information
// this is the expiration callback function that deletes stale entries
-PLDHashOperator PR_CALLBACK nsNavHistory::ExpireNonrecentRedirects(
+PLDHashOperator nsNavHistory::ExpireNonrecentRedirects(
nsCStringHashKey::KeyType aKey, RedirectInfo& aData, void* aUserArg)
{
PRInt64* threshold = reinterpret_cast<PRInt64*>(aUserArg);
if (aData.mTimeCreated < *threshold)
return PL_DHASH_REMOVE;
return PL_DHASH_NEXT;
}
@@ -5470,17 +5470,17 @@ nsNavHistory::CheckIsRecentEvent(RecentE
return PR_FALSE;
}
// nsNavHistory::ExpireNonrecentEvents
//
// This goes through our
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
ExpireNonrecentEventsCallback(nsCStringHashKey::KeyType aKey,
PRInt64& aData,
void* userArg)
{
PRInt64* threshold = reinterpret_cast<PRInt64*>(userArg);
if (aData < *threshold)
return PL_DHASH_REMOVE;
return PL_DHASH_NEXT;
--- a/toolkit/components/places/src/nsNavHistory.h
+++ b/toolkit/components/places/src/nsNavHistory.h
@@ -623,17 +623,17 @@ protected:
// redirect tracking. See GetRedirectFor for a description of how this works.
struct RedirectInfo {
nsCString mSourceURI;
PRTime mTimeCreated;
PRUint32 mType; // one of TRANSITION_REDIRECT_[TEMPORARY,PERMANENT]
};
typedef nsDataHashtable<nsCStringHashKey, RedirectInfo> RedirectHash;
RedirectHash mRecentRedirects;
- PR_STATIC_CALLBACK(PLDHashOperator) ExpireNonrecentRedirects(
+ static PLDHashOperator ExpireNonrecentRedirects(
nsCStringHashKey::KeyType aKey, RedirectInfo& aData, void* aUserArg);
PRBool GetRedirectFor(const nsACString& aDestination, nsACString& aSource,
PRTime* aTime, PRUint32* aRedirectType);
// session tracking
PRInt64 mLastSessionID;
PRInt64 GetNewSessionID() { mLastSessionID ++; return mLastSessionID; }
--- a/toolkit/components/places/src/nsNavHistoryResult.cpp
+++ b/toolkit/components/places/src/nsNavHistoryResult.cpp
@@ -836,32 +836,32 @@ PRInt32 nsNavHistoryContainerResultNode:
}
// nsNavHistoryContainerResultNode::SortComparison_Bookmark
//
// When there are bookmark indices, we should never have ties, so we don't
// need to worry about tiebreaking. When there are no bookmark indices,
// everything will be -1 and we don't worry about sorting.
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_Bookmark(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_Bookmark(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
return a->mBookmarkIndex - b->mBookmarkIndex;
}
// nsNavHistoryContainerResultNode::SortComparison_Title*
//
// These are a little more complicated because they do a localization
// conversion. If this is too slow, we can compute the sort keys once in
// advance, sort that array, and then reorder the real array accordingly.
// This would save some key generations.
//
// The collation object must be allocated before sorting on title!
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_TitleLess(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_TitleLess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
PRUint32 aType;
a->GetType(&aType);
PRInt32 value = SortComparison_StringLess(NS_ConvertUTF8toUTF16(a->mTitle),
NS_ConvertUTF8toUTF16(b->mTitle));
if (value == 0) {
@@ -873,94 +873,94 @@ PRInt32 PR_CALLBACK nsNavHistoryContaine
// resolve by date
value = ComparePRTime(a->mTime, b->mTime);
if (value == 0)
value = nsNavHistoryContainerResultNode::SortComparison_Bookmark(a, b, closure);
}
}
return value;
}
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_TitleGreater(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_TitleGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
return -SortComparison_TitleLess(a, b, closure);
}
// nsNavHistoryContainerResultNode::SortComparison_Date*
//
// Equal times will be very unusual, but it is important that there is some
// deterministic ordering of the results so they don't move around.
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_DateLess(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_DateLess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
PRInt32 value = ComparePRTime(a->mTime, b->mTime);
if (value == 0) {
value = SortComparison_StringLess(NS_ConvertUTF8toUTF16(a->mTitle),
NS_ConvertUTF8toUTF16(b->mTitle));
if (value == 0)
value = nsNavHistoryContainerResultNode::SortComparison_Bookmark(a, b, closure);
}
return value;
}
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_DateGreater(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_DateGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
return -nsNavHistoryContainerResultNode::SortComparison_DateLess(a, b, closure);
}
// nsNavHistoryContainerResultNode::SortComparison_DateAdded*
//
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_DateAddedLess(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_DateAddedLess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
PRInt32 value = ComparePRTime(a->mDateAdded, b->mDateAdded);
if (value == 0) {
value = SortComparison_StringLess(NS_ConvertUTF8toUTF16(a->mTitle),
NS_ConvertUTF8toUTF16(b->mTitle));
if (value == 0)
value = nsNavHistoryContainerResultNode::SortComparison_Bookmark(a, b, closure);
}
return value;
}
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_DateAddedGreater(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_DateAddedGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
return -nsNavHistoryContainerResultNode::SortComparison_DateAddedLess(a, b, closure);
}
// nsNavHistoryContainerResultNode::SortComparison_LastModified*
//
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_LastModifiedLess(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_LastModifiedLess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
PRInt32 value = ComparePRTime(a->mLastModified, b->mLastModified);
if (value == 0) {
value = SortComparison_StringLess(NS_ConvertUTF8toUTF16(a->mTitle),
NS_ConvertUTF8toUTF16(b->mTitle));
if (value == 0)
value = nsNavHistoryContainerResultNode::SortComparison_Bookmark(a, b, closure);
}
return value;
}
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_LastModifiedGreater(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_LastModifiedGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
return -nsNavHistoryContainerResultNode::SortComparison_LastModifiedLess(a, b, closure);
}
// nsNavHistoryContainerResultNode::SortComparison_URI*
//
// Certain types of parent nodes are treated specially because URIs are not
// valid (like days or hosts).
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_URILess(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_URILess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
PRInt32 value;
if (a->IsURI() && b->IsURI()) {
// normal URI or visit
value = a->mURI.Compare(b->mURI.get());
} else {
// for everything else, use title (= host name)
@@ -970,24 +970,24 @@ PRInt32 PR_CALLBACK nsNavHistoryContaine
if (value == 0) {
value = ComparePRTime(a->mTime, b->mTime);
if (value == 0)
value = nsNavHistoryContainerResultNode::SortComparison_Bookmark(a, b, closure);
}
return value;
}
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_URIGreater(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_URIGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
return -SortComparison_URILess(a, b, closure);
}
// nsNavHistoryContainerResultNode::SortComparison_Keyword*
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_KeywordLess(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_KeywordLess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
PRInt32 value = 0;
if (a->mItemId != -1 || b->mItemId != -1) {
// compare the keywords
nsAutoString aKeyword, bKeyword;
nsNavBookmarks* bookmarks = nsNavBookmarks::GetBookmarksService();
NS_ENSURE_TRUE(bookmarks, 0);
@@ -1007,23 +1007,23 @@ PRInt32 PR_CALLBACK nsNavHistoryContaine
// fall back to title sorting
if (value == 0)
value = SortComparison_TitleLess(a, b, closure);
return value;
}
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_KeywordGreater(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_KeywordGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
return -SortComparison_KeywordLess(a, b, closure);
}
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_AnnotationLess(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_AnnotationLess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
nsCAutoString annoName(static_cast<char*>(closure));
NS_ENSURE_TRUE(!annoName.IsEmpty(), 0);
nsNavBookmarks* bookmarks = nsNavBookmarks::GetBookmarksService();
NS_ENSURE_TRUE(bookmarks, 0);
@@ -1151,46 +1151,46 @@ PRInt32 PR_CALLBACK nsNavHistoryContaine
// Note we also fall back to the title-sorting route one of the items didn't
// have the annotation set or if both had it set but in a different storage
// type
if (value == 0)
return SortComparison_TitleLess(a, b, nsnull);
return value;
}
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_AnnotationGreater(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_AnnotationGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
return -SortComparison_AnnotationLess(a, b, closure);
}
// nsNavHistoryContainerResultNode::SortComparison_VisitCount*
//
// Fall back on dates for conflict resolution
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_VisitCountLess(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_VisitCountLess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
PRInt32 value = CompareIntegers(a->mAccessCount, b->mAccessCount);
if (value == 0) {
value = ComparePRTime(a->mTime, b->mTime);
if (value == 0)
value = nsNavHistoryContainerResultNode::SortComparison_Bookmark(a, b, closure);
}
return value;
}
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_VisitCountGreater(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_VisitCountGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
return -nsNavHistoryContainerResultNode::SortComparison_VisitCountLess(a, b, closure);
}
// nsNavHistoryContainerResultNode::SortComparison_Tags*
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_TagsLess(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_TagsLess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
PRInt32 value = 0;
nsAutoString aTags, bTags;
nsresult rv = a->GetTags(aTags);
NS_ENSURE_SUCCESS(rv, 0);
@@ -1201,17 +1201,17 @@ PRInt32 PR_CALLBACK nsNavHistoryContaine
// fall back to title sorting
if (value == 0)
value = SortComparison_TitleLess(a, b, closure);
return value;
}
-PRInt32 PR_CALLBACK nsNavHistoryContainerResultNode::SortComparison_TagsGreater(
+PRInt32 nsNavHistoryContainerResultNode::SortComparison_TagsGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure)
{
return -SortComparison_TagsLess(a, b, closure);
}
// nsNavHistoryContainerResultNode::FindChildURI
//
// Searches this folder for a node with the given URI. Returns null if not
@@ -1695,17 +1695,17 @@ nsNavHistoryContainerResultNode::UpdateU
// nsNavHistoryContainerResultNode::ChangeTitles
//
// This is used to update the titles in the tree. This is called from both
// query and bookmark folder containers to update the tree. Bookmark folders
// should be sure to set recursive to false, since child folders will have
// their own callbacks registered.
-static void PR_CALLBACK setTitleCallback(
+static void setTitleCallback(
nsNavHistoryResultNode* aNode, void* aClosure)
{
const nsACString* newTitle = reinterpret_cast<nsACString*>(aClosure);
aNode->mTitle = *newTitle;
}
nsresult
nsNavHistoryContainerResultNode::ChangeTitles(nsIURI* aURI,
const nsACString& aNewTitle,
@@ -2799,17 +2799,17 @@ nsNavHistoryQueryResultNode::OnClearHist
Refresh();
return NS_OK;
}
// nsNavHistoryQueryResultNode::OnPageChanged
//
-static void PR_CALLBACK setFaviconCallback(
+static void setFaviconCallback(
nsNavHistoryResultNode* aNode, void* aClosure)
{
const nsCString* newFavicon = static_cast<nsCString*>(aClosure);
aNode->mFaviconURI = *newFavicon;
}
NS_IMETHODIMP
nsNavHistoryQueryResultNode::OnPageChanged(nsIURI *aURI, PRUint32 aWhat,
const nsAString &aValue)
@@ -3686,32 +3686,32 @@ nsNavHistorySeparatorResultNode::nsNavHi
0, 0, EmptyCString())
{
}
// nsNavHistoryResult **********************************************************
NS_IMPL_CYCLE_COLLECTION_CLASS(nsNavHistoryResult)
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
RemoveBookmarkFolderObserversCallback(nsTrimInt64HashKey::KeyType aKey,
nsNavHistoryResult::FolderObserverList*& aData,
void* userArg)
{
delete aData;
return PL_DHASH_REMOVE;
}
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsNavHistoryResult)
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mRootNode)
NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mView)
tmp->mBookmarkFolderObservers.Enumerate(&RemoveBookmarkFolderObserversCallback, nsnull);
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
TraverseBookmarkFolderObservers(nsTrimInt64HashKey::KeyType aKey,
nsNavHistoryResult::FolderObserverList*& aData,
void* aUserArg)
{
nsCycleCollectionTraversalCallback* cb =
static_cast<nsCycleCollectionTraversalCallback*>(aUserArg);
PRUint32 i, count = aData->Length();
for (i = 0; i < count; ++i) {
--- a/toolkit/components/places/src/nsNavHistoryResult.h
+++ b/toolkit/components/places/src/nsNavHistoryResult.h
@@ -584,53 +584,53 @@ public:
SortComparator aComparator);
PRUint32 FindInsertionPoint(nsNavHistoryResultNode* aNode, SortComparator aComparator,
const char* aData, PRBool* aItemExists);
PRBool DoesChildNeedResorting(PRUint32 aIndex, SortComparator aComparator,
const char* aData);
static PRInt32 SortComparison_StringLess(const nsAString& a, const nsAString& b);
- PR_STATIC_CALLBACK(int) SortComparison_Bookmark(
+ static int SortComparison_Bookmark(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_TitleLess(
+ static int SortComparison_TitleLess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_TitleGreater(
+ static int SortComparison_TitleGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_DateLess(
+ static int SortComparison_DateLess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_DateGreater(
+ static int SortComparison_DateGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_URILess(
+ static int SortComparison_URILess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_URIGreater(
+ static int SortComparison_URIGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_VisitCountLess(
+ static int SortComparison_VisitCountLess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_VisitCountGreater(
+ static int SortComparison_VisitCountGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_KeywordLess(
+ static int SortComparison_KeywordLess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_KeywordGreater(
+ static int SortComparison_KeywordGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_AnnotationLess(
+ static int SortComparison_AnnotationLess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_AnnotationGreater(
+ static int SortComparison_AnnotationGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_DateAddedLess(
+ static int SortComparison_DateAddedLess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_DateAddedGreater(
+ static int SortComparison_DateAddedGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_LastModifiedLess(
+ static int SortComparison_LastModifiedLess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_LastModifiedGreater(
+ static int SortComparison_LastModifiedGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_TagsLess(
+ static int SortComparison_TagsLess(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
- PR_STATIC_CALLBACK(int) SortComparison_TagsGreater(
+ static int SortComparison_TagsGreater(
nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure);
// finding children: THESE DO NOT ADDREF
nsNavHistoryResultNode* FindChildURI(nsIURI* aURI, PRUint32* aNodeIndex)
{
nsCAutoString spec;
if (NS_FAILED(aURI->GetSpec(spec)))
return PR_FALSE;
--- a/toolkit/components/satchel/src/nsFormFillController.cpp
+++ b/toolkit/components/satchel/src/nsFormFillController.cpp
@@ -566,17 +566,17 @@ nsFormFillController::HandleEvent(nsIDOM
mPwmgrInputs.Enumerate(RemoveForDOMDocumentEnumerator, domDoc);
}
return NS_OK;
}
-/* static */ PLDHashOperator PR_CALLBACK
+/* static */ PLDHashOperator
nsFormFillController::RemoveForDOMDocumentEnumerator(nsISupports* aKey,
PRInt32& aEntry,
void* aUserData)
{
nsIDOMDocument* domDoc = static_cast<nsIDOMDocument*>(aUserData);
nsCOMPtr<nsIDOMHTMLInputElement> element = do_QueryInterface(aKey);
nsCOMPtr<nsIDOMDocument> elementDoc;
element->GetOwnerDocument(getter_AddRefs(elementDoc));
--- a/toolkit/components/satchel/src/nsFormFillController.h
+++ b/toolkit/components/satchel/src/nsFormFillController.h
@@ -124,19 +124,19 @@ protected:
void StopControllingInput();
PRBool RowMatch(nsFormHistory *aHistory, PRUint32 aIndex, const nsAString &aInputName, const nsAString &aInputValue);
inline nsIDocShell *GetDocShellForInput(nsIDOMHTMLInputElement *aInput);
inline nsIDOMWindow *GetWindowForDocShell(nsIDocShell *aDocShell);
inline PRInt32 GetIndexOfDocShell(nsIDocShell *aDocShell);
- static PLDHashOperator PR_CALLBACK RemoveForDOMDocumentEnumerator(nsISupports* aKey,
- PRInt32& aEntry,
- void* aUserData);
+ static PLDHashOperator RemoveForDOMDocumentEnumerator(nsISupports* aKey,
+ PRInt32& aEntry,
+ void* aUserData);
// members //////////////////////////////////////////
nsCOMPtr<nsIAutoCompleteController> mController;
nsCOMPtr<nsILoginManager> mLoginManager;
nsCOMPtr<nsIDOMHTMLInputElement> mFocusedInput;
nsCOMPtr<nsIAutoCompletePopup> mFocusedPopup;
nsCOMPtr<nsISupportsArray> mDocShells;
--- a/toolkit/components/satchel/src/nsFormHistory.cpp
+++ b/toolkit/components/satchel/src/nsFormHistory.cpp
@@ -798,17 +798,17 @@ nsFormHistory::AutoCompleteSearch(const
}
*aResult = result;
NS_IF_ADDREF(*aResult);
return NS_OK;
}
-int PR_CALLBACK
+int
nsFormHistory::SortComparison(const void *v1, const void *v2, void *closureVoid)
{
PRUint32 *index1 = (PRUint32 *)v1;
PRUint32 *index2 = (PRUint32 *)v2;
nsAutoVoidArray *array = (nsAutoVoidArray *)closureVoid;
PRUnichar *s1 = (PRUnichar *)array->ElementAt(*index1);
PRUnichar *s2 = (PRUnichar *)array->ElementAt(*index2);
--- a/toolkit/components/satchel/src/nsFormHistory.h
+++ b/toolkit/components/satchel/src/nsFormHistory.h
@@ -94,17 +94,17 @@ protected:
mdb_err UseThumb(nsIMdbThumb *aThumb, PRBool *aDone);
nsresult AppendRow(const nsAString &aValue, const nsAString &aName, nsIMdbRow **aResult);
nsresult SetRowValue(nsIMdbRow *aRow, mdb_column aCol, const nsAString &aValue);
nsresult GetRowValue(nsIMdbRow *aRow, mdb_column aCol, nsAString &aValue);
PRBool RowMatch(nsIMdbRow *aRow, const nsAString &aInputName, const nsAString &aInputValue, PRUnichar **aValue);
- PR_STATIC_CALLBACK(int) SortComparison(const void *v1, const void *v2, void *closureVoid);
+ static int SortComparison(const void *v1, const void *v2, void *closureVoid);
nsresult EntriesExistInternal(const nsAString *aName, const nsAString *aValue, PRBool *_retval);
nsresult RemoveEntriesInternal(const nsAString *aName);
nsresult InitByteOrder(PRBool aForce);
nsresult GetByteOrder(nsAString& aByteOrder);
nsresult SaveByteOrder(const nsAString& aByteOrder);
--- a/toolkit/components/satchel/src/nsStorageFormHistory.cpp
+++ b/toolkit/components/satchel/src/nsStorageFormHistory.cpp
@@ -695,17 +695,17 @@ static void SwapBytes(PRUnichar* aBuffer
for (PRUnichar *b = aBuffer; *b; b++)
{
PRUnichar c = *b;
*b = (0xff & (c >> 8)) | (c << 8);
}
}
// Enumerator callback to add an entry to the FormHistory
-/* static */ PLDHashOperator PR_CALLBACK
+/* static */ PLDHashOperator
nsFormHistoryImporter::AddToFormHistoryCB(const nsCSubstring &aRowID,
const nsTArray<nsCString> *aValues,
void *aData)
{
FormHistoryImportClosure *data = static_cast<FormHistoryImportClosure*>
(aData);
const nsMorkReader *reader = data->reader;
nsCString values[kColumnCount];
--- a/toolkit/components/satchel/src/nsStorageFormHistory.h
+++ b/toolkit/components/satchel/src/nsStorageFormHistory.h
@@ -141,16 +141,16 @@ public:
class nsFormHistoryImporter : public nsIFormHistoryImporter
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIFORMHISTORYIMPORTER
private:
// Enumerator callback to add a single row to the FormHistory.
- static PLDHashOperator PR_CALLBACK
+ static PLDHashOperator
AddToFormHistoryCB(const nsCSubstring &aRowID,
const nsTArray<nsCString> *aValues,
void *aData);
};
#endif
#endif // __nsFormHistory__
--- a/toolkit/crashreporter/nsExceptionHandler.cpp
+++ b/toolkit/crashreporter/nsExceptionHandler.cpp
@@ -742,19 +742,19 @@ static PRBool DoFindInReadable(const nsA
{
nsACString::const_iterator start, end;
str.BeginReading(start);
str.EndReading(end);
return FindInReadable(value, start, end);
}
-static PLDHashOperator PR_CALLBACK EnumerateEntries(const nsACString& key,
- nsCString entry,
- void* userData)
+static PLDHashOperator EnumerateEntries(const nsACString& key,
+ nsCString entry,
+ void* userData)
{
crashReporterAPIData->Append(key + NS_LITERAL_CSTRING("=") + entry +
NS_LITERAL_CSTRING("\n"));
return PL_DHASH_NEXT;
}
nsresult AnnotateCrashReport(const nsACString& key, const nsACString& data)
{
--- a/toolkit/xre/nsSigHandlers.cpp
+++ b/toolkit/xre/nsSigHandlers.cpp
@@ -113,17 +113,17 @@ void abnormal_exit_handler(int signum)
#elif defined(CRAWL_STACK_ON_SIGSEGV)
#include <unistd.h>
#include "nsISupportsUtils.h"
#include "nsStackWalk.h"
extern "C" {
-PR_STATIC_CALLBACK(void) PrintStackFrame(void *aPC, void *aClosure)
+static void PrintStackFrame(void *aPC, void *aClosure)
{
char buf[1024];
nsCodeAddressDetails details;
NS_DescribeCodeAddress(aPC, &details);
NS_FormatCodeAddressDetails(aPC, &details, buf, sizeof(buf));
fprintf(stdout, buf);
}
--- a/toolkit/xre/nsUpdateDriver.cpp
+++ b/toolkit/xre/nsUpdateDriver.cpp
@@ -170,17 +170,17 @@ GetXULRunnerStubPath(const char* argv0,
if (NS_FAILED(rv))
return rv;
NS_ADDREF(*aResult = lf);
return NS_OK;
}
#endif /* XP_MACOSX */
-PR_STATIC_CALLBACK(int)
+static int
ScanDirComparator(nsIFile *a, nsIFile *b, void *unused)
{
// lexically compare the leaf names of these two files
nsCAutoString a_name, b_name;
a->GetNativeLeafName(a_name);
b->GetNativeLeafName(b_name);
return Compare(a_name, b_name);
}
--- a/tools/trace-malloc/lib/nsTraceMalloc.c
+++ b/tools/trace-malloc/lib/nsTraceMalloc.c
@@ -229,17 +229,17 @@ static uint32 tracing_enabled = 0;
#endif
static TM_TLS_INDEX_TYPE tls_index;
static tm_thread main_thread; /* 0-initialization is correct */
/* FIXME (maybe): This is currently unused; we leak the thread-local data. */
#if 0
-PR_STATIC_CALLBACK(void)
+static void
free_tm_thread(void *priv)
{
tm_thread *t = (tm_thread*) priv;
PR_ASSERT(t->suppress_tracing == 0);
if (t->in_heap) {
t->suppress_tracing = 1;
@@ -892,17 +892,17 @@ calltree(void **stack, size_t num_stack_
TM_EXIT_LOCK(t);
return NULL;
}
/*
* Buffer the stack from top at low index to bottom at high, so that we can
* reverse it in calltree.
*/
-PR_STATIC_CALLBACK(void)
+static void
stack_callback(void *pc, void *closure)
{
stack_buffer_info *info = (stack_buffer_info*) closure;
/*
* If we run out of buffer, keep incrementing entries so that
* backtrace can call us again with a bigger buffer.
*/
--- a/uriloader/base/nsDocLoader.cpp
+++ b/uriloader/base/nsDocLoader.cpp
@@ -100,17 +100,17 @@ struct nsRequestInfo : public PLDHashEnt
const void* mKey; // Must be first for the pldhash stubs to work
nsInt64 mCurrentProgress;
nsInt64 mMaxProgress;
PRBool mUploading;
};
-PR_STATIC_CALLBACK(PRBool)
+static PRBool
RequestInfoHashInitEntry(PLDHashTable *table, PLDHashEntryHdr *entry,
const void *key)
{
// Initialize the entry with placement new
new (entry) nsRequestInfo(key);
return PR_TRUE;
}
@@ -1432,17 +1432,17 @@ nsRequestInfo * nsDocLoader::GetRequestI
// Return what we found in the hash...
return info;
}
// PLDHashTable enumeration callback that just removes every entry
// from the hash.
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
RemoveInfoCallback(PLDHashTable *table, PLDHashEntryHdr *hdr, PRUint32 number,
void *arg)
{
return PL_DHASH_REMOVE;
}
void nsDocLoader::ClearRequestInfoHash(void)
{
@@ -1451,17 +1451,17 @@ void nsDocLoader::ClearRequestInfoHash(v
return;
}
PL_DHashTableEnumerate(&mRequestInfoHash, RemoveInfoCallback, nsnull);
}
// PLDHashTable enumeration callback that calculates the max progress.
-PR_STATIC_CALLBACK(PLDHashOperator)
+static PLDHashOperator
CalcMaxProgressCallback(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg)
{
const nsRequestInfo *info = static_cast<const nsRequestInfo *>(hdr);
nsInt64 *max = static_cast<nsInt64 *>(arg);
if (info->mMaxProgress < info->mCurrentProgress) {
*max = nsInt64(-1);
--- a/view/src/nsView.cpp
+++ b/view/src/nsView.cpp
@@ -43,17 +43,17 @@
#include "nsIComponentManager.h"
#include "nsIScrollableView.h"
#include "nsGfxCIID.h"
#include "nsIRegion.h"
#include "nsIInterfaceRequestor.h"
//mmptemp
-static nsEventStatus PR_CALLBACK HandleEvent(nsGUIEvent *aEvent);
+static nsEventStatus HandleEvent(nsGUIEvent *aEvent);
//#define SHOW_VIEW_BORDERS
//#define HIDE_ALL_WIDGETS
// {34297A07-A8FD-d811-87C6-000244212BCB}
#define VIEW_WRAPPER_IID \
{ 0x34297a07, 0xa8fd, 0xd811, { 0x87, 0xc6, 0x0, 0x2, 0x44, 0x21, 0x2b, 0xcb } }
@@ -150,17 +150,17 @@ static ViewWrapper* GetWrapperFor(nsIWid
}
}
return nsnull;
}
//
// Main events handler
//
-nsEventStatus PR_CALLBACK HandleEvent(nsGUIEvent *aEvent)
+nsEventStatus HandleEvent(nsGUIEvent *aEvent)
{
//printf(" %d %d %d (%d,%d) \n", aEvent->widget, aEvent->widgetSupports,
// aEvent->message, aEvent->point.x, aEvent->point.y);
nsEventStatus result = nsEventStatus_eIgnore;
nsView *view = nsView::GetViewFor(aEvent->widget);
if (view)
{
--- a/widget/public/nsIWidget.h
+++ b/widget/public/nsIWidget.h
@@ -66,17 +66,17 @@ class nsIContent;
/**
* Callback function that processes events.
