Bug 456388 - Remove PR_STATIC_CALLBACK and PR_CALLBACK(_DECL) from the tree; r+sr=brendan
authorArpad Borsos <arpad.borsos@googlemail.com>
Fri, 10 Oct 2008 17:04:34 +0200
changeset 20261 eee86e5513ad381eaa16a55f037fa479c8d54187
parent 20260 bf3f9fbfb54311c3c682d0885a2ffe251ab74af6
child 20262 dda85c54599d0daf83d124179be6f401055566ea
push idunknown
push userunknown
push dateunknown
bugs456388
milestone1.9.1b2pre
Bug 456388 - Remove PR_STATIC_CALLBACK and PR_CALLBACK(_DECL) from the tree; r+sr=brendan
accessible/src/base/nsAccessNode.h
accessible/src/base/nsDocAccessible.cpp
caps/include/nsScriptSecurityManager.h
caps/src/nsPrincipal.cpp
caps/src/nsScriptSecurityManager.cpp
caps/src/nsSecurityManagerFactory.cpp
content/base/public/nsContentUtils.h
content/base/src/mozSanitizingSerializer.cpp
content/base/src/mozSanitizingSerializer.h
content/base/src/nsContentList.cpp
content/base/src/nsContentUtils.cpp
content/base/src/nsDocument.cpp
content/base/src/nsDocument.h
content/base/src/nsGenericElement.cpp
content/base/src/nsNodeInfoManager.h
content/base/src/nsNodeUtils.cpp
content/base/src/nsNodeUtils.h
content/base/src/nsPropertyTable.cpp
content/base/src/nsXMLNameSpaceMap.cpp
content/events/src/nsDOMDataContainerEvent.h
content/events/src/nsXMLEventsManager.cpp
content/html/content/src/nsHTMLFormElement.cpp
content/html/content/src/nsHTMLTableRowElement.cpp
content/html/document/src/nsHTMLDocument.cpp
content/xbl/src/nsBindingManager.cpp
content/xbl/src/nsXBLBinding.cpp
content/xbl/src/nsXBLDocumentInfo.cpp
content/xbl/src/nsXBLPrototypeBinding.cpp
content/xslt/src/xml/txXMLParser.cpp
content/xslt/src/xslt/txBufferingHandler.cpp
content/xslt/src/xslt/txStandaloneStylesheetCompiler.cpp
content/xul/document/src/nsXULDocument.cpp
content/xul/document/src/nsXULPrototypeCache.cpp
content/xul/document/src/nsXULPrototypeDocument.cpp
content/xul/templates/src/nsXULContentUtils.h
content/xul/templates/src/nsXULSortService.cpp
content/xul/templates/src/nsXULTemplateQueryProcessorRDF.cpp
content/xul/templates/src/nsXULTreeBuilder.cpp
db/morkreader/nsMorkReader.cpp
db/morkreader/nsMorkReader.h
docshell/base/nsWebShell.cpp
docshell/base/nsWebShell.h
docshell/build/nsDocShellModule.cpp
docshell/shistory/src/nsSHEntry.cpp
dom/src/base/nsGlobalWindow.cpp
dom/src/base/nsJSEnvironment.cpp
dom/src/base/nsJSEnvironment.h
dom/src/base/nsScriptNameSpaceManager.cpp
dom/src/storage/nsDOMStorage.cpp
embedding/browser/activex/src/common/IEHtmlNode.cpp
embedding/browser/activex/src/plugin/XPConnect.cpp
embedding/browser/photon/src/PtMozilla.cpp
embedding/browser/webBrowser/nsWebBrowser.cpp
embedding/browser/webBrowser/nsWebBrowser.h
embedding/components/commandhandler/src/nsCommandGroup.cpp
embedding/components/commandhandler/src/nsCommandGroup.h
embedding/components/commandhandler/src/nsCommandManager.cpp
embedding/components/commandhandler/src/nsCommandParams.h
embedding/components/webbrowserpersist/src/nsWebBrowserPersist.cpp
embedding/components/webbrowserpersist/src/nsWebBrowserPersist.h
extensions/access-builtin/accessproxy/nsAccessProxyRegistration.cpp
extensions/auth/nsAuthFactory.cpp
extensions/cookie/nsPermissionManager.cpp
extensions/metrics/src/nsLoadCollector.cpp
extensions/metrics/src/nsLoadCollector.h
extensions/metrics/src/nsMetricsConfig.cpp
extensions/metrics/src/nsMetricsConfig.h
extensions/metrics/src/nsMetricsService.cpp
extensions/metrics/src/nsMetricsService.h
extensions/metrics/src/nsUICommandCollector.cpp
extensions/metrics/src/nsUICommandCollector.h
extensions/pref/system-pref/src/gconf/nsSystemPrefService.cpp
extensions/spellcheck/src/mozPersonalDictionary.cpp
gfx/src/nsDeviceContext.cpp
gfx/src/thebes/nsThebesGfxFactory.cpp
gfx/tests/coverage/nsCoverage.cpp
gfx/thebes/public/gfxWindowsPlatform.h
gfx/thebes/src/gfxQuartzFontCache.h
gfx/thebes/src/gfxTextRunWordCache.cpp
gfx/thebes/src/gfxWindowsPlatform.cpp
intl/locale/src/nsLocale.h
ipc/ipcd/client/src/ipcConnectionUnix.cpp
ipc/ipcd/client/src/ipcModuleFactory.cpp
ipc/ipcd/client/src/ipcdclient.cpp
ipc/ipcd/extensions/dconnect/src/ipcDConnectService.cpp
ipc/ipcd/extensions/lock/src/module/ipcLockModule.cpp
ipc/ipcd/extensions/lock/test/TestIPCLocks.cpp
jpeg/jmorecfg.h
js/jsd/jsd_java.c
js/src/prmjtime.cpp
js/src/xpconnect/src/xpcjsruntime.cpp
js/src/xpconnect/src/xpcmodule.cpp
js/src/xpconnect/src/xpcthreadcontext.cpp
layout/base/nsCSSFrameConstructor.cpp
layout/base/nsCSSFrameConstructor.h
layout/base/nsCounterManager.cpp
layout/base/nsDocumentViewer.cpp
layout/base/nsFrameManager.cpp
layout/base/nsIFocusEventSuppressor.h
layout/base/nsPresContext.cpp
layout/base/nsPresContext.h
layout/base/nsPresShell.cpp
layout/build/nsLayoutModule.cpp
layout/generic/nsFrameList.cpp
layout/generic/nsHTMLReflowState.cpp
layout/generic/nsIntervalSet.h
layout/generic/nsSpaceManager.cpp
layout/style/nsCSSLoader.cpp
layout/style/nsCSSParser.cpp
layout/style/nsCSSRuleProcessor.cpp
layout/style/nsCSSScanner.cpp
layout/style/nsCSSStyleSheet.cpp
layout/style/nsHTMLStyleSheet.cpp
layout/style/nsICSSParser.h
layout/style/nsIStyleRuleProcessor.h
layout/style/nsMediaFeatures.cpp
layout/style/nsMediaFeatures.h
layout/style/nsRuleNode.cpp
layout/style/nsRuleNode.h
layout/svg/base/src/nsSVGOuterSVGFrame.cpp
layout/svg/base/src/nsSVGUtils.cpp
layout/tables/SpanningCellSorter.cpp
layout/tables/SpanningCellSorter.h
layout/xul/base/src/nsMenuPopupFrame.cpp
layout/xul/base/src/tree/src/nsTreeBodyFrame.cpp
layout/xul/base/src/tree/src/nsTreeStyleCache.cpp
layout/xul/base/src/tree/src/nsTreeStyleCache.h
modules/libjar/nsJAR.cpp
modules/libjar/nsJARFactory.cpp
modules/libjar/nsZipArchive.cpp
modules/libpr0n/build/nsImageModule.cpp
modules/libpr0n/decoders/icon/nsIconModule.cpp
modules/libpref/src/nsPrefBranch.cpp
modules/libpref/src/nsSharedPrefHandler.cpp
modules/libpref/src/prefapi.cpp
modules/libpref/src/prefapi_private_data.h
modules/oji/src/lcglue.cpp
modules/oji/src/nsJVMConfigManagerUnix.cpp
modules/oji/src/nsJVMManager.cpp
modules/plugin/base/src/nsJSNPRuntime.cpp
modules/plugin/base/src/nsPluginHostImpl.cpp
netwerk/base/src/nsBaseChannel.cpp
netwerk/base/src/nsDirectoryIndexStream.cpp
netwerk/base/src/nsIOThreadPool.cpp
netwerk/base/src/nsLoadGroup.cpp
netwerk/base/src/nsProtocolProxyService.cpp
netwerk/base/src/nsProtocolProxyService.h
netwerk/build/nsNetModule.cpp
netwerk/cache/src/nsCacheEntry.cpp
netwerk/cache/src/nsCacheEntry.h
netwerk/cache/src/nsCacheService.cpp
netwerk/cache/src/nsCacheService.h
netwerk/cache/src/nsDeleteDir.cpp
netwerk/cache/src/nsDiskCacheBinding.cpp
netwerk/cache/src/nsMemoryCacheDevice.cpp
netwerk/cookie/src/nsCookieService.cpp
netwerk/cookie/src/nsCookieService.h
netwerk/dns/src/nsHostResolver.cpp
netwerk/dns/src/nsHostResolver.h
netwerk/protocol/http/src/nsHttp.cpp
netwerk/protocol/http/src/nsHttpAuthCache.h
netwerk/protocol/http/src/nsHttpChannel.cpp
netwerk/protocol/http/src/nsHttpConnectionMgr.cpp
netwerk/protocol/http/src/nsHttpConnectionMgr.h
netwerk/socket/base/nsSOCKSIOLayer.cpp
netwerk/streamconv/src/nsStreamConverterService.cpp
parser/htmlparser/src/nsExpatDriver.cpp
parser/htmlparser/src/nsHTMLEntities.cpp
parser/htmlparser/src/nsHTMLTags.cpp
parser/htmlparser/src/nsParserModule.cpp
rdf/base/src/nsInMemoryDataSource.cpp
rdf/base/src/nsRDFService.cpp
testing/mochitest/ssltunnel/ssltunnel.cpp
toolkit/components/filepicker/src/nsFileView.cpp
toolkit/components/places/src/nsFaviconService.cpp
toolkit/components/places/src/nsMorkHistoryImporter.cpp
toolkit/components/places/src/nsNavBookmarks.cpp
toolkit/components/places/src/nsNavHistory.cpp
toolkit/components/places/src/nsNavHistory.h
toolkit/components/places/src/nsNavHistoryResult.cpp
toolkit/components/places/src/nsNavHistoryResult.h
toolkit/components/satchel/src/nsFormFillController.cpp
toolkit/components/satchel/src/nsFormFillController.h
toolkit/components/satchel/src/nsFormHistory.cpp
toolkit/components/satchel/src/nsFormHistory.h
toolkit/components/satchel/src/nsStorageFormHistory.cpp
toolkit/components/satchel/src/nsStorageFormHistory.h
toolkit/crashreporter/nsExceptionHandler.cpp
toolkit/xre/nsSigHandlers.cpp
toolkit/xre/nsUpdateDriver.cpp
tools/trace-malloc/lib/nsTraceMalloc.c
uriloader/base/nsDocLoader.cpp
view/src/nsView.cpp
widget/public/nsIWidget.h
widget/src/gtk2/nsBidiKeyboard.cpp
widget/src/gtk2/nsSound.cpp
widget/src/gtk2/nsWidgetFactory.cpp
widget/src/os2/nsToolkit.cpp
widget/src/os2/nsWidgetFactory.cpp
widget/src/photon/nsWidgetFactory.cpp
widget/src/qt/nsSound.cpp
widget/src/qt/nsWidgetFactory.cpp
widget/src/windows/nsKeyboardLayout.cpp
widget/src/windows/nsKeyboardLayout.h
widget/src/xpwidgets/nsAppShellSingleton.h
xpcom/base/nsConsoleService.cpp
xpcom/base/nsCycleCollector.cpp
xpcom/base/nsErrorService.cpp
xpcom/base/nsExceptionService.h
xpcom/base/nsGarbageCollector.c
xpcom/base/nsStackWalk.h
xpcom/base/nsTraceRefcntImpl.cpp
xpcom/build/nsXPCOM.h
xpcom/build/nsXPCOMPrivate.h
xpcom/build/nsXPComInit.cpp
xpcom/components/nsCategoryManager.cpp
xpcom/components/nsComponentManager.cpp
xpcom/components/nsModule.h
xpcom/components/nsStaticComponentLoader.cpp
xpcom/ds/nsArray.cpp
xpcom/ds/nsAtomTable.cpp
xpcom/ds/nsDoubleHashtable.h
xpcom/ds/nsHashPropertyBag.cpp
xpcom/ds/nsHashtable.cpp
xpcom/ds/nsHashtable.h
xpcom/ds/nsPersistentProperties.cpp
xpcom/ds/nsProperties.cpp
xpcom/ds/nsStaticNameTable.cpp
xpcom/glue/nsAutoLock.cpp
xpcom/glue/nsBaseHashtable.h
xpcom/glue/nsCOMArray.cpp
xpcom/glue/nsCOMArray.h
xpcom/glue/nsCycleCollectionParticipant.cpp
xpcom/glue/nsCycleCollectionParticipant.h
xpcom/glue/nsIGenericFactory.h
xpcom/glue/nsINIParser.h
xpcom/glue/nsTHashtable.h
xpcom/glue/nsVoidArray.cpp
xpcom/glue/nsVoidArray.h
xpcom/glue/pldhash.h
xpcom/io/nsDirectoryService.h
xpcom/io/nsFastLoadFile.cpp
xpcom/io/nsFastLoadFile.h
xpcom/io/nsLocalFileOS2.cpp
xpcom/reflect/xptinfo/src/xptiInterfaceInfoManager.cpp
xpcom/reflect/xptinfo/src/xptiManifest.cpp
xpcom/reflect/xptinfo/src/xptiWorkingSet.cpp
xpcom/tests/TestAutoLock.cpp
xpcom/tests/TestThreads.cpp
xpcom/threads/nsThread.h
xpcom/threads/nsThreadManager.cpp
xpfe/appshell/src/nsAppShellFactory.cpp
xpfe/appshell/src/nsWebShellWindow.cpp
xpfe/appshell/src/nsWebShellWindow.h
xpfe/components/history/src/nsGlobalHistory.cpp
xpfe/components/history/src/nsGlobalHistory.h
xpfe/components/intl/nsCharsetMenu.cpp
xpfe/components/windowds/nsWindowDataSource.cpp
xpinstall/src/nsJSInstallTriggerGlobal.cpp
--- 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 &currentTime = *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)