Bug 678155 - Remove NS_COM. r=bsmedberg
authorMatheus Kerschbaum <matjk7@gmail.com>
Thu, 18 Aug 2011 15:46:39 +0200
changeset 76534 e8cb0687737a90e89871b38707153e8f98042a6d
parent 76533 6309d93cd072d3d9cc49a3c903e9022b3f64490b
child 76535 46dc0fb0b1cb4b5b90bbb655f4e0d6d820e0aae6
push id340
push userclegnitto@mozilla.com
push dateTue, 08 Nov 2011 22:56:33 +0000
treeherdermozilla-beta@f745dc151615 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbsmedberg
bugs678155
milestone9.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 678155 - Remove NS_COM. r=bsmedberg
xpcom/base/FunctionTimer.h
xpcom/base/nsCycleCollector.h
xpcom/base/nsDebugImpl.cpp
xpcom/base/nsError.h
xpcom/base/nsIMemoryReporter.idl
xpcom/base/nsInterfaceRequestorAgg.h
xpcom/base/nsMemoryReporterManager.cpp
xpcom/base/nsTraceRefcntImpl.cpp
xpcom/base/nsTraceRefcntImpl.h
xpcom/base/nscore.h
xpcom/build/Services.cpp
xpcom/build/Services.h
xpcom/components/nsCategoryManager.cpp
xpcom/components/nsCategoryManagerUtils.h
xpcom/components/nsComponentManager.cpp
xpcom/ds/TimeStamp.h
xpcom/ds/nsAtomTable.cpp
xpcom/ds/nsByteBuffer.cpp
xpcom/ds/nsCRT.h
xpcom/ds/nsCheapSets.h
xpcom/ds/nsDoubleHashtable.h
xpcom/ds/nsFixedSizeAllocator.h
xpcom/ds/nsHashPropertyBag.h
xpcom/ds/nsHashSets.h
xpcom/ds/nsHashtable.h
xpcom/ds/nsIAtom.idl
xpcom/ds/nsIByteBuffer.h
xpcom/ds/nsICollection.idl
xpcom/ds/nsISupportsArray.idl
xpcom/ds/nsIUnicharBuffer.h
xpcom/ds/nsRecyclingAllocator.h
xpcom/ds/nsStaticAtom.h
xpcom/ds/nsStaticNameTable.h
xpcom/ds/nsStringEnumerator.cpp
xpcom/ds/nsStringEnumerator.h
xpcom/ds/nsSupportsArray.cpp
xpcom/ds/nsSupportsArray.h
xpcom/ds/nsSupportsArrayEnumerator.cpp
xpcom/ds/nsUnicharBuffer.cpp
xpcom/ds/nsVariant.h
xpcom/ds/nsWindowsRegKey.h
xpcom/glue/nsCycleCollectorUtils.h
xpcom/glue/nsThreadUtils.h
xpcom/io/SpecialSystemDirectory.cpp
xpcom/io/SpecialSystemDirectory.h
xpcom/io/nsEscape.cpp
xpcom/io/nsEscape.h
xpcom/io/nsIInputStreamTee.idl
xpcom/io/nsIPipe.idl
xpcom/io/nsIStorageStream.idl
xpcom/io/nsInputStreamTee.cpp
xpcom/io/nsLinebreakConverter.h
xpcom/io/nsLocalFileOS2.h
xpcom/io/nsLocalFileUnix.cpp
xpcom/io/nsLocalFileUnix.h
xpcom/io/nsNativeCharsetUtils.cpp
xpcom/io/nsNativeCharsetUtils.h
xpcom/io/nsPipe3.cpp
xpcom/io/nsSegmentedBuffer.cpp
xpcom/io/nsSegmentedBuffer.h
xpcom/io/nsStorageStream.cpp
xpcom/io/nsStreamUtils.cpp
xpcom/io/nsStreamUtils.h
xpcom/io/nsStringStream.cpp
xpcom/io/nsStringStream.h
xpcom/io/nsUnicharInputStream.h
xpcom/io/nsWildCard.cpp
xpcom/io/nsWildCard.h
xpcom/proxy/public/nsIProxyObjectManager.idl
xpcom/proxy/src/nsProxyObjectManager.cpp
xpcom/string/public/nsAString.h
xpcom/string/public/nsCharTraits.h
xpcom/string/public/nsPrintfCString.h
xpcom/string/public/nsReadableUtils.h
xpcom/string/public/nsStringBuffer.h
xpcom/string/public/nsTDependentString.h
xpcom/string/public/nsTDependentSubstring.h
xpcom/string/public/nsTPromiseFlatString.h
xpcom/string/public/nsTString.h
xpcom/string/public/nsTSubstring.h
xpcom/string/public/nsTSubstringTuple.h
xpcom/string/src/nsReadableUtils.cpp
xpcom/string/src/nsTString.cpp
xpcom/string/src/nsTStringComparator.cpp
xpcom/tests/TestPipes.cpp
xpcom/threads/nsEventQueue.h
xpcom/threads/nsThreadUtilsInternal.h
--- a/xpcom/base/FunctionTimer.h
+++ b/xpcom/base/FunctionTimer.h
@@ -128,32 +128,32 @@
 #define NS_TIME_FUNCTION_ELAPSED (0)
 #define NS_TIME_FUNCTION_ELAPSED_SINCE_MARK (0)
 #define NS_TIME_FUNCTION_LATEST (mozilla::TimeDuration(0))
 
 #endif
 
 namespace mozilla {
 
-class NS_COM FunctionTimerLog
+class FunctionTimerLog
 {
 public:
     FunctionTimerLog(const char *fname);
     ~FunctionTimerLog();
 
     void LogString(const char *str);
 
     TimeDuration LatestSinceStartup() const;
 
 private:
     void *mFile;
     TimeStamp mLatest;
 };
 
-class NS_COM FunctionTimer
+class FunctionTimer
 {
     static nsAutoPtr<FunctionTimerLog> sLog;
     static char *sBuf1;
     static char *sBuf2;
     static int sBufSize;
     static unsigned sDepth;
 
     enum { BUF_LOG_LENGTH = 1024 };
--- a/xpcom/base/nsCycleCollector.h
+++ b/xpcom/base/nsCycleCollector.h
@@ -59,18 +59,18 @@ struct nsCycleCollectionLanguageRuntime
     virtual nsCycleCollectionParticipant *ToParticipant(void *p) = 0;
 #ifdef DEBUG_CC
     virtual void PrintAllReferencesTo(void *p) = 0;
 #endif
 };
 
 nsresult nsCycleCollector_startup();
 // Returns the number of collected nodes.
-NS_COM PRUint32 nsCycleCollector_collect(nsICycleCollectorListener *aListener);
-NS_COM PRUint32 nsCycleCollector_suspectedCount();
+PRUint32 nsCycleCollector_collect(nsICycleCollectorListener *aListener);
+PRUint32 nsCycleCollector_suspectedCount();
 void nsCycleCollector_shutdownThreads();
 void nsCycleCollector_shutdown();
 
 // The JS runtime is special, it needs to call cycle collection during its GC.
 // If the JS runtime is registered nsCycleCollector_collect will call
 // nsCycleCollectionJSRuntime::Collect which will call
 // nsCycleCollector_doCollect, else nsCycleCollector_collect will call
 // nsCycleCollector_doCollect directly.
@@ -83,25 +83,25 @@ struct nsCycleCollectionJSRuntime : publ
 
     /**
      * Runs the JavaScript GC.
      */
     virtual void Collect() = 0;
 };
 
 #ifdef DEBUG
-NS_COM void nsCycleCollector_DEBUG_shouldBeFreed(nsISupports *n);
-NS_COM void nsCycleCollector_DEBUG_wasFreed(nsISupports *n);
+void nsCycleCollector_DEBUG_shouldBeFreed(nsISupports *n);
+void nsCycleCollector_DEBUG_wasFreed(nsISupports *n);
 #endif
 
 // Helpers for interacting with language-identified scripts
 
-NS_COM void nsCycleCollector_registerRuntime(PRUint32 langID, nsCycleCollectionLanguageRuntime *rt);
-NS_COM nsCycleCollectionLanguageRuntime * nsCycleCollector_getRuntime(PRUint32 langID);
-NS_COM void nsCycleCollector_forgetRuntime(PRUint32 langID);
+void nsCycleCollector_registerRuntime(PRUint32 langID, nsCycleCollectionLanguageRuntime *rt);
+nsCycleCollectionLanguageRuntime * nsCycleCollector_getRuntime(PRUint32 langID);
+void nsCycleCollector_forgetRuntime(PRUint32 langID);
 
 #define NS_CYCLE_COLLECTOR_LOGGER_CID \
 { 0x58be81b4, 0x39d2, 0x437c, \
 { 0x94, 0xea, 0xae, 0xde, 0x2c, 0x62, 0x08, 0xd3 } }
 
 extern nsresult
 nsCycleCollectorLoggerConstructor(nsISupports* outer,
                                   const nsIID& aIID,
--- a/xpcom/base/nsDebugImpl.cpp
+++ b/xpcom/base/nsDebugImpl.cpp
@@ -528,17 +528,17 @@ nsDebugImpl::Create(nsISupports* outer, 
   NS_ENSURE_NO_AGGREGATION(outer);
 
   return const_cast<nsDebugImpl*>(&kImpl)->
     QueryInterface(aIID, aInstancePtr);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-NS_COM nsresult
+nsresult
 NS_ErrorAccordingToNSPR()
 {
     PRErrorCode err = PR_GetError();
     switch (err) {
       case PR_OUT_OF_MEMORY_ERROR:              return NS_ERROR_OUT_OF_MEMORY;
       case PR_WOULD_BLOCK_ERROR:                return NS_BASE_STREAM_WOULD_BLOCK;
       case PR_FILE_NOT_FOUND_ERROR:             return NS_ERROR_FILE_NOT_FOUND;
       case PR_READ_ONLY_FILESYSTEM_ERROR:       return NS_ERROR_FILE_READ_ONLY;
@@ -554,16 +554,16 @@ NS_ErrorAccordingToNSPR()
       case PR_NO_ACCESS_RIGHTS_ERROR:           return NS_ERROR_FILE_ACCESS_DENIED;
       default:                                  return NS_ERROR_FAILURE;
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #ifdef XP_WIN
-NS_COM PRBool sXPCOMHasLoadedNewDLLs = PR_FALSE;
+PRBool sXPCOMHasLoadedNewDLLs = PR_FALSE;
 
 NS_EXPORT void
 NS_SetHasLoadedNewDLLs()
 {
   sXPCOMHasLoadedNewDLLs = PR_TRUE;
 }
 #endif
--- a/xpcom/base/nsError.h
+++ b/xpcom/base/nsError.h
@@ -322,23 +322,23 @@ inline int NS_SUCCEEDED(nsresult _nsresu
  /*
   * This will return the nsresult corresponding to the most recent NSPR failure
   * returned by PR_GetError.
   *
   ***********************************************************************
   *      Do not depend on this function. It will be going away!
   ***********************************************************************
   */
-extern NS_COM nsresult
+extern nsresult
 NS_ErrorAccordingToNSPR();
 
 
 #ifdef _MSC_VER
 #pragma warning(disable: 4251) /* 'nsCOMPtr<class nsIInputStream>' needs to have dll-interface to be used by clients of class 'nsInputStream' */
 #pragma warning(disable: 4275) /* non dll-interface class 'nsISupports' used as base for dll-interface class 'nsIRDFNode' */
 #endif
 
 #ifdef XP_WIN
-extern NS_COM PRBool sXPCOMHasLoadedNewDLLs;
+extern PRBool sXPCOMHasLoadedNewDLLs;
 NS_EXPORT void NS_SetHasLoadedNewDLLs();
 #endif
 
 #endif
--- a/xpcom/base/nsIMemoryReporter.idl
+++ b/xpcom/base/nsIMemoryReporter.idl
@@ -287,15 +287,15 @@ interface nsIMemoryReporterManager : nsI
 
 #define NS_MEMORY_REPORTER_IMPLEMENT(_c, _p, _k, _u, _a, _d) \
         NS_MEMORY_REPORTER_IMPLEMENT_HELPER(_c, _p, _k, _u, _a, _d, _)
 #define NS_THREADSAFE_MEMORY_REPORTER_IMPLEMENT(_c, _p, _k, _u, _a, _d) \
         NS_MEMORY_REPORTER_IMPLEMENT_HELPER(_c, _p, _k, _u, _a, _d, _THREADSAFE_)
 
 #define NS_MEMORY_REPORTER_NAME(_classname)  MemoryReporter_##_classname
 
-NS_COM nsresult NS_RegisterMemoryReporter (nsIMemoryReporter *reporter);
-NS_COM nsresult NS_RegisterMemoryMultiReporter (nsIMemoryMultiReporter *reporter);
+nsresult NS_RegisterMemoryReporter (nsIMemoryReporter *reporter);
+nsresult NS_RegisterMemoryMultiReporter (nsIMemoryMultiReporter *reporter);
 
-NS_COM nsresult NS_UnregisterMemoryReporter (nsIMemoryReporter *reporter);
-NS_COM nsresult NS_UnregisterMemoryMultiReporter (nsIMemoryMultiReporter *reporter);
+nsresult NS_UnregisterMemoryReporter (nsIMemoryReporter *reporter);
+nsresult NS_UnregisterMemoryMultiReporter (nsIMemoryMultiReporter *reporter);
 
 %}
--- a/xpcom/base/nsInterfaceRequestorAgg.h
+++ b/xpcom/base/nsInterfaceRequestorAgg.h
@@ -41,14 +41,14 @@
 
 /**
  * This function returns an instance of nsIInterfaceRequestor that aggregates
  * two nsIInterfaceRequestor instances.  Its GetInterface method queries
  * aFirst for the requested interface and will query aSecond only if aFirst
  * failed to supply the requested interface.  Both aFirst and aSecond may
  * be null.
  */
-extern NS_COM nsresult
+extern nsresult
 NS_NewInterfaceRequestorAggregation(nsIInterfaceRequestor  *aFirst,
                                     nsIInterfaceRequestor  *aSecond,
                                     nsIInterfaceRequestor **aResult);
 
 #endif // !defined( nsInterfaceRequestorAgg_h__ )
--- a/xpcom/base/nsMemoryReporterManager.cpp
+++ b/xpcom/base/nsMemoryReporterManager.cpp
@@ -741,44 +741,44 @@ NS_IMETHODIMP nsMemoryReporter::GetAmoun
 }
 
 NS_IMETHODIMP nsMemoryReporter::GetDescription(nsACString &aDescription)
 {
     aDescription.Assign(mDesc);
     return NS_OK;
 }
 
-NS_COM nsresult
+nsresult
 NS_RegisterMemoryReporter (nsIMemoryReporter *reporter)
 {
     nsCOMPtr<nsIMemoryReporterManager> mgr = do_GetService("@mozilla.org/memory-reporter-manager;1");
     if (mgr == nsnull)
         return NS_ERROR_FAILURE;
     return mgr->RegisterReporter(reporter);
 }
 
-NS_COM nsresult
+nsresult
 NS_RegisterMemoryMultiReporter (nsIMemoryMultiReporter *reporter)
 {
     nsCOMPtr<nsIMemoryReporterManager> mgr = do_GetService("@mozilla.org/memory-reporter-manager;1");
     if (mgr == nsnull)
         return NS_ERROR_FAILURE;
     return mgr->RegisterMultiReporter(reporter);
 }
 
-NS_COM nsresult
+nsresult
 NS_UnregisterMemoryReporter (nsIMemoryReporter *reporter)
 {
     nsCOMPtr<nsIMemoryReporterManager> mgr = do_GetService("@mozilla.org/memory-reporter-manager;1");
     if (mgr == nsnull)
         return NS_ERROR_FAILURE;
     return mgr->UnregisterReporter(reporter);
 }
 
-NS_COM nsresult
+nsresult
 NS_UnregisterMemoryMultiReporter (nsIMemoryMultiReporter *reporter)
 {
     nsCOMPtr<nsIMemoryReporterManager> mgr = do_GetService("@mozilla.org/memory-reporter-manager;1");
     if (mgr == nsnull)
         return NS_ERROR_FAILURE;
     return mgr->UnregisterMultiReporter(reporter);
 }
 
--- a/xpcom/base/nsTraceRefcntImpl.cpp
+++ b/xpcom/base/nsTraceRefcntImpl.cpp
@@ -68,17 +68,17 @@
 #include "mozilla/BlockingResourceBase.h"
 
 #ifdef HAVE_DLOPEN
 #include <dlfcn.h>
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 
-NS_COM void
+void
 NS_MeanAndStdDev(double n, double sumOfValues, double sumOfSquaredValues,
                  double *meanResult, double *stdDevResult)
 {
   double mean = 0.0, var = 0.0, stdDev = 0.0;
   if (n > 0.0 && sumOfValues >= 0) {
     mean = sumOfValues / n;
     double temp = (n * sumOfSquaredValues) - (sumOfValues * sumOfValues);
     if (temp < 0.0 || n <= 1)
@@ -502,17 +502,17 @@ class nsDefaultComparator <BloatEntry*, 
     }
     PRBool LessThan(BloatEntry* const& aA, BloatEntry* const& aB) const {
       return PL_strcmp(aA->GetClassName(), aB->GetClassName()) < 0;
     }
 };
 
 #endif /* NS_IMPL_REFCNT_LOGGING */
 
-NS_COM nsresult
+nsresult
 nsTraceRefcntImpl::DumpStatistics(StatisticsType type, FILE* out)
 {
 #ifdef NS_IMPL_REFCNT_LOGGING
   if (gBloatLog == nsnull || gBloatView == nsnull) {
     return NS_ERROR_FAILURE;
   }
   if (out == nsnull) {
     out = gBloatLog;
@@ -565,17 +565,17 @@ nsTraceRefcntImpl::DumpStatistics(Statis
 
   gLogging = wasLogging;
   UNLOCK_TRACELOG();
 #endif
 
   return NS_OK;
 }
 
-NS_COM void
+void
 nsTraceRefcntImpl::ResetStatistics()
 {
 #ifdef NS_IMPL_REFCNT_LOGGING
   LOCK_TRACELOG();
   if (gBloatView) {
     PL_HashTableDestroy(gBloatView);
     gBloatView = nsnull;
   }
@@ -874,32 +874,32 @@ static void PrintStackFrame(void *aPC, v
 
   NS_DescribeCodeAddress(aPC, &details);
   NS_FormatCodeAddressDetails(aPC, &details, buf, sizeof(buf));
   fputs(buf, stream);
 }
 
 }
 
-NS_COM void
+void
 nsTraceRefcntImpl::WalkTheStack(FILE* aStream)
 {
   NS_StackWalk(PrintStackFrame, 2, aStream);
 }
 
 //----------------------------------------------------------------------
 
 // This thing is exported by libstdc++
 // Yes, this is a gcc only hack
 #if defined(MOZ_DEMANGLE_SYMBOLS)
 #include <cxxabi.h>
 #include <stdlib.h> // for free()
 #endif // MOZ_DEMANGLE_SYMBOLS
 
-NS_COM void
+void
 nsTraceRefcntImpl::DemangleSymbol(const char * aSymbol,
                               char * aBuffer,
                               int aBufLen)
 {
   NS_ASSERTION(nsnull != aSymbol,"null symbol");
   NS_ASSERTION(nsnull != aBuffer,"null buffer");
   NS_ASSERTION(aBufLen >= 32 ,"pulled 32 out of you know where");
 
@@ -1255,22 +1255,22 @@ NS_LogCOMPtrRelease(void* aCOMPtr, nsISu
       nsTraceRefcntImpl::WalkTheStack(gCOMPtrLog);
     }
 
     UNLOCK_TRACELOG();
   }
 #endif
 }
 
-NS_COM void
+void
 nsTraceRefcntImpl::Startup()
 {
 }
 
-NS_COM void
+void
 nsTraceRefcntImpl::Shutdown()
 {
 #ifdef NS_IMPL_REFCNT_LOGGING
 
   if (gBloatView) {
     PL_HashTableDestroy(gBloatView);
     gBloatView = nsnull;
   }
@@ -1304,17 +1304,17 @@ nsTraceRefcntImpl::Shutdown()
   }
   if (gCOMPtrLog) {
     fclose(gCOMPtrLog);
     gCOMPtrLog = nsnull;
   }
 #endif
 }
 
-NS_COM void
+void
 nsTraceRefcntImpl::SetActivityIsLegal(PRBool aLegal)
 {
 #ifdef NS_IMPL_REFCNT_LOGGING
   if (gActivityTLS == BAD_TLS_INDEX)
     PR_NewThreadPrivateIndex(&gActivityTLS, nsnull);
 
   PR_SetThreadPrivate(gActivityTLS, NS_INT32_TO_PTR(!aLegal));
 #endif
--- a/xpcom/base/nsTraceRefcntImpl.h
+++ b/xpcom/base/nsTraceRefcntImpl.h
@@ -43,40 +43,40 @@
 
 class nsTraceRefcntImpl : public nsITraceRefcnt
 {
 public:
   nsTraceRefcntImpl() {}
   NS_DECL_ISUPPORTS
   NS_DECL_NSITRACEREFCNT
 
-  static NS_COM void Startup();
-  static NS_COM void Shutdown();
+  static void Startup();
+  static void Shutdown();
 
   enum StatisticsType {
     ALL_STATS,
     NEW_STATS
   };
 
-  static NS_COM nsresult DumpStatistics(StatisticsType type = ALL_STATS,
+  static nsresult DumpStatistics(StatisticsType type = ALL_STATS,
                                         FILE* out = 0);
 
-  static NS_COM void ResetStatistics(void);
+  static void ResetStatistics(void);
 
-  static NS_COM void DemangleSymbol(const char * aSymbol,
+  static void DemangleSymbol(const char * aSymbol,
                                     char * aBuffer,
                                     int aBufLen);
 
-  static NS_COM void WalkTheStack(FILE* aStream);
+  static void WalkTheStack(FILE* aStream);
   /**
    * Tell nsTraceRefcnt whether refcounting, allocation, and destruction
    * activity is legal.  This is used to trigger assertions for any such
    * activity that occurs because of static constructors or destructors.
    */
-  static NS_COM void SetActivityIsLegal(PRBool aLegal);
+  static void SetActivityIsLegal(PRBool aLegal);
 
   static NS_METHOD Create(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr);
 };
 
 #define NS_TRACE_REFCNT_CONTRACTID "@mozilla.org/xpcom/trace-refcnt;1"
 #define NS_TRACE_REFCNT_CLASSNAME  "nsTraceRefcnt Interface"
 #define NS_TRACE_REFCNT_CID                          \
 { /* e3e7511e-a395-4924-94b1-d527861cded4 */         \
@@ -84,14 +84,14 @@ public:
     0xa395,                                          \
     0x4924,                                          \
     {0x94, 0xb1, 0xd5, 0x27, 0x86, 0x1c, 0xde, 0xd4} \
 }                                                    \
 
 ////////////////////////////////////////////////////////////////////////////////
 // And now for that utility that you've all been asking for...
 
-extern "C" NS_COM void
+extern "C" void
 NS_MeanAndStdDev(double n, double sumOfValues, double sumOfSquaredValues,
                  double *meanResult, double *stdDevResult);
 
 ////////////////////////////////////////////////////////////////////////////////
 #endif
--- a/xpcom/base/nscore.h
+++ b/xpcom/base/nscore.h
@@ -29,16 +29,17 @@
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
+
 #ifndef nscore_h___
 #define nscore_h___
 
 /**
  * Make sure that we have the proper platform specific
  * c++ definitions needed by nscore.h
  */
 #ifndef _XPCOM_CONFIG_H_
@@ -290,20 +291,18 @@
 #ifdef _IMPL_NS_COM
 #define XPCOM_API(type) EXPORT_XPCOM_API(type)
 #elif defined(XPCOM_GLUE)
 #define XPCOM_API(type) GLUE_XPCOM_API(type)
 #else
 #define XPCOM_API(type) IMPORT_XPCOM_API(type)
 #endif
 
-#define NS_COM
-
 #ifdef MOZILLA_INTERNAL_API
-#  define NS_COM_GLUE NS_COM
+#  define NS_COM_GLUE
    /*
      The frozen string API has different definitions of nsAC?String
      classes than the internal API. On systems that explicitly declare
      dllexport symbols this is not a problem, but on ELF systems
      internal symbols can accidentally "shine through"; we rename the
      internal classes to avoid symbol conflicts.
    */
 #  define nsAString nsAString_internal
--- a/xpcom/build/Services.cpp
+++ b/xpcom/build/Services.cpp
@@ -59,17 +59,17 @@ using namespace mozilla::services;
 
 /*
  * Define a global variable and a getter for every service in ServiceList.
  * eg. gIOService and GetIOService()
  */
 #define MOZ_SERVICE(NAME, TYPE, CONTRACT_ID)                            \
   static TYPE* g##NAME = nsnull;                                        \
                                                                         \
-  NS_COM already_AddRefed<TYPE>                                         \
+  already_AddRefed<TYPE>                                         \
   mozilla::services::Get##NAME()                                        \
   {                                                                     \
     if (!g##NAME) {                                                     \
       nsCOMPtr<TYPE> os = do_GetService(CONTRACT_ID);                   \
       g##NAME = os.forget().get();                                      \
     }                                                                   \
     NS_IF_ADDREF(g##NAME);                                              \
     return g##NAME;                                                     \
--- a/xpcom/build/Services.h
+++ b/xpcom/build/Services.h
@@ -47,16 +47,16 @@
 
 #include "ServiceList.h"
 #undef MOZ_SERVICE
 #undef MOZ_USE_NAMESPACE
 
 namespace mozilla {
 namespace services {
 
-#define MOZ_SERVICE(NAME, TYPE, SERVICE_CID) NS_COM already_AddRefed<TYPE> Get##NAME();
+#define MOZ_SERVICE(NAME, TYPE, SERVICE_CID) already_AddRefed<TYPE> Get##NAME();
 #include "ServiceList.h"
 #undef MOZ_SERVICE
 
 } // namespace services
 } // namespace mozilla
 
 #endif
--- a/xpcom/components/nsCategoryManager.cpp
+++ b/xpcom/components/nsCategoryManager.cpp
@@ -737,17 +737,17 @@ nsCategoryManager::SuppressNotifications
  * CreateServicesFromCategory()
  *
  * Given a category, this convenience functions enumerates the category and 
  * creates a service of every CID or ContractID registered under the category.
  * If observerTopic is non null and the service implements nsIObserver,
  * this will attempt to notify the observer with the origin, observerTopic string
  * as parameter.
  */
-NS_COM void
+void
 NS_CreateServicesFromCategory(const char *category,
                               nsISupports *origin,
                               const char *observerTopic)
 {
   NS_TIME_FUNCTION_FMT("NS_CreateServicesFromCategory: %s (%s)",
                        category, observerTopic ? observerTopic : "(no topic)");
 
   nsresult rv;
--- a/xpcom/components/nsCategoryManagerUtils.h
+++ b/xpcom/components/nsCategoryManagerUtils.h
@@ -35,14 +35,14 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef nsCategoryManagerUtils_h__
 #define nsCategoryManagerUtils_h__
 
 #include "nsICategoryManager.h"
 
-NS_COM void
+void
 NS_CreateServicesFromCategory(const char *category,
                               nsISupports *origin,
                               const char *observerTopic);
 
 #endif
--- a/xpcom/components/nsComponentManager.cpp
+++ b/xpcom/components/nsComponentManager.cpp
@@ -41,21 +41,23 @@
  * Corporation, 2000
  *
  * Modifications to Mozilla code or documentation
  * identified per MPL Section 3.3
  *
  * Date             Modified by     Description of modification
  * 04/20/2000       IBM Corp.      Added PR_CALLBACK for Optlink use in OS2
  */
+
 #include <stdlib.h>
 #include "nscore.h"
 #include "nsISupports.h"
 #include "nspr.h"
 #include "nsCRT.h" // for atoll
+
 // Arena used by component manager for storing contractid string, dll
 // location strings and small objects
 // CAUTION: Arena align mask needs to be defined before including plarena.h
 //          currently from nsComponentManager.h
 #define PL_ARENA_CONST_ALIGN_MASK 7
 #define NS_CM_BLOCK_SIZE (1024 * 8)
 
 #include "nsCategoryManager.h"
@@ -102,17 +104,17 @@
 #include "mozilla/Omnijar.h"
 #include "nsJAR.h"
 static NS_DEFINE_CID(kZipReaderCID, NS_ZIPREADER_CID);
 
 #include "prlog.h"
 
 using namespace mozilla;
 
-NS_COM PRLogModuleInfo* nsComponentManagerLog = nsnull;
+PRLogModuleInfo* nsComponentManagerLog = nsnull;
 
 #if 0 || defined (DEBUG_timeless)
  #define SHOW_DENIED_ON_SHUTDOWN
  #define SHOW_CI_ON_EXISTING_SERVICE
 #endif
 
 // Bloated registry buffer size to improve startup performance -- needs to
 // be big enough to fit the entire file into memory or it'll thrash.
@@ -1988,38 +1990,38 @@ nsFactoryEntry::GetFactory()
     NS_ADDREF(mFactory);
     return mFactory.get();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Static Access Functions
 ////////////////////////////////////////////////////////////////////////////////
 
-NS_COM nsresult
+nsresult
 NS_GetComponentManager(nsIComponentManager* *result)
 {
     if (!nsComponentManagerImpl::gComponentManager)
         return NS_ERROR_NOT_INITIALIZED;
 
     NS_ADDREF(*result = nsComponentManagerImpl::gComponentManager);
     return NS_OK;
 }
 
-NS_COM nsresult
+nsresult
 NS_GetServiceManager(nsIServiceManager* *result)
 {
     if (!nsComponentManagerImpl::gComponentManager)
         return NS_ERROR_NOT_INITIALIZED;
 
     NS_ADDREF(*result = nsComponentManagerImpl::gComponentManager);
     return NS_OK;
 }
 
 
-NS_COM nsresult
+nsresult
 NS_GetComponentRegistrar(nsIComponentRegistrar* *result)
 {
     if (!nsComponentManagerImpl::gComponentManager)
         return NS_ERROR_NOT_INITIALIZED;
 
     NS_ADDREF(*result = nsComponentManagerImpl::gComponentManager);
     return NS_OK;
 }
--- a/xpcom/ds/TimeStamp.h
+++ b/xpcom/ds/TimeStamp.h
@@ -52,17 +52,17 @@ class TimeStamp;
  * Negative durations are allowed, meaning the end is before the start.
  * 
  * Internally the duration is stored as a PRInt64 in units of
  * PR_TicksPerSecond() when building with NSPR interval timers, or a
  * system-dependent unit when building with system clocks.  The
  * system-dependent unit must be constant, otherwise the semantics of
  * this class would be broken.
  */
-class NS_COM TimeDuration
+class TimeDuration
 {
 public:
   // The default duration is 0.
   TimeDuration() : mValue(0) {}
   // Allow construction using '0' as the initial value, for readability,
   // but no other numbers (so we don't have any implicit unit conversions).
   struct _SomethingVeryRandomHere;
   TimeDuration(_SomethingVeryRandomHere* aZero) : mValue(0) {
@@ -181,17 +181,17 @@ private:
  * meaningless like add two TimeStamps.
  *
  * Internally this is implemented as either a wrapper around
  *   - high-resolution, monotonic, system clocks if they exist on this
  *     platform
  *   - PRIntervalTime otherwise.  We detect wraparounds of
  *     PRIntervalTime and work around them.
  */
-class NS_COM TimeStamp
+class TimeStamp
 {
 public:
   /**
    * Initialize to the "null" moment
    */
   TimeStamp() : mValue(0) {}
   // Default copy-constructor and assignment are OK
 
--- a/xpcom/ds/nsAtomTable.cpp
+++ b/xpcom/ds/nsAtomTable.cpp
@@ -414,17 +414,17 @@ class CheckStaticAtomSizes
                       offsetof(nsStringBuffer, mRefCount)) &&
                      (offsetof(nsFakeStringBuffer<1>, mSize) ==
                       offsetof(nsStringBuffer, mStorageSize)) &&
                      (offsetof(nsFakeStringBuffer<1>, mStringData) ==
                       sizeof(nsStringBuffer)));
   }
 };
 
-NS_COM nsresult
+nsresult
 NS_RegisterStaticAtoms(const nsStaticAtom* aAtoms, PRUint32 aAtomCount)
 {
   // this does three things:
   // 1) wraps each static atom in a wrapper, if necessary
   // 2) initializes the address pointed to by each mBits slot
   // 3) puts the atom into the static atom table as well
   
   if (!gStaticAtomTable && !gStaticAtomTableSealed) {
@@ -485,23 +485,23 @@ NS_RegisterStaticAtoms(const nsStaticAto
       gStaticAtomTable->Put(str, atom);
     }
 #endif
 
   }
   return NS_OK;
 }
 
-NS_COM nsIAtom*
+nsIAtom*
 NS_NewAtom(const char* aUTF8String)
 {
   return NS_NewAtom(nsDependentCString(aUTF8String));
 }
 
-NS_COM nsIAtom*
+nsIAtom*
 NS_NewAtom(const nsACString& aUTF8String)
 {
   AtomTableEntry *he = GetAtomHashEntry(aUTF8String.Data(),
                                         aUTF8String.Length());
 
   if (he->mAtom) {
     nsIAtom* atom;
     NS_ADDREF(atom = he->mAtom);
@@ -516,23 +516,23 @@ NS_NewAtom(const nsACString& aUTF8String
   AtomImpl* atom = new AtomImpl(str);
 
   he->mAtom = atom;
   NS_ADDREF(atom);
 
   return atom;
 }
 
-NS_COM nsIAtom*
+nsIAtom*
 NS_NewAtom(const PRUnichar* aUTF16String)
 {
   return NS_NewAtom(nsDependentString(aUTF16String));
 }
 
-NS_COM nsIAtom*
+nsIAtom*
 NS_NewAtom(const nsAString& aUTF16String)
 {
   AtomTableEntry *he = GetAtomHashEntry(aUTF16String.Data(),
                                         aUTF16String.Length());
 
   if (he->mAtom) {
     nsIAtom* atom;
     NS_ADDREF(atom = he->mAtom);
@@ -542,17 +542,17 @@ NS_NewAtom(const nsAString& aUTF16String
 
   AtomImpl* atom = new AtomImpl(aUTF16String);
   he->mAtom = atom;
   NS_ADDREF(atom);
 
   return atom;
 }
 
-NS_COM nsIAtom*
+nsIAtom*
 NS_NewPermanentAtom(const nsAString& aUTF16String)
 {
   AtomTableEntry *he = GetAtomHashEntry(aUTF16String.Data(),
                                         aUTF16String.Length());
 
   AtomImpl* atom = he->mAtom;
   if (atom) {
     if (!atom->IsPermanent()) {
@@ -563,31 +563,31 @@ NS_NewPermanentAtom(const nsAString& aUT
     atom = new PermanentAtomImpl(aUTF16String);
     he->mAtom = atom;
   }
 
   // No need to addref since permanent atoms aren't refcounted anyway
   return atom;
 }
 
-NS_COM nsrefcnt
+nsrefcnt
 NS_GetNumberOfAtoms(void)
 {
   return gAtomTable.entryCount;
 }
 
-NS_COM nsIAtom*
+nsIAtom*
 NS_GetStaticAtom(const nsAString& aUTF16String)
 {
   NS_PRECONDITION(gStaticAtomTable, "Static atom table not created yet.");
   NS_PRECONDITION(gStaticAtomTableSealed, "Static atom table not sealed yet.");
   nsIAtom* atom;
   if (!gStaticAtomTable->Get(aUTF16String, &atom)) {
     atom = nsnull;
   }
   return atom;
 }
 
-NS_COM void
+void
 NS_SealStaticAtomTable()
 {
   gStaticAtomTableSealed = PR_TRUE;
 }
--- a/xpcom/ds/nsByteBuffer.cpp
+++ b/xpcom/ds/nsByteBuffer.cpp
@@ -146,17 +146,17 @@ ByteBufferImpl::Fill(nsresult* aErrorCod
   if (NS_SUCCEEDED(*aErrorCode)) {
     mLength += nb;
   }
   else
     nb = 0;
   return nb;
 }
 
-NS_COM nsresult NS_NewByteBuffer(nsIByteBuffer** aInstancePtrResult,
+nsresult NS_NewByteBuffer(nsIByteBuffer** aInstancePtrResult,
                                   nsISupports* aOuter,
                                   PRUint32 aBufferSize)
 {
   nsresult rv;
   nsIByteBuffer* buf;
   rv = ByteBufferImpl::Create(aOuter, NS_GET_IID(nsIByteBuffer), (void**)&buf);
   if (NS_FAILED(rv)) return rv;
     
--- a/xpcom/ds/nsCRT.h
+++ b/xpcom/ds/nsCRT.h
@@ -90,17 +90,17 @@ extern const PRUnichar kIsoLatin1ToUCS2[
     ::operator delete(ptr);                             \
   }
 
 // Freeing helper
 #define CRTFREEIF(x) if (x) { nsCRT::free(x); x = 0; }
 
 /// This is a wrapper class around all the C runtime functions. 
 
-class NS_COM nsCRT {
+class nsCRT {
 public:
   enum {
     LF='\n'   /* Line Feed */,
     VTAB='\v' /* Vertical Tab */,
     CR='\r'   /* Carriage Return */
   };
 
   /***
--- a/xpcom/ds/nsCheapSets.h
+++ b/xpcom/ds/nsCheapSets.h
@@ -39,17 +39,17 @@
 #define __nsCheapSets_h__
 
 #include "nsHashSets.h"
 
 /**
  * A string set that takes up minimal size when there are 0 or 1 strings in the
  * set.  Use for cases where sizes of 0 and 1 are even slightly common.
  */
-class NS_COM nsCheapStringSet {
+class nsCheapStringSet {
 public:
   nsCheapStringSet() : mValOrHash(nsnull)
   {
   }
   ~nsCheapStringSet();
 
   /**
    * Put a string into the set
@@ -114,17 +114,17 @@ private:
   void* mValOrHash;
 };
 
 
 /**
  * An integer set that takes up only 4 bytes when there are 0 or 1 integers
  * in the set.  Use for cases where sizes of 0 and 1 are even slightly common.
  */
-class NS_COM nsCheapInt32Set {
+class nsCheapInt32Set {
 public:
   nsCheapInt32Set() : mValOrHash(nsnull)
   {
   }
   ~nsCheapInt32Set();
 
   /**
    * Put an int into the set
--- a/xpcom/ds/nsDoubleHashtable.h
+++ b/xpcom/ds/nsDoubleHashtable.h
@@ -393,17 +393,17 @@ void CLASSNAME::Remove(const KEY_TYPE aK
  *
  * XXX It could be advisable (unless COW strings ever happens) to have a
  * PLDHashDependentStringEntry
  */
 
 //
 // String-key entry
 //
-class NS_COM PLDHashStringEntry : public PLDHashEntryHdr
+class PLDHashStringEntry : public PLDHashEntryHdr
 {
 public:
   PLDHashStringEntry(const void* aKey) :
     mKey(*static_cast<const nsAString*>(aKey)) { }
   ~PLDHashStringEntry() { }
 
   static PLDHashNumber HashKey(const void* key) {
     return HashString(*static_cast<const nsAString*>(key));
@@ -413,17 +413,17 @@ public:
   }
 
   const nsString mKey;
 };
 
 //
 // CString-key entry
 //
-class NS_COM PLDHashCStringEntry : public PLDHashEntryHdr
+class PLDHashCStringEntry : public PLDHashEntryHdr
 {
 public:
   PLDHashCStringEntry(const void* aKey) :
     mKey(*static_cast<const nsACString*>(aKey)) { }
   ~PLDHashCStringEntry() { }
 
   static PLDHashNumber HashKey(const void* key) {
     return HashString(*static_cast<const nsACString*>(key));
@@ -433,17 +433,17 @@ public:
   }
 
   const nsCString mKey;
 };
 
 //
 // Int-key entry
 //
-class NS_COM PLDHashInt32Entry : public PLDHashEntryHdr
+class PLDHashInt32Entry : public PLDHashEntryHdr
 {
 public:
   PLDHashInt32Entry(const void* aKey) :
     mKey(*(static_cast<const PRInt32*>(aKey))) { }
   ~PLDHashInt32Entry() { }
 
   static PLDHashNumber HashKey(const void* key) {
     return *static_cast<const PRInt32*>(key);
@@ -454,17 +454,17 @@ public:
 
   const PRInt32 mKey;
 };
 
 
 //
 // Void-key entry
 //
-class NS_COM PLDHashVoidEntry : public PLDHashEntryHdr
+class PLDHashVoidEntry : public PLDHashEntryHdr
 {
 public:
   PLDHashVoidEntry(const void* aKey) :
     mKey(*(const void**)aKey) { }
   ~PLDHashVoidEntry() { }
 
   static PLDHashNumber HashKey(const void* key) {
     return PLDHashNumber(NS_PTR_TO_INT32(*(const void**)key)) >> 2;
--- a/xpcom/ds/nsFixedSizeAllocator.h
+++ b/xpcom/ds/nsFixedSizeAllocator.h
@@ -129,17 +129,17 @@
 #define nsFixedSizeAllocator_h__
 
 #include "nscore.h"
 #include "nsError.h"
 #include "plarena.h"
 
 #define NS_SIZE_IN_HEAP(_size) (_size)
 
-class NS_COM nsFixedSizeAllocator
+class nsFixedSizeAllocator
 {
 protected:
     PLArenaPool mPool;
 
     struct Bucket;
     struct FreeEntry;
   
     friend struct Bucket;
--- a/xpcom/ds/nsHashPropertyBag.h
+++ b/xpcom/ds/nsHashPropertyBag.h
@@ -43,22 +43,17 @@
 #include "nsCOMPtr.h"
 #include "nsCOMArray.h"
 
 #include "nsIVariant.h"
 #include "nsIWritablePropertyBag.h"
 #include "nsIWritablePropertyBag2.h"
 #include "nsInterfaceHashtable.h"
 
-// Set IMETHOD_VISIBILITY to empty so that the class-level NS_COM declaration
-// controls member method visibility.
-#undef  IMETHOD_VISIBILITY
-#define IMETHOD_VISIBILITY
-
-class NS_COM nsHashPropertyBag : public nsIWritablePropertyBag
+class nsHashPropertyBag : public nsIWritablePropertyBag
                                , public nsIWritablePropertyBag2
 {
 public:
     nsHashPropertyBag() { }
     virtual ~nsHashPropertyBag() {}
 
     nsresult Init();
 
@@ -77,12 +72,12 @@ protected:
     nsInterfaceHashtable<nsStringHashKey, nsIVariant> mPropertyHash;
 };
 
 #undef  IMETHOD_VISIBILITY
 #define IMETHOD_VISIBILITY NS_VISIBILITY_HIDDEN
 
 // Note: NS_NewHashPropertyBag returns a HPB that
 // uses a non-thread-safe internal hash
-extern "C" NS_COM nsresult
+extern "C" nsresult
 NS_NewHashPropertyBag(nsIWritablePropertyBag* *_retval);
 
 #endif /* nsHashPropertyBag_h___ */
--- a/xpcom/ds/nsHashSets.h
+++ b/xpcom/ds/nsHashSets.h
@@ -88,17 +88,17 @@ public:                                 
     return GetEntry(aKey) ? PR_TRUE : PR_FALSE;                               \
   }                                                                           \
 };
 
 #define DHASH_SET(CLASSNAME,ENTRY_CLASS,KEY_TYPE)                              \
 DHASH_WRAPPER(CLASSNAME##Super,ENTRY_CLASS,KEY_TYPE)
 
 #undef DHASH_EXPORT
-#define DHASH_EXPORT NS_COM
+#define DHASH_EXPORT
 
 DECL_DHASH_SET(nsStringHashSet, PLDHashStringEntry, nsAString&)
 DECL_DHASH_SET(nsCStringHashSet,PLDHashCStringEntry,nsACString&)
 DECL_DHASH_SET(nsInt32HashSet,  PLDHashInt32Entry,  PRInt32)
 DECL_DHASH_SET(nsVoidHashSet,   PLDHashVoidEntry,   void*)
 
 #undef DHASH_EXPORT
 #define DHASH_EXPORT
--- a/xpcom/ds/nsHashtable.h
+++ b/xpcom/ds/nsHashtable.h
@@ -61,17 +61,17 @@
 #include "nsTraceRefcnt.h"
 
 class nsIObjectInputStream;
 class nsIObjectOutputStream;
 
 class nsHashtable;
 class nsStringKey;
 
-class NS_COM nsHashKey {
+class nsHashKey {
   protected:
     nsHashKey(void) {
 #ifdef DEBUG
         mKeyType = UnknownKey;
 #endif
         MOZ_COUNT_CTOR(nsHashKey);
     }
 
@@ -123,17 +123,17 @@ typedef nsresult
 // NB: may be called with null aKey or aData, to free just one of the two.
 typedef void
 (* nsHashtableFreeEntryFunc)(nsIObjectInputStream *aStream, nsHashKey *aKey,
                              void *aData);
 
 typedef nsresult
 (* nsHashtableWriteDataFunc)(nsIObjectOutputStream *aStream, void *aData);
 
-class NS_COM nsHashtable {
+class nsHashtable {
   protected:
     // members  
     PRLock*         mLock;
     PLDHashTable    mHashtable;
     PRBool          mEnumerating;
 
   public:
     nsHashtable(PRUint32 aSize = 16, PRBool threadSafe = PR_FALSE);
@@ -158,17 +158,17 @@ class NS_COM nsHashtable {
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsObjectHashtable: an nsHashtable where the elements are C++ objects to be
 // deleted
 
 typedef void* (* nsHashtableCloneElementFunc)(nsHashKey *aKey, void *aData, void* aClosure);
 
-class NS_COM nsObjectHashtable : public nsHashtable {
+class nsObjectHashtable : public nsHashtable {
   public:
     nsObjectHashtable(nsHashtableCloneElementFunc cloneElementFun,
                       void* cloneElementClosure,
                       nsHashtableEnumFunc destroyElementFun,
                       void* destroyElementClosure,
                       PRUint32 aSize = 16, PRBool threadSafe = PR_FALSE);
     ~nsObjectHashtable();
 
@@ -187,17 +187,17 @@ class NS_COM nsObjectHashtable : public 
     void*                       mDestroyElementClosure;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsSupportsHashtable: an nsHashtable where the elements are nsISupports*
 
 class nsISupports;
 
-class NS_COM nsSupportsHashtable
+class nsSupportsHashtable
   : private nsHashtable
 {
   public:
     typedef PRBool (* EnumFunc) (nsHashKey *aKey, void *aData, void* aClosure);
 
     nsSupportsHashtable(PRUint32 aSize = 16, PRBool threadSafe = PR_FALSE)
       : nsHashtable(aSize, threadSafe) {}
     ~nsSupportsHashtable();
@@ -226,17 +226,17 @@ class NS_COM nsSupportsHashtable
                                          PRUint32 i, void *arg);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsISupportsKey: Where keys are nsISupports objects that get refcounted.
 
 #include "nsISupports.h"
 
-class NS_COM nsISupportsKey : public nsHashKey {
+class nsISupportsKey : public nsHashKey {
   protected:
     nsISupports* mKey;
     
   public:
     nsISupportsKey(const nsISupportsKey& aKey) : mKey(aKey.mKey) {
 #ifdef DEBUG
         mKeyType = SupportsKey;
 #endif
@@ -332,17 +332,17 @@ class nsVoidKey : public nsHashKey {
     }
 
     void* GetValue() { return mKey; }
 };
 
 #include "nsString.h"
 
 // for null-terminated c-strings
-class NS_COM nsCStringKey : public nsHashKey {
+class nsCStringKey : public nsHashKey {
   public:
 
     // NB: when serializing, NEVER_OWN keys are deserialized as OWN.
     enum Ownership {
         NEVER_OWN,  // very long lived, even clones don't need to copy it.
         OWN_CLONE,  // as long lived as this key. But clones make a copy.
         OWN         // to be free'd in key dtor. Clones make their own copy.
     };
@@ -366,17 +366,17 @@ class NS_COM nsCStringKey : public nsHas
 
   protected:
     char*       mStr;
     PRUint32    mStrLen;
     Ownership   mOwnership;
 };
 
 // for null-terminated unicode strings
-class NS_COM nsStringKey : public nsHashKey {
+class nsStringKey : public nsHashKey {
   public:
 
     // NB: when serializing, NEVER_OWN keys are deserialized as OWN.
     enum Ownership {
         NEVER_OWN,  // very long lived, even clones don't need to copy it.
         OWN_CLONE,  // as long lived as this key. But clones make a copy.
         OWN         // to be free'd in key dtor. Clones make their own copy.
     };
--- a/xpcom/ds/nsIAtom.idl
+++ b/xpcom/ds/nsIAtom.idl
@@ -113,60 +113,60 @@ protected:
  * count, which requires locking and hurts performance.
  */
 
 
 /**
  * Find an atom that matches the given UTF-8 string.
  * The string is assumed to be zero terminated.
  */
-extern NS_COM nsIAtom* NS_NewAtom(const char* aUTF8String);
+extern nsIAtom* NS_NewAtom(const char* aUTF8String);
 
 inline already_AddRefed<nsIAtom> do_GetAtom(const char* aUTF8String)
     { return NS_NewAtom(aUTF8String); }
  
 /**
  * Find an atom that matches the given UTF-8 string.
  */
-extern NS_COM nsIAtom* NS_NewAtom(const nsACString& aUTF8String);
+extern nsIAtom* NS_NewAtom(const nsACString& aUTF8String);
 inline already_AddRefed<nsIAtom> do_GetAtom(const nsACString& aUTF8String)
     { return NS_NewAtom(aUTF8String); }
 
 /**
  * Find an atom that matches the given UTF-16 string.
  * The string is assumed to be zero terminated.
  */
-extern NS_COM nsIAtom* NS_NewAtom(const PRUnichar* aUTF16String);
+extern nsIAtom* NS_NewAtom(const PRUnichar* aUTF16String);
 inline already_AddRefed<nsIAtom> do_GetAtom(const PRUnichar* aUTF16String)
     { return NS_NewAtom(aUTF16String); }
 
 /**
  * Find an atom that matches the given UTF-16 string.
  */
-extern NS_COM nsIAtom* NS_NewAtom(const nsAString& aUTF16String);
-extern NS_COM nsIAtom* NS_NewPermanentAtom(const nsAString& aUTF16String);
+extern nsIAtom* NS_NewAtom(const nsAString& aUTF16String);
+extern nsIAtom* NS_NewPermanentAtom(const nsAString& aUTF16String);
 inline already_AddRefed<nsIAtom> do_GetAtom(const nsAString& aUTF16String)
     { return NS_NewAtom(aUTF16String); }
 
 /**
  * Return a count of the total number of atoms currently
  * alive in the system.
  */
-extern NS_COM nsrefcnt NS_GetNumberOfAtoms(void);
+extern nsrefcnt NS_GetNumberOfAtoms(void);
 
 /**
  * Return a pointer for a static atom for the string or null if there's 
  * no static atom for this string.
  */
-extern NS_COM nsIAtom* NS_GetStaticAtom(const nsAString& aUTF16String);
+extern nsIAtom* NS_GetStaticAtom(const nsAString& aUTF16String);
 
 /**
  * Seal the static atom table
  */
-extern NS_COM void NS_SealStaticAtomTable();
+extern void NS_SealStaticAtomTable();
 
 class nsAtomString : public nsString
 {
 public:
   nsAtomString(nsIAtom* aAtom)
   {
     aAtom->ToString(*this);
   }
--- a/xpcom/ds/nsIByteBuffer.h
+++ b/xpcom/ds/nsIByteBuffer.h
@@ -83,15 +83,15 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsIByteBuf
 { /* a49d5280-0d6b-11d3-9331-00104ba0fd40 */         \
     0xa49d5280,                                      \
     0x0d6b,                                          \
     0x11d3,                                          \
     {0x93, 0x31, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40} \
 }
 
 /** Create a new byte buffer using the given buffer size. */
-extern NS_COM nsresult 
+extern nsresult 
 NS_NewByteBuffer(nsIByteBuffer** aInstancePtrResult,
                  nsISupports* aOuter,
                  PRUint32 aBufferSize = 0);
 
 #endif /* nsIByteBuffer_h___ */
 
--- a/xpcom/ds/nsICollection.idl
+++ b/xpcom/ds/nsICollection.idl
@@ -58,17 +58,17 @@ interface nsICollection : nsISerializabl
 };
 
 %{C++
 
 #ifndef nsCOMPtr_h__
 #include "nsCOMPtr.h"
 #endif
 
-class NS_COM nsQueryElementAt : public nsCOMPtr_helper
+class nsQueryElementAt : public nsCOMPtr_helper
   {
     public:
       nsQueryElementAt( nsICollection* aCollection, PRUint32 aIndex, nsresult* aErrorPtr )
           : mCollection(aCollection),
             mIndex(aIndex),
             mErrorPtr(aErrorPtr)
         {
           // nothing else to do here
--- a/xpcom/ds/nsISupportsArray.idl
+++ b/xpcom/ds/nsISupportsArray.idl
@@ -62,17 +62,17 @@ class nsISupportsArray;
     {0x93, 0x31, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40} \
 }
 #define NS_SUPPORTSARRAY_CONTRACTID "@mozilla.org/supports-array;1"
 #define NS_SUPPORTSARRAY_CLASSNAME "Supports Array"
  
 // Enumerator callback function. Return PR_FALSE to stop
 typedef PRBool (*nsISupportsArrayEnumFunc)(nsISupports* aElement, void *aData);
  
-NS_COM nsresult
+nsresult
 NS_NewArrayEnumerator(nsISimpleEnumerator* *result NS_OUTPARAM,
                       nsISupportsArray* array);
 %}
 
 [scriptable, uuid(791eafa0-b9e6-11d1-8031-006008159b5a)]
 interface nsISupportsArray : nsICollection {
 
   [notxpcom] boolean Equals([const] in nsISupportsArray other);
@@ -126,18 +126,18 @@ interface nsISupportsArray : nsICollecti
 
   [notxpcom] boolean SizeTo(in long aSize);
   
 };
 
 %{C++
 
 // Construct and return a default implementation of nsISupportsArray:
-extern NS_COM nsresult
+extern nsresult
 NS_NewISupportsArray(nsISupportsArray** aInstancePtrResult);
 
 // Construct and return a default implementation of an enumerator for nsISupportsArrays:
-extern NS_COM nsresult
+extern nsresult
 NS_NewISupportsArrayEnumerator(nsISupportsArray* array,
                                nsIBidirectionalEnumerator* *aInstancePtrResult);
 
 
 %}
--- a/xpcom/ds/nsIUnicharBuffer.h
+++ b/xpcom/ds/nsIUnicharBuffer.h
@@ -54,17 +54,17 @@ public:
   NS_IMETHOD_(PRInt32) GetBufferSize() const = 0;
   NS_IMETHOD_(PRUnichar*) GetBuffer() const = 0;
   NS_IMETHOD_(PRBool) Grow(PRInt32 aNewSize) = 0;
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(nsIUnicharBuffer, NS_IUNICHARBUFFER_IID)
 
 /// Factory method for nsIUnicharBuffer.
-extern NS_COM nsresult
+extern nsresult
 NS_NewUnicharBuffer(nsIUnicharBuffer** aInstancePtrResult,
                     nsISupports* aOuter,
                     PRUint32 aBufferSize = 0);
 
 #define NS_UNICHARBUFFER_CID                         \
 { /* c81fd8f0-0d6b-11d3-9331-00104ba0fd40 */         \
     0xc81fd8f0,                                      \
     0x0d6b,                                          \
--- a/xpcom/ds/nsRecyclingAllocator.h
+++ b/xpcom/ds/nsRecyclingAllocator.h
@@ -66,17 +66,17 @@
 #include "nsIRecyclingAllocator.h"
 
 #define NS_DEFAULT_RECYCLE_TIMEOUT 10  // secs
 #define NS_ALLOCATOR_OVERHEAD_BYTES (sizeof(PRSize)) // bytes
 
 class nsITimer;
 class nsIMemory;
 
-class NS_COM nsRecyclingAllocator {
+class nsRecyclingAllocator {
  protected:
     struct Block {
       PRSize bytes;
       Block *next;
     };
 
 #define DATA(block) ((void *)(((char *)block) + NS_ALLOCATOR_OVERHEAD_BYTES))
 #define DATA_TO_BLOCK(data) ((Block *)((char *)(data) - NS_ALLOCATOR_OVERHEAD_BYTES))
--- a/xpcom/ds/nsStaticAtom.h
+++ b/xpcom/ds/nsStaticAtom.h
@@ -72,12 +72,12 @@ struct nsStaticAtom {
 template <PRUint32 size>
 struct nsFakeStringBuffer {
     PRInt32 mRefCnt;
     PRUint32 mSize;
     nsStaticAtomStringType mStringData[size];
 };
 
 // Register static atoms with the atom table
-NS_COM nsresult
+nsresult
 NS_RegisterStaticAtoms(const nsStaticAtom*, PRUint32 aAtomCount);
 
 #endif
--- a/xpcom/ds/nsStaticNameTable.h
+++ b/xpcom/ds/nsStaticNameTable.h
@@ -54,17 +54,17 @@
  * - It is not an xpcom interface - meant for fast lookup in static tables.
  *
  * ***REQUIREMENTS***
  * - It *requires* that all entries in the table be lowercase only.
  * - It *requires* that the table of strings be in memory that lives at least
  *    as long as this table object - typically a static string array.
  */
 
-class NS_COM nsStaticCaseInsensitiveNameTable
+class nsStaticCaseInsensitiveNameTable
 {
 public:
   enum { NOT_FOUND = -1 };
 
   PRBool           Init(const char* const aNames[], PRInt32 Count);
   PRInt32          Lookup(const nsACString& aName);
   PRInt32          Lookup(const nsAString& aName);
   const nsAFlatCString& GetStringValue(PRInt32 index);
--- a/xpcom/ds/nsStringEnumerator.cpp
+++ b/xpcom/ds/nsStringEnumerator.cpp
@@ -186,74 +186,74 @@ StringEnumeratorTail(T** aResult NS_INPA
     NS_ADDREF(*aResult);
     return NS_OK;
 }
 
 //
 // constructors
 //
 
-NS_COM nsresult
+nsresult
 NS_NewStringEnumerator(nsIStringEnumerator** aResult,
                        const nsTArray<nsString>* aArray, nsISupports* aOwner)
 {
     NS_ENSURE_ARG_POINTER(aResult);
     NS_ENSURE_ARG_POINTER(aArray);
     
     *aResult = new nsStringEnumerator(aArray, aOwner);
     return StringEnumeratorTail(aResult);
 }
 
 
-NS_COM nsresult
+nsresult
 NS_NewUTF8StringEnumerator(nsIUTF8StringEnumerator** aResult,
                            const nsTArray<nsCString>* aArray, nsISupports* aOwner)
 {
     NS_ENSURE_ARG_POINTER(aResult);
     NS_ENSURE_ARG_POINTER(aArray);
     
     *aResult = new nsStringEnumerator(aArray, aOwner);
     return StringEnumeratorTail(aResult);
 }
 
-NS_COM nsresult
+nsresult
 NS_NewAdoptingStringEnumerator(nsIStringEnumerator** aResult,
                                nsTArray<nsString>* aArray)
 {
     NS_ENSURE_ARG_POINTER(aResult);
     NS_ENSURE_ARG_POINTER(aArray);
     
     *aResult = new nsStringEnumerator(aArray, PR_TRUE);
     return StringEnumeratorTail(aResult);
 }
 
-NS_COM nsresult
+nsresult
 NS_NewAdoptingUTF8StringEnumerator(nsIUTF8StringEnumerator** aResult,
                                    nsTArray<nsCString>* aArray)
 {
     NS_ENSURE_ARG_POINTER(aResult);
     NS_ENSURE_ARG_POINTER(aArray);
     
     *aResult = new nsStringEnumerator(aArray, PR_TRUE);
     return StringEnumeratorTail(aResult);
 }
 
 // const ones internally just forward to the non-const equivalents
-NS_COM nsresult
+nsresult
 NS_NewStringEnumerator(nsIStringEnumerator** aResult,
                        const nsTArray<nsString>* aArray)
 {
     NS_ENSURE_ARG_POINTER(aResult);
     NS_ENSURE_ARG_POINTER(aArray);
     
     *aResult = new nsStringEnumerator(aArray, PR_FALSE);
     return StringEnumeratorTail(aResult);
 }
 
-NS_COM nsresult
+nsresult
 NS_NewUTF8StringEnumerator(nsIUTF8StringEnumerator** aResult,
                            const nsTArray<nsCString>* aArray)
 {
     NS_ENSURE_ARG_POINTER(aResult);
     NS_ENSURE_ARG_POINTER(aArray);
     
     *aResult = new nsStringEnumerator(aArray, PR_FALSE);
     return StringEnumeratorTail(aResult);
--- a/xpcom/ds/nsStringEnumerator.h
+++ b/xpcom/ds/nsStringEnumerator.h
@@ -70,54 +70,54 @@
 // array.AppendCString("abc");
 // array.AppendCString("def");
 // NS_NewStringEnumerator(&enumerator, &array, PR_TRUE);
 //
 // // call some internal method which iterates the enumerator
 // InternalMethod(enumerator);
 // NS_RELEASE(enumerator);
 //
-NS_COM nsresult
+nsresult
 NS_NewStringEnumerator(nsIStringEnumerator** aResult NS_OUTPARAM,
                        const nsTArray<nsString>* aArray,
                        nsISupports* aOwner);
-NS_COM nsresult
+nsresult
 NS_NewUTF8StringEnumerator(nsIUTF8StringEnumerator** aResult NS_OUTPARAM,
                            const nsTArray<nsCString>* aArray);
 
-NS_COM nsresult
+nsresult
 NS_NewStringEnumerator(nsIStringEnumerator** aResult NS_OUTPARAM,
                        const nsTArray<nsString>* aArray);
 
 // Adopting string enumerators assume ownership of the array and will
 // call |operator delete| on the array when the enumerator is destroyed
 // this is useful when the provider creates an array solely for the
 // purpose of creating the enumerator.
 // For example:
 //
 // nsTArray<nsCString>* array = new nsTArray<nsCString>;
 // array->AppendString("abcd");
 // NS_NewAdoptingStringEnumerator(&result, array);
-NS_COM nsresult
+nsresult
 NS_NewAdoptingStringEnumerator(nsIStringEnumerator** aResult NS_OUTPARAM,
                                nsTArray<nsString>* aArray);
 
-NS_COM nsresult
+nsresult
 NS_NewAdoptingUTF8StringEnumerator(nsIUTF8StringEnumerator** aResult NS_OUTPARAM,
                                    nsTArray<nsCString>* aArray);
 
 
 // these versions take a refcounted "owner" which will be addreffed
 // when the enumerator is created, and destroyed when the enumerator
 // is released. This allows providers to give non-owning pointers to
 // ns*StringArray member variables without worrying about lifetime
 // issues
 // For example:
 //
 // nsresult MyClass::Enumerate(nsIUTF8StringEnumerator** aResult) {
 //     mCategoryList->AppendString("abcd");
 //     return NS_NewStringEnumerator(aResult, mCategoryList, this);
 // }
 //
-NS_COM nsresult
+nsresult
 NS_NewUTF8StringEnumerator(nsIUTF8StringEnumerator** aResult NS_OUTPARAM,
                            const nsTArray<nsCString>* aArray,
                            nsISupports* aOwner);
--- a/xpcom/ds/nsSupportsArray.cpp
+++ b/xpcom/ds/nsSupportsArray.cpp
@@ -668,17 +668,17 @@ nsSupportsArray::Clone(nsISupportsArray*
   nsISupportsArray* newArray;
   rv = NS_NewISupportsArray(&newArray);
   PRBool ok = EnumerateForwards(CopyElement, newArray);
   if (!ok) return NS_ERROR_OUT_OF_MEMORY;
   *result = newArray;
   return NS_OK;
 }
 
-NS_COM nsresult
+nsresult
 NS_NewISupportsArray(nsISupportsArray** aInstancePtrResult)
 {
   nsresult rv;
   rv = nsSupportsArray::Create(NULL, NS_GET_IID(nsISupportsArray),
                                (void**)aInstancePtrResult);
   return rv;
 }
 
--- a/xpcom/ds/nsSupportsArray.h
+++ b/xpcom/ds/nsSupportsArray.h
@@ -39,22 +39,17 @@
 #define nsSupportsArray_h__
 
 //#define DEBUG_SUPPORTSARRAY 1
 
 #include "nsISupportsArray.h"
 
 static const PRUint32 kAutoArraySize = 8;
 
-// Set IMETHOD_VISIBILITY to empty so that the class-level NS_COM declaration
-// controls member method visibility.
-#undef  IMETHOD_VISIBILITY
-#define IMETHOD_VISIBILITY
-
-class NS_COM nsSupportsArray : public nsISupportsArray {
+class nsSupportsArray : public nsISupportsArray {
 public:
   nsSupportsArray(void);
   ~nsSupportsArray(void); // nonvirtual since we're not subclassed
 
   static nsresult
   Create(nsISupports *aOuter, REFNSIID aIID, void **aResult);
 
   NS_DECL_ISUPPORTS
--- a/xpcom/ds/nsSupportsArrayEnumerator.cpp
+++ b/xpcom/ds/nsSupportsArrayEnumerator.cpp
@@ -125,17 +125,17 @@ nsSupportsArrayEnumerator::Prev()
   if (mCursor >= 0)
     return NS_OK;
   else
     return NS_ERROR_FAILURE;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-NS_COM nsresult
+nsresult
 NS_NewISupportsArrayEnumerator(nsISupportsArray* array,
                                nsIBidirectionalEnumerator* *aInstancePtrResult)
 {
   if (aInstancePtrResult == 0)
     return NS_ERROR_NULL_POINTER;
   nsSupportsArrayEnumerator* e = new nsSupportsArrayEnumerator(array);
   if (e == 0)
     return NS_ERROR_OUT_OF_MEMORY;
--- a/xpcom/ds/nsUnicharBuffer.cpp
+++ b/xpcom/ds/nsUnicharBuffer.cpp
@@ -116,17 +116,17 @@ UnicharBufferImpl::Grow(PRInt32 aNewSize
     }
     delete[] mBuffer;
     mBuffer = newbuf;
     return PR_TRUE;
   }
   return PR_FALSE;
 }
 
-NS_COM nsresult
+nsresult
 NS_NewUnicharBuffer(nsIUnicharBuffer** aInstancePtrResult,
                     nsISupports* aOuter,
                     PRUint32 aBufferSize)
 {
   nsresult rv;
   nsIUnicharBuffer* buf;
   rv = UnicharBufferImpl::Create(aOuter, NS_GET_IID(nsIUnicharBuffer), 
                                  (void**)&buf);
--- a/xpcom/ds/nsVariant.h
+++ b/xpcom/ds/nsVariant.h
@@ -108,17 +108,17 @@ struct nsDiscriminatedUnion
  * these objects. They are created 'empty' and 'writable'. 
  *
  * nsIVariant users won't usually need to see this class.
  *
  * This class also has static helper methods that nsIVariant *implementors* can
  * use to help them do all the 'standard' nsIVariant data conversions.
  */
 
-class NS_COM nsVariant : public nsIWritableVariant
+class nsVariant : public nsIWritableVariant
 {
 public:
     NS_DECL_ISUPPORTS
     NS_DECL_NSIVARIANT
     NS_DECL_NSIWRITABLEVARIANT
 
     nsVariant();
 
--- a/xpcom/ds/nsWindowsRegKey.h
+++ b/xpcom/ds/nsWindowsRegKey.h
@@ -48,17 +48,17 @@
  * via the XPCOM component manager.
  */
 #define NS_WINDOWSREGKEY_CONTRACTID "@mozilla.org/windows-registry-key;1"
 
 /**
  * This function may be used to instantiate a windows registry key object prior
  * to XPCOM being initialized.
  */
-extern "C" NS_COM nsresult
+extern "C" nsresult
 NS_NewWindowsRegKey(nsIWindowsRegKey **result);
 
 //-----------------------------------------------------------------------------
 
 #ifdef _IMPL_NS_COM
 
 #define NS_WINDOWSREGKEY_CLASSNAME "nsWindowsRegKey"
 
--- a/xpcom/glue/nsCycleCollectorUtils.h
+++ b/xpcom/glue/nsCycleCollectorUtils.h
@@ -38,17 +38,17 @@
 #define nsCycleCollectorUtils_h__
 
 #include "nscore.h"
 #include "mozilla/threads/nsThreadIDs.h"
 
 #if defined(MOZILLA_INTERNAL_API)
 #define NS_IsCycleCollectorThread NS_IsCycleCollectorThread_P
 #if defined(XP_WIN)
-NS_COM bool NS_IsCycleCollectorThread();
+bool NS_IsCycleCollectorThread();
 #elif defined(NS_TLS)
 // Defined in nsThreadManager.cpp.
 extern NS_TLS mozilla::threads::ID gTLSThreadID;
 inline bool NS_IsCycleCollectorThread()
 {
   return gTLSThreadID == mozilla::threads::CycleCollector;
 }
 #else
--- a/xpcom/glue/nsThreadUtils.h
+++ b/xpcom/glue/nsThreadUtils.h
@@ -100,17 +100,17 @@ NS_GetCurrentThread(nsIThread **result);
  *
  * @param result
  *   The resulting nsIThread object.
  */
 extern NS_COM_GLUE NS_METHOD
 NS_GetMainThread(nsIThread **result);
 
 #if defined(MOZILLA_INTERNAL_API) && defined(XP_WIN)
-NS_COM bool NS_IsMainThread();
+bool NS_IsMainThread();
 #elif defined(MOZILLA_INTERNAL_API) && defined(NS_TLS)
 // This is defined in nsThreadManager.cpp and initialized to `Main` for the
 // main thread by nsThreadManager::Init.
 extern NS_TLS mozilla::threads::ID gTLSThreadID;
 inline bool NS_IsMainThread()
 {
   return gTLSThreadID == mozilla::threads::Main;
 }
--- a/xpcom/io/SpecialSystemDirectory.cpp
+++ b/xpcom/io/SpecialSystemDirectory.cpp
@@ -100,31 +100,31 @@ typedef HRESULT (WINAPI* nsGetKnownFolde
                                                HANDLE hToken,
                                                PWSTR *ppszPath);
 
 static nsGetKnownFolderPath gGetKnownFolderPath = NULL;
 
 static HINSTANCE gShell32DLLInst = NULL;
 #endif
 
-NS_COM void StartupSpecialSystemDirectory()
+void StartupSpecialSystemDirectory()
 {
 #if defined (XP_WIN)
     // SHGetKnownFolderPath is only available on Windows Vista
     // so that we need to use GetProcAddress to get the pointer.
     gShell32DLLInst = LoadLibraryW(L"shell32.dll");
     if(gShell32DLLInst)
     {
         gGetKnownFolderPath = (nsGetKnownFolderPath)
             GetProcAddress(gShell32DLLInst, "SHGetKnownFolderPath");
     }
 #endif
 }
 
-NS_COM void ShutdownSpecialSystemDirectory()
+void ShutdownSpecialSystemDirectory()
 {
 #if defined (XP_WIN)
     if (gShell32DLLInst)
     {
         FreeLibrary(gShell32DLLInst);
         gShell32DLLInst = NULL;
         gGetKnownFolderPath = NULL;
     }
--- a/xpcom/io/SpecialSystemDirectory.h
+++ b/xpcom/io/SpecialSystemDirectory.h
@@ -45,19 +45,18 @@
 #include "nsILocalFile.h"
 
 #ifdef XP_MACOSX
 #include <Carbon/Carbon.h>
 #include "nsILocalFileMac.h"
 #include "prenv.h"
 #endif
 
-
-extern NS_COM void StartupSpecialSystemDirectory();
-extern NS_COM void ShutdownSpecialSystemDirectory();
+extern void StartupSpecialSystemDirectory();
+extern void ShutdownSpecialSystemDirectory();
 
 
 enum SystemDirectories {
   OS_DriveDirectory         =   1,   
   OS_TemporaryDirectory     =   2,   
   OS_CurrentProcessDirectory=   3,   
   OS_CurrentWorkingDirectory=   4,
   XPCOM_CurrentProcessComponentDirectory=   5,   
--- a/xpcom/io/nsEscape.cpp
+++ b/xpcom/io/nsEscape.cpp
@@ -151,34 +151,34 @@ static char* nsEscapeCount(
 
     *dst = '\0';     /* tack on eos */
 	if(out_len)
 		*out_len = dst - (unsigned char *) result;
     return result;
 }
 
 //----------------------------------------------------------------------------------------
-NS_COM char* nsEscape(const char * str, nsEscapeMask flags)
+char* nsEscape(const char * str, nsEscapeMask flags)
 //----------------------------------------------------------------------------------------
 {
     if(!str)
         return NULL;
     return nsEscapeCount(str, flags, NULL);
 }
 
 //----------------------------------------------------------------------------------------
-NS_COM char* nsUnescape(char * str)
+char* nsUnescape(char * str)
 //----------------------------------------------------------------------------------------
 {
 	nsUnescapeCount(str);
 	return str;
 }
 
 //----------------------------------------------------------------------------------------
-NS_COM PRInt32 nsUnescapeCount(char * str)
+PRInt32 nsUnescapeCount(char * str)
 //----------------------------------------------------------------------------------------
 {
     register char *src = str;
     register char *dst = str;
     static const char hexChars[] = "0123456789ABCDEFabcdef";
 
     char c1[] = " ";
     char c2[] = " ";
@@ -214,17 +214,17 @@ NS_COM PRInt32 nsUnescapeCount(char * st
     }
 
     *dst = 0;
     return (int)(dst - str);
 
 } /* NET_UnEscapeCnt */
 
 
-NS_COM char *
+char *
 nsEscapeHTML(const char * string)
 {
     char *rv = nsnull;
     /* XXX Hardcoded max entity len. The +1 is for the trailing null. */
     PRUint32 len = PL_strlen(string);
     if (len >= (PR_UINT32_MAX / 6))
       return nsnull;
 
@@ -280,17 +280,17 @@ nsEscapeHTML(const char * string)
               }
           }
         *ptr = '\0';
       }
 
     return(rv);
 }
 
-NS_COM PRUnichar *
+PRUnichar *
 nsEscapeHTML2(const PRUnichar *aSourceBuffer, PRInt32 aSourceBufferLen)
 {
   // if the caller didn't calculate the length
   if (aSourceBufferLen < 0) {
     aSourceBufferLen = nsCRT::strlen(aSourceBuffer); // ...then I will
   }
 
   /* XXX Hardcoded max entity len. */
@@ -386,17 +386,17 @@ const int EscapeChars[256] =
    that already look escaped, which means it already includes 
    a valid hexcode. This is done to avoid multiple escapes of
    a string. Use the following flags to force escaping of a 
    string:
  
    esc_Forced        =  1024
 */
 
-NS_COM PRBool NS_EscapeURL(const char *part,
+PRBool NS_EscapeURL(const char *part,
                            PRInt32 partLen,
                            PRUint32 flags,
                            nsACString &result)
 {
     if (!part) {
         NS_NOTREACHED("null pointer");
         return PR_FALSE;
     }
@@ -472,17 +472,17 @@ NS_COM PRBool NS_EscapeURL(const char *p
       tempBuffer[tempBufferPos] = '\0';
       result += tempBuffer;
     }
     return writing;
 }
 
 #define ISHEX(c) memchr(hexChars, c, sizeof(hexChars)-1)
 
-NS_COM PRBool NS_UnescapeURL(const char *str, PRInt32 len, PRUint32 flags, nsACString &result)
+PRBool NS_UnescapeURL(const char *str, PRInt32 len, PRUint32 flags, nsACString &result)
 {
     if (!str) {
         NS_NOTREACHED("null pointer");
         return PR_FALSE;
     }
 
     if (len < 0)
         len = strlen(str);
--- a/xpcom/io/nsEscape.h
+++ b/xpcom/io/nsEscape.h
@@ -63,33 +63,33 @@ extern "C" {
 
 /**
  * Escape the given string according to mask
  * @param str The string to escape
  * @param mask How to escape the string
  * @return A newly allocated escaped string that must be free'd with
  *         nsCRT::free, or null on failure
  */
-NS_COM char * nsEscape(const char * str, nsEscapeMask mask);
+char * nsEscape(const char * str, nsEscapeMask mask);
 
-NS_COM char * nsUnescape(char * str);
+char * nsUnescape(char * str);
 	/* decode % escaped hex codes into character values,
 	 * modifies the parameter, returns the same buffer
 	 */
 
-NS_COM PRInt32 nsUnescapeCount (char * str);
+PRInt32 nsUnescapeCount (char * str);
 	/* decode % escaped hex codes into character values,
 	 * modifies the parameter buffer, returns the length of the result
 	 * (result may contain \0's).
 	 */
 
-NS_COM char *
+char *
 nsEscapeHTML(const char * string);
 
-NS_COM PRUnichar *
+PRUnichar *
 nsEscapeHTML2(const PRUnichar *aSourceBuffer,
               PRInt32 aSourceBufferLen = -1);
  /*
   * Escape problem char's for HTML display 
   */
 
 
 #ifdef __cplusplus
@@ -137,33 +137,33 @@ enum EscapeMask {
  *
  * @param  str     url segment string
  * @param  len     url segment string length (-1 if unknown)
  * @param  flags   url segment type flag
  * @param  result  result buffer, untouched if part is already escaped
  *
  * @return TRUE if escaping was performed, FALSE otherwise.
  */
-NS_COM PRBool NS_EscapeURL(const char *str,
+PRBool NS_EscapeURL(const char *str,
                            PRInt32 len,
                            PRUint32 flags,
                            nsACString &result);
 
 /**
  * Expands URL escape sequences... beware embedded null bytes!
  *
  * @param  str     url string to unescape
  * @param  len     length of |str|
  * @param  flags   only esc_OnlyNonASCII, esc_SkipControl and esc_AlwaysCopy 
  *                 are recognized
  * @param  result  result buffer, untouched if |str| is already unescaped
  *
  * @return TRUE if unescaping was performed, FALSE otherwise.
  */
-NS_COM PRBool NS_UnescapeURL(const char *str,
+PRBool NS_UnescapeURL(const char *str,
                              PRInt32 len,
                              PRUint32 flags,
                              nsACString &result);
 
 /** returns resultant string length **/
 inline PRInt32 NS_UnescapeURL(char *str) {
     return nsUnescapeCount(str);
 }
--- a/xpcom/io/nsIInputStreamTee.idl
+++ b/xpcom/io/nsIInputStreamTee.idl
@@ -58,19 +58,19 @@ interface nsIInputStreamTee : nsIInputSt
      * storage-policy is STORE_ON_DISK_AS_FILE, copying to sink happens
      * synchronously while reading from the source.
      */
     attribute nsIEventTarget eventTarget;
 };
 
 %{C++
 // factory methods
-extern NS_COM nsresult
+extern nsresult
 NS_NewInputStreamTee(nsIInputStream **tee, // read from this input stream
                      nsIInputStream *source,
                      nsIOutputStream *sink);
                      
-extern NS_COM nsresult
+extern nsresult
 NS_NewInputStreamTeeAsync(nsIInputStream **tee, // read from this input stream
                      nsIInputStream *source,
                      nsIOutputStream *sink,
                      nsIEventTarget *eventTarget);
 %}
--- a/xpcom/io/nsIPipe.idl
+++ b/xpcom/io/nsIPipe.idl
@@ -156,17 +156,17 @@ interface nsISearchableInputStream : nsI
  *        specifies the max number of segments (pass 0 to use default value)
  *        passing PR_UINT32_MAX here causes the pipe to have "infinite" space.
  *        this mode can be useful in some cases, but should always be used with
  *        caution.  the default value for this parameter is a finite value.
  * @param segmentAlloc
  *        pass reference to nsIMemory to have all pipe allocations use this
  *        allocator (pass null to use the default allocator)
  */
-extern NS_COM nsresult
+extern nsresult
 NS_NewPipe2(nsIAsyncInputStream **pipeIn,
             nsIAsyncOutputStream **pipeOut,
             PRBool nonBlockingInput = PR_FALSE,
             PRBool nonBlockingOutput = PR_FALSE,
             PRUint32 segmentSize = 0,
             PRUint32 segmentCount = 0,
             nsIMemory *segmentAlloc = nsnull);
 
@@ -193,17 +193,17 @@ NS_NewPipe2(nsIAsyncInputStream **pipeIn
  * @param nonBlockingInput
  *        true specifies non-blocking input stream behavior
  * @param nonBlockingOutput
  *        true specifies non-blocking output stream behavior
  * @param segmentAlloc
  *        pass reference to nsIMemory to have all pipe allocations use this
  *        allocator (pass null to use the default allocator)
  */
-extern NS_COM nsresult
+extern nsresult
 NS_NewPipe(nsIInputStream **pipeIn,
            nsIOutputStream **pipeOut,
            PRUint32 segmentSize = 0,
            PRUint32 maxSize = 0,
            PRBool nonBlockingInput = PR_FALSE,
            PRBool nonBlockingOutput = PR_FALSE,
            nsIMemory *segmentAlloc = nsnull);
 
--- a/xpcom/io/nsIStorageStream.idl
+++ b/xpcom/io/nsIStorageStream.idl
@@ -97,11 +97,11 @@ interface nsIStorageStream : nsISupports
     /**
      * True, when output stream has not yet been Close'ed
      */
     readonly attribute boolean writeInProgress;
 };
 
 %{C++
 // Factory method
-NS_COM nsresult
+nsresult
 NS_NewStorageStream(PRUint32 segmentSize, PRUint32 maxSize, nsIStorageStream **result);
 %}
--- a/xpcom/io/nsInputStreamTee.cpp
+++ b/xpcom/io/nsInputStreamTee.cpp
@@ -333,17 +333,17 @@ nsInputStreamTee::SetEventTarget(nsIEven
 NS_IMETHODIMP
 nsInputStreamTee::GetEventTarget(nsIEventTarget **anEventTarget)
 {
     NS_IF_ADDREF(*anEventTarget = mEventTarget);
     return NS_OK;
 }
 
 
-NS_COM nsresult
+nsresult
 NS_NewInputStreamTeeAsync(nsIInputStream **result,
                           nsIInputStream *source,
                           nsIOutputStream *sink,
                           nsIEventTarget *anEventTarget)
 {
     nsresult rv;
     
     nsCOMPtr<nsIInputStreamTee> tee = new nsInputStreamTee();
@@ -358,15 +358,15 @@ NS_NewInputStreamTeeAsync(nsIInputStream
 
     rv = tee->SetEventTarget(anEventTarget);
     if (NS_FAILED(rv)) return rv;
 
     NS_ADDREF(*result = tee);
     return rv;
 }
 
-NS_COM nsresult
+nsresult
 NS_NewInputStreamTee(nsIInputStream **result,
                      nsIInputStream *source,
                      nsIOutputStream *sink)
 {
     return NS_NewInputStreamTeeAsync(result, source, sink, nsnull);
 }
--- a/xpcom/io/nsLinebreakConverter.h
+++ b/xpcom/io/nsLinebreakConverter.h
@@ -33,23 +33,22 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef nsLinebreakConverter_h_
 #define nsLinebreakConverter_h_
 
-
 #include "nscore.h"
 #include "nsString.h"
 
 // utility class for converting between different line breaks.
 
-class NS_COM nsLinebreakConverter
+class nsLinebreakConverter
 {
 public:
 
   // Note: enum must match char* array in GetLinebreakString
   typedef enum {
     eLinebreakAny,          // any kind of linebreak (i.e. "don't care" source)
     
     eLinebreakPlatform,     // platform linebreak
@@ -147,12 +146,9 @@ public:
    *              terminated string.
    * @param aOutLen: used to return character length of returned buffer, if not null.
    */
   static nsresult ConvertUnicharLineBreaksInSitu(PRUnichar **ioBuffer, ELinebreakType aSrcBreaks, ELinebreakType aDestBreaks,
                         PRInt32 aSrcLen = kIgnoreLen, PRInt32* aOutLen = nsnull);
     
 };
 
-
-
-
 #endif // nsLinebreakConverter_h_
--- a/xpcom/io/nsLocalFileOS2.h
+++ b/xpcom/io/nsLocalFileOS2.h
@@ -62,18 +62,18 @@
 #define INCL_DOSERRORS
 #define INCL_WINCOUNTRY
 #define INCL_WINWORKPLACE
 
 #include <os2.h>
 
 class TypeEaEnumerator;
 
-class NS_COM nsLocalFile : public nsILocalFileOS2,
-                                   public nsIHashable
+class nsLocalFile : public nsILocalFileOS2,
+                    public nsIHashable
 {
 public:
     NS_DEFINE_STATIC_CID_ACCESSOR(NS_LOCAL_FILE_CID)
 
     nsLocalFile();
 
     static nsresult nsLocalFileConstructor(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr);
 
--- a/xpcom/io/nsLocalFileUnix.cpp
+++ b/xpcom/io/nsLocalFileUnix.cpp
@@ -127,17 +127,17 @@ static nsresult MacErrorMapper(OSErr inE
 
 #define CHECK_mPath()                           \
     PR_BEGIN_MACRO                              \
         if (mPath.IsEmpty())                    \
             return NS_ERROR_NOT_INITIALIZED;    \
     PR_END_MACRO
 
 /* directory enumerator */
-class NS_COM
+class
 nsDirEnumeratorUnix : public nsISimpleEnumerator,
                       public nsIDirectoryEnumerator
 {
     public:
     nsDirEnumeratorUnix();
 
     // nsISupports interface
     NS_DECL_ISUPPORTS
--- a/xpcom/io/nsLocalFileUnix.h
+++ b/xpcom/io/nsLocalFileUnix.h
@@ -103,17 +103,17 @@
     #define LSTAT lstat64
     #define HAVE_STATS64 1
 #else
     #define STAT stat
     #define LSTAT lstat
 #endif
 
 
-class NS_COM nsLocalFile :
+class nsLocalFile :
 #ifdef XP_MACOSX
                            public nsILocalFileMac,
 #else
                            public nsILocalFile,
 #endif
                            public nsIHashable
 {
 public:
--- a/xpcom/io/nsNativeCharsetUtils.cpp
+++ b/xpcom/io/nsNativeCharsetUtils.cpp
@@ -46,24 +46,24 @@
 // XP_MACOSX or ANDROID
 //-----------------------------------------------------------------------------
 #if defined(XP_MACOSX) || defined(ANDROID)
 
 #include "nsAString.h"
 #include "nsReadableUtils.h"
 #include "nsString.h"
 
-NS_COM nsresult
+nsresult
 NS_CopyNativeToUnicode(const nsACString &input, nsAString  &output)
 {
     CopyUTF8toUTF16(input, output);
     return NS_OK;
 }
 
-NS_COM nsresult
+nsresult
 NS_CopyUnicodeToNative(const nsAString  &input, nsACString &output)
 {
     CopyUTF16toUTF8(input, output);
     return NS_OK;
 }
 
 void
 NS_StartupNativeCharsetUtils()
@@ -797,17 +797,17 @@ nsNativeCharsetConverter::IsNativeUTF8()
 }
 
 #endif // USE_STDCONV
 
 //-----------------------------------------------------------------------------
 // API implementation
 //-----------------------------------------------------------------------------
 
-NS_COM nsresult
+nsresult
 NS_CopyNativeToUnicode(const nsACString &input, nsAString &output)
 {
     output.Truncate();
 
     PRUint32 inputLen = input.Length();
 
     nsACString::const_iterator iter;
     input.BeginReading(iter);
@@ -834,17 +834,17 @@ NS_CopyNativeToUnicode(const nsACString 
     nsresult rv = conv.NativeToUnicode(&buf, &bufLeft, &result, &resultLeft);
     if (NS_SUCCEEDED(rv)) {
         NS_ASSERTION(bufLeft == 0, "did not consume entire input buffer");
         output.SetLength(inputLen - resultLeft);
     }
     return rv;
 }
 
-NS_COM nsresult
+nsresult
 NS_CopyUnicodeToNative(const nsAString &input, nsACString &output)
 {
     output.Truncate();
 
     nsAString::const_iterator iter, end;
     input.BeginReading(iter);
     input.EndReading(end);
 
@@ -863,17 +863,17 @@ NS_CopyUnicodeToNative(const nsAString &
         if (NS_FAILED(rv)) return rv;
 
         if (tempLeft < sizeof(temp))
             output.Append(temp, sizeof(temp) - tempLeft);
     }
     return NS_OK;
 }
 
-NS_COM PRBool
+PRBool
 NS_IsNativeUTF8()
 {
     return nsNativeCharsetConverter::IsNativeUTF8();
 }
 
 void
 NS_StartupNativeCharsetUtils()
 {
@@ -900,17 +900,17 @@ NS_ShutdownNativeCharsetUtils()
 // XP_WIN
 //-----------------------------------------------------------------------------
 #elif defined(XP_WIN)
 
 #include <windows.h>
 #include "nsAString.h"
 #include "nsReadableUtils.h"
 
-NS_COM nsresult
+nsresult
 NS_CopyNativeToUnicode(const nsACString &input, nsAString &output)
 {
     PRUint32 inputLen = input.Length();
 
     nsACString::const_iterator iter;
     input.BeginReading(iter);
 
     const char *buf = iter.get();
@@ -930,17 +930,17 @@ NS_CopyNativeToUnicode(const nsACString 
 
         PRUnichar *result = out_iter.get();
 
         ::MultiByteToWideChar(CP_ACP, 0, buf, inputLen, result, resultLen);
     }
     return NS_OK;
 }
 
-NS_COM nsresult
+nsresult
 NS_CopyUnicodeToNative(const nsAString  &input, nsACString &output)
 {
     PRUint32 inputLen = input.Length();
 
     nsAString::const_iterator iter;
     input.BeginReading(iter);
 
     const PRUnichar *buf = iter.get();
@@ -967,23 +967,23 @@ NS_CopyUnicodeToNative(const nsAString  
 
         ::WideCharToMultiByte(CP_ACP, 0, buf, inputLen, result, resultLen,
                               &defaultChar, NULL);
     }
     return NS_OK;
 }
 
 // moved from widget/src/windows/nsToolkit.cpp
-NS_COM PRInt32 
+PRInt32 
 NS_ConvertAtoW(const char *aStrInA, int aBufferSize, PRUnichar *aStrOutW)
 {
     return MultiByteToWideChar(CP_ACP, 0, aStrInA, -1, aStrOutW, aBufferSize);
 }
 
-NS_COM PRInt32 
+PRInt32 
 NS_ConvertWtoA(const PRUnichar *aStrInW, int aBufferSizeOut,
                char *aStrOutA, const char *aDefault)
 {
     if ((!aStrInW) || (!aStrOutA) || (aBufferSizeOut <= 0))
         return 0;
 
     int numCharsConverted = WideCharToMultiByte(CP_ACP, 0, aStrInW, -1, 
                                                 aStrOutA, aBufferSizeOut,
@@ -1017,17 +1017,17 @@ NS_ConvertWtoA(const PRUnichar *aStrInW,
 #include <uconv.h>
 #include "nsAString.h"
 #include "nsReadableUtils.h"
 #include <ulserrno.h>
 #include "nsNativeCharsetUtils.h"
 
 static UconvObject UnicodeConverter = NULL;
 
-NS_COM nsresult
+nsresult
 NS_CopyNativeToUnicode(const nsACString &input, nsAString  &output)
 {
     PRUint32 inputLen = input.Length();
 
     nsACString::const_iterator iter;
     input.BeginReading(iter);
     const char *inputStr = iter.get();
 
@@ -1057,17 +1057,17 @@ NS_CopyNativeToUnicode(const nsACString 
     }
 
     // Need to update string length to reflect how many bytes were actually
     // written.
     output.Truncate(resultLen - resultLeft);
     return NS_OK;
 }
 
-NS_COM nsresult
+nsresult
 NS_CopyUnicodeToNative(const nsAString &input, nsACString &output)
 {
     size_t inputLen = input.Length();
 
     nsAString::const_iterator iter;
     input.BeginReading(iter);
     UniChar* inputStr = (UniChar*) const_cast<PRUnichar*>(iter.get());
 
@@ -1131,24 +1131,24 @@ NS_ShutdownNativeCharsetUtils()
 {
     ::UniFreeUconvObject(UnicodeConverter);
 }
 
 #else
 
 #include "nsReadableUtils.h"
 
-NS_COM nsresult
+nsresult
 NS_CopyNativeToUnicode(const nsACString &input, nsAString  &output)
 {
     CopyASCIItoUTF16(input, output);
     return NS_OK;
 }
 
-NS_COM nsresult
+nsresult
 NS_CopyUnicodeToNative(const nsAString  &input, nsACString &output)
 {
     LossyCopyUTF16toASCII(input, output);
     return NS_OK;
 }
 
 void
 NS_StartupNativeCharsetUtils()
--- a/xpcom/io/nsNativeCharsetUtils.h
+++ b/xpcom/io/nsNativeCharsetUtils.h
@@ -49,34 +49,34 @@
  *    for converting *FILENAMES* between native and unicode. They are not    *
  *    designed or tested for general encoding converter use.                 *
  *                                                                           *
 \*****************************************************************************/
 
 /**
  * thread-safe conversion routines that do not depend on uconv libraries.
  */
-NS_COM nsresult NS_CopyNativeToUnicode(const nsACString &input, nsAString  &output);
-NS_COM nsresult NS_CopyUnicodeToNative(const nsAString  &input, nsACString &output);
+nsresult NS_CopyNativeToUnicode(const nsACString &input, nsAString  &output);
+nsresult NS_CopyUnicodeToNative(const nsAString  &input, nsACString &output);
 
 /* 
  * This function indicates whether the character encoding used in the file
  * system (more exactly what's used for |GetNativeFoo| and |SetNativeFoo|
  * of |nsILocalFile|) is UTF-8 or not. Knowing that helps us avoid an 
  * unncessary encoding conversion in some cases. For instance, to get the leaf
  * name in UTF-8 out of nsILocalFile, we can just use |GetNativeLeafName| rather
  * than using |GetLeafName| and converting the result to UTF-8 if the file 
  * system  encoding is UTF-8.
  * On Unix (but not on Mac OS X), it depends on the locale and is not known
  * in advance (at the compilation time) so that this function needs to be 
  * a real function. On Mac OS X it's always UTF-8 while on Windows 
  * and other platforms (e.g. OS2), it's never UTF-8.  
  */
 #if defined(XP_UNIX) && !defined(XP_MACOSX) && !defined(ANDROID)
-NS_COM PRBool NS_IsNativeUTF8();
+PRBool NS_IsNativeUTF8();
 #else
 inline PRBool NS_IsNativeUTF8()
 {
 #if defined(XP_MACOSX) || defined(ANDROID)
     return PR_TRUE;
 #else
     return PR_FALSE;
 #endif
--- a/xpcom/io/nsPipe3.cpp
+++ b/xpcom/io/nsPipe3.cpp
@@ -1253,17 +1253,17 @@ nsPipeOutputStream::AsyncWait(nsIOutputS
             mCallbackFlags = flags;
         }
     }
     return NS_OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-NS_COM nsresult
+nsresult
 NS_NewPipe(nsIInputStream **pipeIn,
            nsIOutputStream **pipeOut,
            PRUint32 segmentSize,
            PRUint32 maxSize,
            PRBool nonBlockingInput,
            PRBool nonBlockingOutput,
            nsIMemory *segmentAlloc)
 {
@@ -1283,17 +1283,17 @@ NS_NewPipe(nsIInputStream **pipeIn,
                               segmentSize, segmentCount, segmentAlloc);
     if (NS_FAILED(rv)) return rv;
 
     *pipeIn = in;
     *pipeOut = out;
     return NS_OK;
 }
 
-NS_COM nsresult
+nsresult
 NS_NewPipe2(nsIAsyncInputStream **pipeIn,
             nsIAsyncOutputStream **pipeOut,
             PRBool nonBlockingInput,
             PRBool nonBlockingOutput,
             PRUint32 segmentSize,
             PRUint32 segmentCount,
             nsIMemory *segmentAlloc)
 {
--- a/xpcom/io/nsSegmentedBuffer.cpp
+++ b/xpcom/io/nsSegmentedBuffer.cpp
@@ -163,17 +163,17 @@ nsSegmentedBuffer::Empty()
         nsMemory::Free(mSegmentArray);
         mSegmentArray = nsnull;
     }
     mSegmentArrayCount = NS_SEGMENTARRAY_INITIAL_COUNT;
     mFirstSegmentIndex = mLastSegmentIndex = 0;
 }
 
 #if 0
-NS_COM void
+void
 TestSegmentedBuffer()
 {
     nsSegmentedBuffer* buf = new nsSegmentedBuffer();
     NS_ASSERTION(buf, "out of memory");
     buf->Init(4, 16);
     char* seg;
     PRBool empty;
     seg = buf->AppendNewSegment();
--- a/xpcom/io/nsSegmentedBuffer.h
+++ b/xpcom/io/nsSegmentedBuffer.h
@@ -51,32 +51,32 @@ public:
           mFirstSegmentIndex(0), mLastSegmentIndex(0) {}
 
     ~nsSegmentedBuffer() {
         Empty();
         NS_IF_RELEASE(mSegAllocator);
     }
 
 
-    NS_COM nsresult Init(PRUint32 segmentSize, PRUint32 maxSize,
+    nsresult Init(PRUint32 segmentSize, PRUint32 maxSize,
                   nsIMemory* allocator = nsnull);
 
-    NS_COM char* AppendNewSegment();   // pushes at end
+    char* AppendNewSegment();   // pushes at end
 
     // returns true if no more segments remain:
     PRBool DeleteFirstSegment();  // pops from beginning
 
     // returns true if no more segments remain:
     PRBool DeleteLastSegment();  // pops from beginning
 
     // Call Realloc() on last segment.  This is used to reduce memory
     // consumption when data is not an exact multiple of segment size.
     PRBool ReallocLastSegment(size_t newSize);
 
-    NS_COM void Empty();               // frees all segments
+    void Empty();               // frees all segments
 
     inline PRUint32 GetSegmentCount() {
         if (mFirstSegmentIndex <= mLastSegmentIndex)
             return mLastSegmentIndex - mFirstSegmentIndex;
         else 
             return mSegmentArrayCount + mLastSegmentIndex - mFirstSegmentIndex;
     }
 
--- a/xpcom/io/nsStorageStream.cpp
+++ b/xpcom/io/nsStorageStream.cpp
@@ -538,17 +538,17 @@ nsStorageInputStream::Seek(PRUint32 aPos
     mReadCursor = mStorageStream->mSegmentedBuffer->GetSegment(mSegmentNum) +
         segmentOffset;
     PRUint32 available = length - aPosition;
     mSegmentEnd = mReadCursor + NS_MIN(mSegmentSize - segmentOffset, available);
     mLogicalCursor = aPosition;
     return NS_OK;
 }
 
-NS_COM nsresult
+nsresult
 NS_NewStorageStream(PRUint32 segmentSize, PRUint32 maxSize, nsIStorageStream **result)
 {
     NS_ENSURE_ARG(result);
 
     nsStorageStream* storageStream = new nsStorageStream();
     if (!storageStream) return NS_ERROR_OUT_OF_MEMORY;
     
     NS_ADDREF(storageStream);
--- a/xpcom/io/nsStreamUtils.cpp
+++ b/xpcom/io/nsStreamUtils.cpp
@@ -202,31 +202,31 @@ private:
     nsCOMPtr<nsIEventTarget>          mTarget;
 };
 
 NS_IMPL_THREADSAFE_ISUPPORTS2(nsOutputStreamReadyEvent, nsIRunnable,
                               nsIOutputStreamCallback)
 
 //-----------------------------------------------------------------------------
 
-NS_COM nsresult
+nsresult
 NS_NewInputStreamReadyEvent(nsIInputStreamCallback **event,
                             nsIInputStreamCallback *callback,
                             nsIEventTarget *target)
 {
     NS_ASSERTION(callback, "null callback");
     NS_ASSERTION(target, "null target");
     nsInputStreamReadyEvent *ev = new nsInputStreamReadyEvent(callback, target);
     if (!ev)
         return NS_ERROR_OUT_OF_MEMORY;
     NS_ADDREF(*event = ev);
     return NS_OK;
 }
 
-NS_COM nsresult
+nsresult
 NS_NewOutputStreamReadyEvent(nsIOutputStreamCallback **event,
                              nsIOutputStreamCallback *callback,
                              nsIEventTarget *target)
 {
     NS_ASSERTION(callback, "null callback");
     NS_ASSERTION(target, "null target");
     nsOutputStreamReadyEvent *ev = new nsOutputStreamReadyEvent(callback, target);
     if (!ev)
@@ -579,17 +579,17 @@ public:
             mSink->WriteSegments(FillOutputBuffer, &state, mChunkSize, &n);
         *sourceCondition = state.mSourceCondition;
         return n;
     }
 };
 
 //-----------------------------------------------------------------------------
 
-NS_COM nsresult
+nsresult
 NS_AsyncCopy(nsIInputStream         *source,
              nsIOutputStream        *sink,
              nsIEventTarget         *target,
              nsAsyncCopyMode         mode,
              PRUint32                chunkSize,
              nsAsyncCopyCallbackFun  callback,
              void                   *closure,
              PRBool                  closeSource,
@@ -621,27 +621,27 @@ NS_AsyncCopy(nsIInputStream         *sou
     }
     NS_RELEASE(copier);
 
     return rv;
 }
 
 //-----------------------------------------------------------------------------
 
-NS_COM nsresult
+nsresult
 NS_CancelAsyncCopy(nsISupports *aCopierCtx, nsresult aReason)
 {
   nsAStreamCopier *copier = static_cast<nsAStreamCopier *>(
                             static_cast<nsIRunnable *>(aCopierCtx));
   return copier->Cancel(aReason);
 }
 
 //-----------------------------------------------------------------------------
 
-NS_COM nsresult
+nsresult
 NS_ConsumeStream(nsIInputStream *stream, PRUint32 maxCount, nsACString &result)
 {
     nsresult rv = NS_OK;
     result.Truncate();
 
     while (maxCount) {
         PRUint32 avail;
         rv = stream->Available(&avail);
@@ -686,17 +686,17 @@ TestInputStream(nsIInputStream *inStr,
                 PRUint32 count,
                 PRUint32 *countWritten)
 {
     PRBool *result = static_cast<PRBool *>(closure);
     *result = PR_TRUE;
     return NS_ERROR_ABORT;  // don't call me anymore
 }
 
-NS_COM PRBool
+PRBool
 NS_InputStreamIsBuffered(nsIInputStream *stream)
 {
     PRBool result = PR_FALSE;
     PRUint32 n;
     nsresult rv = stream->ReadSegments(TestInputStream,
                                        &result, 1, &n);
     return result || NS_SUCCEEDED(rv);
 }
@@ -709,28 +709,28 @@ TestOutputStream(nsIOutputStream *outStr
                  PRUint32 count,
                  PRUint32 *countRead)
 {
     PRBool *result = static_cast<PRBool *>(closure);
     *result = PR_TRUE;
     return NS_ERROR_ABORT;  // don't call me anymore
 }
 
-NS_COM PRBool
+PRBool
 NS_OutputStreamIsBuffered(nsIOutputStream *stream)
 {
     PRBool result = PR_FALSE;
     PRUint32 n;
     stream->WriteSegments(TestOutputStream, &result, 1, &n);
     return result;
 }
 
 //-----------------------------------------------------------------------------
 
-NS_COM NS_METHOD
+NS_METHOD
 NS_CopySegmentToStream(nsIInputStream *inStr,
                        void *closure,
                        const char *buffer,
                        PRUint32 offset,
                        PRUint32 count,
                        PRUint32 *countWritten)
 {
     nsIOutputStream *outStr = static_cast<nsIOutputStream *>(closure);
@@ -742,45 +742,45 @@ NS_CopySegmentToStream(nsIInputStream *i
             return rv;
         buffer += n;
         count -= n;
         *countWritten += n;
     }
     return NS_OK;
 }
 
-NS_COM NS_METHOD
+NS_METHOD
 NS_CopySegmentToBuffer(nsIInputStream *inStr,
                        void *closure,
                        const char *buffer,
                        PRUint32 offset,
                        PRUint32 count,
                        PRUint32 *countWritten)
 {
     char *toBuf = static_cast<char *>(closure);
     memcpy(&toBuf[offset], buffer, count);
     *countWritten = count;
     return NS_OK;
 }
 
-NS_COM NS_METHOD
+NS_METHOD
 NS_DiscardSegment(nsIInputStream *inStr,
                   void *closure,
                   const char *buffer,
                   PRUint32 offset,
                   PRUint32 count,
                   PRUint32 *countWritten)
 {
     *countWritten = count;
     return NS_OK;
 }
 
 //-----------------------------------------------------------------------------
 
-NS_COM NS_METHOD
+NS_METHOD
 NS_WriteSegmentThunk(nsIInputStream *inStr,
                      void *closure,
                      const char *buffer,
                      PRUint32 offset,
                      PRUint32 count,
                      PRUint32 *countWritten)
 {
     nsWriteSegmentThunk *thunk = static_cast<nsWriteSegmentThunk *>(closure);
--- a/xpcom/io/nsStreamUtils.h
+++ b/xpcom/io/nsStreamUtils.h
@@ -51,32 +51,32 @@ class nsIEventTarget;
  * proxy object's OnInputStreamReady function may only be called once!  The
  * proxy object ensures that the real notify object will be free'd on the
  * thread corresponding to the given event target regardless of what thread
  * the proxy object is destroyed on.
  *
  * This function is designed to be used to implement AsyncWait when the
  * aTarget parameter is non-null.
  */
-extern NS_COM nsresult
+extern nsresult
 NS_NewInputStreamReadyEvent(nsIInputStreamCallback **aEvent,
                             nsIInputStreamCallback  *aNotify,
                             nsIEventTarget          *aTarget);
 
 /**
  * A "one-shot" proxy of the OnOutputStreamReady callback.  The resulting
  * proxy object's OnOutputStreamReady function may only be called once!  The
  * proxy object ensures that the real notify object will be free'd on the
  * thread corresponding to the given event target regardless of what thread 
  * the proxy object is destroyed on.
  *
  * This function is designed to be used to implement AsyncWait when the
  * aTarget parameter is non-null.
  */
-extern NS_COM nsresult
+extern nsresult
 NS_NewOutputStreamReadyEvent(nsIOutputStreamCallback **aEvent,
                              nsIOutputStreamCallback  *aNotify,
                              nsIEventTarget           *aTarget);
 
 /* ------------------------------------------------------------------------- */
 
 enum nsAsyncCopyMode {
     NS_ASYNCCOPY_VIA_READSEGMENTS,
@@ -100,17 +100,17 @@ typedef void (* nsAsyncCopyCallbackFun)(
  * to determine when to resume copying.
  *
  * Source and sink are closed by default when copying finishes or when error
  * occurs. Caller can prevent closing source or sink by setting aCloseSource
  * or aCloseSink to PR_FALSE.
  *
  * Caller can obtain aCopierCtx to be able to cancel copying.
  */
-extern NS_COM nsresult
+extern nsresult
 NS_AsyncCopy(nsIInputStream         *aSource,
              nsIOutputStream        *aSink,
              nsIEventTarget         *aTarget,
              nsAsyncCopyMode         aMode = NS_ASYNCCOPY_VIA_READSEGMENTS,
              PRUint32                aChunkSize = 4096,
              nsAsyncCopyCallbackFun  aCallbackFun = nsnull,
              void                   *aCallbackClosure = nsnull,
              PRBool                  aCloseSource = PR_TRUE,
@@ -121,17 +121,17 @@ NS_AsyncCopy(nsIInputStream         *aSo
  * This function cancels copying started by function NS_AsyncCopy.
  *
  * @param aCopierCtx
  *        Copier context returned by NS_AsyncCopy.
  * @param aReason
  *        A failure code indicating why the operation is being canceled.
  *        It is an error to pass a success code.
  */
-extern NS_COM nsresult
+extern nsresult
 NS_CancelAsyncCopy(nsISupports *aCopierCtx, nsresult aReason);
 
 /**
  * This function copies all of the available data from the stream (up to at
  * most aMaxCount bytes) into the given buffer.  The buffer is truncated at
  * the start of the function.
  *
  * If an error occurs while reading from the stream or while attempting to
@@ -147,101 +147,101 @@ NS_CancelAsyncCopy(nsISupports *aCopierC
  *        The maximum number of bytes to consume from the stream.  Pass the
  *        value PR_UINT32_MAX to consume the entire stream.  The number of
  *        bytes actually read is given by the length of aBuffer upon return.
  * @param aBuffer
  *        The string object that will contain the stream data upon return.
  *        Note: The data copied to the string may contain null bytes and may
  *        contain non-ASCII values.
  */
-extern NS_COM nsresult
+extern nsresult
 NS_ConsumeStream(nsIInputStream *aSource, PRUint32 aMaxCount,
                  nsACString &aBuffer);
 
 /**
  * This function tests whether or not the input stream is buffered.  A buffered
  * input stream is one that implements readSegments.  The test for this is to
  * simply call readSegments, without actually consuming any data from the
  * stream, to verify that it functions.
  *
  * NOTE: If the stream is non-blocking and has no data available yet, then this
  * test will fail.  In that case, we return false even though the test is not 
  * really conclusive.
  *
  * @param aInputStream
  *        The input stream to test.
  */
-extern NS_COM PRBool
+extern PRBool
 NS_InputStreamIsBuffered(nsIInputStream *aInputStream);
 
 /**
  * This function tests whether or not the output stream is buffered.  A
  * buffered output stream is one that implements writeSegments.  The test for
  * this is to simply call writeSegments, without actually writing any data into
  * the stream, to verify that it functions.
  *
  * NOTE: If the stream is non-blocking and has no available space yet, then
  * this test will fail.  In that case, we return false even though the test is
  * not really conclusive.
  *
  * @param aOutputStream
  *        The output stream to test.
  */
-extern NS_COM PRBool
+extern PRBool
 NS_OutputStreamIsBuffered(nsIOutputStream *aOutputStream);
 
 /**
  * This function is intended to be passed to nsIInputStream::ReadSegments to
  * copy data from the nsIInputStream into a nsIOutputStream passed as the
  * aClosure parameter to the ReadSegments function.
  *
  * @see nsIInputStream.idl for a description of this function's parameters.
  */
-extern NS_COM NS_METHOD
+extern NS_METHOD
 NS_CopySegmentToStream(nsIInputStream *aInputStream, void *aClosure,
                        const char *aFromSegment, PRUint32 aToOffset,
                        PRUint32 aCount, PRUint32 *aWriteCount);
 
 /**
  * This function is intended to be passed to nsIInputStream::ReadSegments to
  * copy data from the nsIInputStream into a character buffer passed as the
  * aClosure parameter to the ReadSegments function.  The character buffer
  * must be at least as large as the aCount parameter passed to ReadSegments.
  *
  * @see nsIInputStream.idl for a description of this function's parameters.
  */
-extern NS_COM NS_METHOD
+extern NS_METHOD
 NS_CopySegmentToBuffer(nsIInputStream *aInputStream, void *aClosure,
                        const char *aFromSegment, PRUint32 aToOffset,
                        PRUint32 aCount, PRUint32 *aWriteCount);
 
 /**
  * This function is intended to be passed to nsIInputStream::ReadSegments to
  * discard data from the nsIInputStream.  This can be used to efficiently read
  * data from the stream without actually copying any bytes.
  *
  * @see nsIInputStream.idl for a description of this function's parameters.
  */
-extern NS_COM NS_METHOD
+extern NS_METHOD
 NS_DiscardSegment(nsIInputStream *aInputStream, void *aClosure,
                   const char *aFromSegment, PRUint32 aToOffset,
                   PRUint32 aCount, PRUint32 *aWriteCount);
 
 /**
  * This function is intended to be passed to nsIInputStream::ReadSegments to
  * adjust the aInputStream parameter passed to a consumer's WriteSegmentFun.
  * The aClosure parameter must be a pointer to a nsWriteSegmentThunk object.
  * The mStream and mClosure members of that object will be passed to the mFun
  * function, with the remainder of the parameters being what are passed to
  * NS_WriteSegmentThunk.
  *
  * This function comes in handy when implementing ReadSegments in terms of an
  * inner stream's ReadSegments.
  */
-extern NS_COM NS_METHOD
+extern NS_METHOD
 NS_WriteSegmentThunk(nsIInputStream *aInputStream, void *aClosure,
                      const char *aFromSegment, PRUint32 aToOffset,
                      PRUint32 aCount, PRUint32 *aWriteCount);
 
 struct nsWriteSegmentThunk {
   nsIInputStream    *mStream;
   nsWriteSegmentFun  mFun;
   void              *mClosure;
--- a/xpcom/io/nsStringStream.cpp
+++ b/xpcom/io/nsStringStream.cpp
@@ -382,17 +382,17 @@ nsStringInputStream::Write(IPC::Message 
     using IPC::WriteParam;
 
     nsCAutoString value;
     GetData(value);
 
     WriteParam(aMsg, value);
 }
 
-NS_COM nsresult
+nsresult
 NS_NewByteInputStream(nsIInputStream** aStreamResult,
                       const char* aStringToRead, PRInt32 aLength,
                       nsAssignmentType aAssignment)
 {
     NS_PRECONDITION(aStreamResult, "null out ptr");
 
     nsStringInputStream* stream = new nsStringInputStream();
     if (! stream)
@@ -420,33 +420,33 @@ NS_NewByteInputStream(nsIInputStream** a
         NS_RELEASE(stream);
         return rv;
     }
     
     *aStreamResult = stream;
     return NS_OK;
 }
 
-NS_COM nsresult
+nsresult
 NS_NewStringInputStream(nsIInputStream** aStreamResult,
                         const nsAString& aStringToRead)
 {
     char* data = ToNewCString(aStringToRead);  // truncates high-order bytes
     if (!data)
         return NS_ERROR_OUT_OF_MEMORY;
 
     nsresult rv = NS_NewByteInputStream(aStreamResult, data,
                                         aStringToRead.Length(),
                                         NS_ASSIGNMENT_ADOPT);
     if (NS_FAILED(rv))
         NS_Free(data);
     return rv;
 }
 
-NS_COM nsresult
+nsresult
 NS_NewCStringInputStream(nsIInputStream** aStreamResult,
                          const nsACString& aStringToRead)
 {
     nsACString::const_iterator data;
     aStringToRead.BeginReading(data);
 
     return NS_NewByteInputStream(aStreamResult, data.get(), data.size_forward(),
                                  NS_ASSIGNMENT_COPY);
--- a/xpcom/io/nsStringStream.h
+++ b/xpcom/io/nsStringStream.h
@@ -75,34 +75,34 @@
  *
  * If aAssignment is NS_ASSIGNMENT_ADOPT, then the resulting stream refers
  * directly to the given buffer (aStringToRead) and will free aStringToRead
  * once the stream is closed.
  *
  * If aLength is less than zero, then the length of aStringToRead will be
  * determined by scanning the buffer for the first null byte.
  */
-extern NS_COM nsresult
+extern nsresult
 NS_NewByteInputStream(nsIInputStream** aStreamResult,
                       const char* aStringToRead, PRInt32 aLength = -1,
                       nsAssignmentType aAssignment = NS_ASSIGNMENT_DEPEND);
 
 /**
  * Factory method to get an nsInputStream from an nsAString.  Result will
  * implement nsIStringInputStream and nsISeekableStream.
  *
  * The given string data will be converted to a single-byte data buffer via
  * truncation (i.e., the high-order byte of each character will be discarded).
  * This could result in data-loss, so be careful when using this function.
  */
-extern NS_COM nsresult
+extern nsresult
 NS_NewStringInputStream(nsIInputStream** aStreamResult,
                         const nsAString& aStringToRead);
 
 /**
  * Factory method to get an nsInputStream from an nsACString.  Result will
  * implement nsIStringInputStream and nsISeekableStream.
  */
-extern NS_COM nsresult
+extern nsresult
 NS_NewCStringInputStream(nsIInputStream** aStreamResult,
                          const nsACString& aStringToRead);
 
 #endif // nsStringStream_h__
--- a/xpcom/io/nsUnicharInputStream.h
+++ b/xpcom/io/nsUnicharInputStream.h
@@ -51,15 +51,15 @@ class nsSimpleUnicharStreamFactory :
   private nsISimpleUnicharStreamFactory
 {
 public:
   nsSimpleUnicharStreamFactory() {}
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_NSIFACTORY
   NS_DECL_NSISIMPLEUNICHARSTREAMFACTORY
 
-  static NS_COM nsSimpleUnicharStreamFactory* GetInstance();
+  static nsSimpleUnicharStreamFactory* GetInstance();
 
 private:
   static const nsSimpleUnicharStreamFactory kInstance;
 };
 
 #endif // nsUnicharInputStream_h__
--- a/xpcom/io/nsWildCard.cpp
+++ b/xpcom/io/nsWildCard.cpp
@@ -165,23 +165,23 @@ static int
 template<class T>
 int
 NS_WildCardValid_(const T *expr)
 {
     int x = ::_valid_subexp(expr, T('\0'), T('\0'));
     return (x < 0 ? x : VALID_SXP);
 }
 
-NS_COM int
+int
 NS_WildCardValid(const char *expr)
 {
     return NS_WildCardValid_(expr);
 }
 
-NS_COM int
+int
 NS_WildCardValid(const PRUnichar *expr)
 {
     return NS_WildCardValid_(expr);
 }
 
 /* ----------------------------- _shexp_match ----------------------------- */
 
 
@@ -439,33 +439,33 @@ ns_WildCardMatch(const T *str, const T *
     if (ret == MATCH)
         ret = ::_shexp_match(str, expr, case_insensitive, 0);
 
     NS_Free(expr);
     return ret;
 }
 
 template<class T>
-NS_COM int
+int
 NS_WildCardMatch_(const T *str, const T *expr, PRBool case_insensitive)
 {
     int is_valid = NS_WildCardValid(expr);
     switch(is_valid) {
         case INVALID_SXP:
             return -1;
         default:
             return ::ns_WildCardMatch(str, expr, case_insensitive);
     }
 }
 
-NS_COM int
+int
 NS_WildCardMatch(const char *str, const char *xp,
                  PRBool case_insensitive)
 {
     return NS_WildCardMatch_(str, xp, case_insensitive);
 }
 
-NS_COM int
+int
 NS_WildCardMatch(const PRUnichar *str, const PRUnichar *xp,
                  PRBool case_insensitive)
 {
     return NS_WildCardMatch_(str, xp, case_insensitive);
 }
--- a/xpcom/io/nsWildCard.h
+++ b/xpcom/io/nsWildCard.h
@@ -65,32 +65,32 @@
  *  INVALID_SXP  if exp is a shell expression, but invalid
  *  VALID_SXP    if exp is a valid shell expression
  */
 
 #define NON_SXP -1
 #define INVALID_SXP -2
 #define VALID_SXP 1
 
-NS_COM int NS_WildCardValid(const char *expr);
+int NS_WildCardValid(const char *expr);
 
-NS_COM int NS_WildCardValid(const PRUnichar *expr);
+int NS_WildCardValid(const PRUnichar *expr);
 
 /* return values for the search routines */
 #define MATCH 0
 #define NOMATCH 1
 #define ABORTED -1
 
 /*
  * NS_WildCardMatch
  *
  * Takes a prevalidated shell expression exp, and a string str.
  *
  * Returns 0 on match and 1 on non-match.
  */
 
-NS_COM int NS_WildCardMatch(const char *str, const char *expr,
+int NS_WildCardMatch(const char *str, const char *expr,
                             PRBool case_insensitive);
 
-NS_COM int NS_WildCardMatch(const PRUnichar *str, const PRUnichar *expr,
+int NS_WildCardMatch(const PRUnichar *str, const PRUnichar *expr,
                             PRBool case_insensitive);
 
 #endif /* nsWildCard_h__ */
--- a/xpcom/proxy/public/nsIProxyObjectManager.idl
+++ b/xpcom/proxy/public/nsIProxyObjectManager.idl
@@ -132,13 +132,13 @@ interface nsIProxyObjectManager : nsISup
 #ifdef MOZILLA_INTERNAL_API
 /**
  * Helper function for code that already has a link-time dependency on the
  * internal API (MOZILLA_INTERNAL_API) and needs to get proxies in a bunch of
  * different places.  This way, the caller isn't forced to get the proxy object
  * manager themselves every single time, thus making the calling code more
  * readable.  The parameters are the same as for GetProxyForObject.
  */
-extern NS_COM nsresult
+extern nsresult
 NS_GetProxyForObject(nsIEventTarget *target, REFNSIID iid, nsISupports* object,
                      PRInt32 proxyType, void** result);
 #endif
 %}
--- a/xpcom/proxy/src/nsProxyObjectManager.cpp
+++ b/xpcom/proxy/src/nsProxyObjectManager.cpp
@@ -321,17 +321,17 @@ nsProxyObjectManager::GetClass(REFNSIID 
 
 /**
  * Helper function for code that already has a link-time dependency on
  * libxpcom and needs to get proxies in a bunch of different places.
  * This way, the caller isn't forced to get the proxy object manager
  * themselves every single time, thus making the calling code more
  * readable.
  */
-NS_COM nsresult
+nsresult
 NS_GetProxyForObject(nsIEventTarget *target, 
                      REFNSIID aIID, 
                      nsISupports* aObj, 
                      PRInt32 proxyType, 
                      void** aProxyObject) 
 {
     static NS_DEFINE_CID(proxyObjMgrCID, NS_PROXYEVENT_MANAGER_CID);
 
--- a/xpcom/string/public/nsAString.h
+++ b/xpcom/string/public/nsAString.h
@@ -69,17 +69,17 @@
 #include "nsTSubstring.h"
 #include "string-template-undef.h"
 
 
   /**
    * ASCII case-insensitive comparator.  (for Unicode case-insensitive
    * comparision, see nsUnicharUtils.h)
    */
-class NS_COM nsCaseInsensitiveCStringComparator
+class nsCaseInsensitiveCStringComparator
     : public nsCStringComparator
   {
     public:
       nsCaseInsensitiveCStringComparator() {}
       typedef char char_type;
 
       virtual int operator()( const char_type*, const char_type*, PRUint32, PRUint32 ) const;
   };
--- a/xpcom/string/public/nsCharTraits.h
+++ b/xpcom/string/public/nsCharTraits.h
@@ -146,17 +146,17 @@ template <class CharT> struct nsCharTrai
 
 NS_SPECIALIZE_TEMPLATE
 struct nsCharTraits<PRUnichar>
   {
     typedef PRUnichar char_type;
     typedef PRUint16  unsigned_char_type;
     typedef char      incompatible_char_type;
 
-    NS_COM static char_type *sEmptyBuffer;
+    static char_type *sEmptyBuffer;
 
     static
     void
     assign( char_type& lhs, char_type rhs )
       {
         lhs = rhs;
       }
 
@@ -436,17 +436,17 @@ struct nsCharTraits<PRUnichar>
 
 NS_SPECIALIZE_TEMPLATE
 struct nsCharTraits<char>
   {
     typedef char           char_type;
     typedef unsigned char  unsigned_char_type;
     typedef PRUnichar      incompatible_char_type;
 
-    NS_COM static char_type *sEmptyBuffer;
+    static char_type *sEmptyBuffer;
 
     static
     void
     assign( char_type& lhs, char_type rhs )
       {
         lhs = rhs;
       }
 
--- a/xpcom/string/public/nsPrintfCString.h
+++ b/xpcom/string/public/nsPrintfCString.h
@@ -62,17 +62,17 @@
    * to get a wide version of your formatted data, you must, e.g.,
    *
    *   CopyASCIItoUTF16(nsPrintfCString("%f", 13.917"), myStr);
    *
    * That's another good reason to avoid this class for anything but numbers ... as strings can be
    * much more efficiently handled with |NS_LITERAL_[C]STRING| and |nsLiteral[C]String|.
    */
 
-class NS_COM nsPrintfCString : public nsCString
+class nsPrintfCString : public nsCString
   {
     typedef nsCString string_type;
 
     enum { kLocalBufferSize=15 };
       // ought to be large enough for most things ... a |long long| needs at most 20 (so you'd better ask)
       //  pinkerton suggests 7.  We should measure and decide what's appropriate
 
     public:
--- a/xpcom/string/public/nsReadableUtils.h
+++ b/xpcom/string/public/nsReadableUtils.h
@@ -54,189 +54,188 @@ inline size_t Distance( const nsReadingI
   {
     return end.get() - start.get();
   }
 inline size_t Distance( const nsReadingIterator<char>& start, const nsReadingIterator<char>& end )
   {
     return end.get() - start.get();
   }
 
-NS_COM void LossyCopyUTF16toASCII( const nsAString& aSource, nsACString& aDest NS_OUTPARAM );
-NS_COM void CopyASCIItoUTF16( const nsACString& aSource, nsAString& aDest NS_OUTPARAM );
+void LossyCopyUTF16toASCII( const nsAString& aSource, nsACString& aDest NS_OUTPARAM );
+void CopyASCIItoUTF16( const nsACString& aSource, nsAString& aDest NS_OUTPARAM );
 
-NS_COM void LossyCopyUTF16toASCII( const PRUnichar* aSource, nsACString& aDest NS_OUTPARAM );
-NS_COM void CopyASCIItoUTF16( const char* aSource, nsAString& aDest NS_OUTPARAM );
+void LossyCopyUTF16toASCII( const PRUnichar* aSource, nsACString& aDest NS_OUTPARAM );
+void CopyASCIItoUTF16( const char* aSource, nsAString& aDest NS_OUTPARAM );
 
-NS_COM void CopyUTF16toUTF8( const nsAString& aSource, nsACString& aDest NS_OUTPARAM );
-NS_COM void CopyUTF8toUTF16( const nsACString& aSource, nsAString& aDest NS_OUTPARAM );
+void CopyUTF16toUTF8( const nsAString& aSource, nsACString& aDest NS_OUTPARAM );
+void CopyUTF8toUTF16( const nsACString& aSource, nsAString& aDest NS_OUTPARAM );
 
-NS_COM void CopyUTF16toUTF8( const PRUnichar* aSource, nsACString& aDest NS_OUTPARAM );
-NS_COM void CopyUTF8toUTF16( const char* aSource, nsAString& aDest NS_OUTPARAM );
+void CopyUTF16toUTF8( const PRUnichar* aSource, nsACString& aDest NS_OUTPARAM );
+void CopyUTF8toUTF16( const char* aSource, nsAString& aDest NS_OUTPARAM );
 
-NS_COM void LossyAppendUTF16toASCII( const nsAString& aSource, nsACString& aDest );
-NS_COM void AppendASCIItoUTF16( const nsACString& aSource, nsAString& aDest );
+void LossyAppendUTF16toASCII( const nsAString& aSource, nsACString& aDest );
+void AppendASCIItoUTF16( const nsACString& aSource, nsAString& aDest );
 
-NS_COM void LossyAppendUTF16toASCII( const PRUnichar* aSource, nsACString& aDest );
-NS_COM void AppendASCIItoUTF16( const char* aSource, nsAString& aDest );
+void LossyAppendUTF16toASCII( const PRUnichar* aSource, nsACString& aDest );
+void AppendASCIItoUTF16( const char* aSource, nsAString& aDest );
 
-NS_COM void AppendUTF16toUTF8( const nsAString& aSource, nsACString& aDest );
-NS_COM void AppendUTF8toUTF16( const nsACString& aSource, nsAString& aDest );
+void AppendUTF16toUTF8( const nsAString& aSource, nsACString& aDest );
+void AppendUTF8toUTF16( const nsACString& aSource, nsAString& aDest );
 
-NS_COM void AppendUTF16toUTF8( const PRUnichar* aSource, nsACString& aDest );
-NS_COM void AppendUTF8toUTF16( const char* aSource, nsAString& aDest );
+void AppendUTF16toUTF8( const PRUnichar* aSource, nsACString& aDest );
+void AppendUTF8toUTF16( const char* aSource, nsAString& aDest );
 
   /**
    * Returns a new |char| buffer containing a zero-terminated copy of |aSource|.
    *
    * Allocates and returns a new |char| buffer which you must free with |nsMemory::Free|.
    * Performs a lossy encoding conversion by chopping 16-bit wide characters down to 8-bits wide while copying |aSource| to your new buffer.
    * This conversion is not well defined; but it reproduces legacy string behavior.
    * The new buffer is zero-terminated, but that may not help you if |aSource| contains embedded nulls.
    *
    * @param aSource a 16-bit wide string
    * @return a new |char| buffer you must free with |nsMemory::Free|.
    */
-NS_COM char* ToNewCString( const nsAString& aSource );
+char* ToNewCString( const nsAString& aSource );
 
 
   /**
    * Returns a new |char| buffer containing a zero-terminated copy of |aSource|.
    *
    * Allocates and returns a new |char| buffer which you must free with |nsMemory::Free|.
    * The new buffer is zero-terminated, but that may not help you if |aSource| contains embedded nulls.
    *
    * @param aSource an 8-bit wide string
    * @return a new |char| buffer you must free with |nsMemory::Free|.
    */
-NS_COM char* ToNewCString( const nsACString& aSource );
+char* ToNewCString( const nsACString& aSource );
 
   /**
    * Returns a new |char| buffer containing a zero-terminated copy of |aSource|.
    *
    * Allocates and returns a new |char| buffer which you must free with 
    * |nsMemory::Free|.
    * Performs an encoding conversion from a UTF-16 string to a UTF-8 string
    * copying |aSource| to your new buffer.
    * The new buffer is zero-terminated, but that may not help you if |aSource| 
    * contains embedded nulls.
    *
    * @param aSource a UTF-16 string (made of PRUnichar's)
    * @param aUTF8Count the number of 8-bit units that was returned
    * @return a new |char| buffer you must free with |nsMemory::Free|.
    */
 
-NS_COM char* ToNewUTF8String( const nsAString& aSource, PRUint32 *aUTF8Count = nsnull );
+char* ToNewUTF8String( const nsAString& aSource, PRUint32 *aUTF8Count = nsnull );
 
 
   /**
    * Returns a new |PRUnichar| buffer containing a zero-terminated copy of 
    * |aSource|.
    *
    * Allocates and returns a new |PRUnichar| buffer which you must free with 
    * |nsMemory::Free|.
    * The new buffer is zero-terminated, but that may not help you if |aSource| 
    * contains embedded nulls.
    *
    * @param aSource a UTF-16 string
    * @return a new |PRUnichar| buffer you must free with |nsMemory::Free|.
    */
-NS_COM PRUnichar* ToNewUnicode( const nsAString& aSource );
+PRUnichar* ToNewUnicode( const nsAString& aSource );
 
 
   /**
    * Returns a new |PRUnichar| buffer containing a zero-terminated copy of |aSource|.
    *
    * Allocates and returns a new |PRUnichar| buffer which you must free with |nsMemory::Free|.
    * Performs an encoding conversion by 0-padding 8-bit wide characters up to 16-bits wide while copying |aSource| to your new buffer.
    * This conversion is not well defined; but it reproduces legacy string behavior.
    * The new buffer is zero-terminated, but that may not help you if |aSource| contains embedded nulls.
    *
    * @param aSource an 8-bit wide string (a C-string, NOT UTF-8)
    * @return a new |PRUnichar| buffer you must free with |nsMemory::Free|.
    */
-NS_COM PRUnichar* ToNewUnicode( const nsACString& aSource );
+PRUnichar* ToNewUnicode( const nsACString& aSource );
 
   /**
    * Returns a new |PRUnichar| buffer containing a zero-terminated copy
    * of |aSource|.
    *
    * Allocates and returns a new |char| buffer which you must free with
    * |nsMemory::Free|.  Performs an encoding conversion from UTF-8 to UTF-16 
    * while copying |aSource| to your new buffer.  This conversion is well defined
    * for a valid UTF-8 string.  The new buffer is zero-terminated, but that 
    * may not help you if |aSource| contains embedded nulls.
    *
    * @param aSource an 8-bit wide string, UTF-8 encoded
    * @param aUTF16Count the number of 16-bit units that was returned
    * @return a new |PRUnichar| buffer you must free with |nsMemory::Free|.
    *         (UTF-16 encoded)
    */
-NS_COM PRUnichar* UTF8ToNewUnicode( const nsACString& aSource, PRUint32 *aUTF16Count = nsnull );
+PRUnichar* UTF8ToNewUnicode( const nsACString& aSource, PRUint32 *aUTF16Count = nsnull );
 
   /**
    * Copies |aLength| 16-bit code units from the start of |aSource| to the
    * |PRUnichar| buffer |aDest|.
    *
    * After this operation |aDest| is not null terminated.
    *
    * @param aSource a UTF-16 string
    * @param aSrcOffset start offset in the source string
    * @param aDest a |PRUnichar| buffer
    * @param aLength the number of 16-bit code units to copy
    * @return pointer to destination buffer - identical to |aDest|
    */
-NS_COM PRUnichar* CopyUnicodeTo( const nsAString& aSource,
+PRUnichar* CopyUnicodeTo( const nsAString& aSource,
                                  PRUint32 aSrcOffset,
                                  PRUnichar* aDest,
                                  PRUint32 aLength );
 
 
   /**
    * Copies 16-bit characters between iterators |aSrcStart| and
    * |aSrcEnd| to the writable string |aDest|. Similar to the
    * |nsString::Mid| method.
    *
    * After this operation |aDest| is not null terminated.
    *
    * @param aSrcStart start source iterator
    * @param aSrcEnd end source iterator
    * @param aDest destination for the copy
    */
-NS_COM void CopyUnicodeTo( const nsAString::const_iterator& aSrcStart,
+void CopyUnicodeTo( const nsAString::const_iterator& aSrcStart,
                            const nsAString::const_iterator& aSrcEnd,
                            nsAString& aDest );
 
   /**
    * Appends 16-bit characters between iterators |aSrcStart| and
    * |aSrcEnd| to the writable string |aDest|. 
    *
    * After this operation |aDest| is not null terminated.
    *
    * @param aSrcStart start source iterator
    * @param aSrcEnd end source iterator
    * @param aDest destination for the copy
    */
-NS_COM void AppendUnicodeTo( const nsAString::const_iterator& aSrcStart,
+void AppendUnicodeTo( const nsAString::const_iterator& aSrcStart,
                              const nsAString::const_iterator& aSrcEnd,
                              nsAString& aDest );
 
   /**
    * Returns |PR_TRUE| if |aString| contains only ASCII characters, that is, characters in the range (0x00, 0x7F).
    *
    * @param aString a 16-bit wide string to scan
    */
-NS_COM PRBool IsASCII( const nsAString& aString );
+PRBool IsASCII( const nsAString& aString );
 
   /**
    * Returns |PR_TRUE| if |aString| contains only ASCII characters, that is, characters in the range (0x00, 0x7F).
    *
    * @param aString a 8-bit wide string to scan
    */
-NS_COM PRBool IsASCII( const nsACString& aString );
-
+PRBool IsASCII( const nsACString& aString );
 
   /**
    * Returns |PR_TRUE| if |aString| is a valid UTF-8 string.
    * XXX This is not bullet-proof and nor an all-purpose UTF-8 validator. 
    * It is mainly written to replace and roughly equivalent to
    *
    *    str.Equals(NS_ConvertUTF16toUTF8(NS_ConvertUTF8toUTF16(str)))
    *
@@ -246,51 +245,51 @@ NS_COM PRBool IsASCII( const nsACString&
    * of surrogate codepoints and non-characters ( 0xFFFE and 0xFFFF
    * in planes 0 through 16.) as well as overlong UTF-8 sequences. 
    * Also note that it regards UTF-8 sequences corresponding to 
    * codepoints above 0x10FFFF as invalid in accordance with 
    * http://www.ietf.org/internet-drafts/draft-yergeau-rfc2279bis-04.txt
    *
    * @param aString an 8-bit wide string to scan
    */
-NS_COM PRBool IsUTF8( const nsACString& aString );
+PRBool IsUTF8( const nsACString& aString );
 
-NS_COM PRBool ParseString(const nsACString& aAstring, char aDelimiter, 
+PRBool ParseString(const nsACString& aAstring, char aDelimiter, 
                           nsTArray<nsCString>& aArray);
 
   /**
    * Converts case in place in the argument string.
    */
-NS_COM void ToUpperCase( nsACString& );
+void ToUpperCase( nsACString& );
 
-NS_COM void ToLowerCase( nsACString& );
+void ToLowerCase( nsACString& );
 
-NS_COM void ToUpperCase( nsCSubstring& );
+void ToUpperCase( nsCSubstring& );
 
-NS_COM void ToLowerCase( nsCSubstring& );
+void ToLowerCase( nsCSubstring& );
 
   /**
    * Converts case from string aSource to aDest.
    */
-NS_COM void ToUpperCase( const nsACString& aSource, nsACString& aDest );
+void ToUpperCase( const nsACString& aSource, nsACString& aDest );
 
-NS_COM void ToLowerCase( const nsACString& aSource, nsACString& aDest );
+void ToLowerCase( const nsACString& aSource, nsACString& aDest );
 
   /**
    * Finds the leftmost occurrence of |aPattern|, if any in the range |aSearchStart|..|aSearchEnd|.
    *
    * Returns |PR_TRUE| if a match was found, and adjusts |aSearchStart| and |aSearchEnd| to
    * point to the match.  If no match was found, returns |PR_FALSE| and makes |aSearchStart == aSearchEnd|.
    *
    * Currently, this is equivalent to the O(m*n) implementation previously on |ns[C]String|.
    * If we need something faster, then we can implement that later.
    */
 
-NS_COM PRBool FindInReadable( const nsAString& aPattern, nsAString::const_iterator&, nsAString::const_iterator&, const nsStringComparator& = nsDefaultStringComparator() );
-NS_COM PRBool FindInReadable( const nsACString& aPattern, nsACString::const_iterator&, nsACString::const_iterator&, const nsCStringComparator& = nsDefaultCStringComparator() );
+PRBool FindInReadable( const nsAString& aPattern, nsAString::const_iterator&, nsAString::const_iterator&, const nsStringComparator& = nsDefaultStringComparator() );
+PRBool FindInReadable( const nsACString& aPattern, nsACString::const_iterator&, nsACString::const_iterator&, const nsCStringComparator& = nsDefaultCStringComparator() );
 
 /* sometimes we don't care about where the string was, just that we
  * found it or not */
 inline PRBool FindInReadable( const nsAString& aPattern, const nsAString& aSource, const nsStringComparator& compare = nsDefaultStringComparator() )
 {
   nsAString::const_iterator start, end;
   aSource.BeginReading(start);
   aSource.EndReading(end);
@@ -301,80 +300,79 @@ inline PRBool FindInReadable( const nsAC
 {
   nsACString::const_iterator start, end;
   aSource.BeginReading(start);
   aSource.EndReading(end);
   return FindInReadable(aPattern, start, end, compare);
 }
 
 
-NS_COM PRBool CaseInsensitiveFindInReadable( const nsACString& aPattern, nsACString::const_iterator&, nsACString::const_iterator& );
+PRBool CaseInsensitiveFindInReadable( const nsACString& aPattern, nsACString::const_iterator&, nsACString::const_iterator& );
 
   /**
    * Finds the rightmost occurrence of |aPattern| 
    * Returns |PR_TRUE| if a match was found, and adjusts |aSearchStart| and |aSearchEnd| to
    * point to the match.  If no match was found, returns |PR_FALSE| and makes |aSearchStart == aSearchEnd|.
    *
    */
-NS_COM PRBool RFindInReadable( const nsAString& aPattern, nsAString::const_iterator&, nsAString::const_iterator&, const nsStringComparator& = nsDefaultStringComparator() );
-NS_COM PRBool RFindInReadable( const nsACString& aPattern, nsACString::const_iterator&, nsACString::const_iterator&, const nsCStringComparator& = nsDefaultCStringComparator() );
+PRBool RFindInReadable( const nsAString& aPattern, nsAString::const_iterator&, nsAString::const_iterator&, const nsStringComparator& = nsDefaultStringComparator() );
+PRBool RFindInReadable( const nsACString& aPattern, nsACString::const_iterator&, nsACString::const_iterator&, const nsCStringComparator& = nsDefaultCStringComparator() );
 
    /**
    * Finds the leftmost occurrence of |aChar|, if any in the range 
    * |aSearchStart|..|aSearchEnd|.
    *
    * Returns |PR_TRUE| if a match was found, and adjusts |aSearchStart| to
    * point to the match.  If no match was found, returns |PR_FALSE| and 
    * makes |aSearchStart == aSearchEnd|.
    */
-NS_COM PRBool FindCharInReadable( PRUnichar aChar, nsAString::const_iterator& aSearchStart, const nsAString::const_iterator& aSearchEnd );
-NS_COM PRBool FindCharInReadable( char aChar, nsACString::const_iterator& aSearchStart, const nsACString::const_iterator& aSearchEnd );
+PRBool FindCharInReadable( PRUnichar aChar, nsAString::const_iterator& aSearchStart, const nsAString::const_iterator& aSearchEnd );
+PRBool FindCharInReadable( char aChar, nsACString::const_iterator& aSearchStart, const nsACString::const_iterator& aSearchEnd );
 
     /**
     * Finds the number of occurences of |aChar| in the string |aStr|
     */
-NS_COM PRUint32 CountCharInReadable( const nsAString& aStr,
+PRUint32 CountCharInReadable( const nsAString& aStr,
                                      PRUnichar aChar );
-NS_COM PRUint32 CountCharInReadable( const nsACString& aStr,
+PRUint32 CountCharInReadable( const nsACString& aStr,
                                      char aChar );
 
-NS_COM PRBool
+PRBool
 StringBeginsWith( const nsAString& aSource, const nsAString& aSubstring,
                   const nsStringComparator& aComparator =
                                               nsDefaultStringComparator() );
-NS_COM PRBool
+PRBool
 StringBeginsWith( const nsACString& aSource, const nsACString& aSubstring,
                   const nsCStringComparator& aComparator =
                                                nsDefaultCStringComparator() );
-NS_COM PRBool
+PRBool
 StringEndsWith( const nsAString& aSource, const nsAString& aSubstring,
                 const nsStringComparator& aComparator =
                                             nsDefaultStringComparator() );
-NS_COM PRBool
+PRBool
 StringEndsWith( const nsACString& aSource, const nsACString& aSubstring,
                 const nsCStringComparator& aComparator =
                                              nsDefaultCStringComparator() );
 
-NS_COM const nsAFlatString& EmptyString();
-NS_COM const nsAFlatCString& EmptyCString();
-
+const nsAFlatString& EmptyString();
+const nsAFlatCString& EmptyCString();
 
    /**
    * Compare a UTF-8 string to an UTF-16 string.
    *
    * Returns 0 if the strings are equal, -1 if aUTF8String is less
    * than aUTF16Count, and 1 in the reverse case.  In case of fatal
    * error (eg the strings are not valid UTF8 and UTF16 respectively),
    * this method will return PR_INT32_MIN.
    */
-NS_COM PRInt32
+PRInt32
 CompareUTF8toUTF16(const nsASingleFragmentCString& aUTF8String,
                    const nsASingleFragmentString& aUTF16String);
 
-NS_COM void
+void
 AppendUCS4ToUTF16(const PRUint32 aSource, nsAString& aDest);
 
 template<class T>
 inline PRBool EnsureStringLength(T& aStr, PRUint32 aLen)
 {
     aStr.SetLength(aLen);
     return (aStr.Length() == aLen);
 }
--- a/xpcom/string/public/nsStringBuffer.h
+++ b/xpcom/string/public/nsStringBuffer.h
@@ -68,41 +68,41 @@ class nsStringBuffer
        * buffer by calling the Data method to fetch the raw data pointer.  Care
        * must be taken to properly null terminate the character array.  The
        * storage size can be greater than the length of the actual string
        * (i.e., it is not required that the null terminator appear in the last
        * storage unit of the string buffer's data).
        *
        * @return new string buffer or null if out of memory.
        */
-      NS_COM static nsStringBuffer* Alloc(size_t storageSize);
+      static nsStringBuffer* Alloc(size_t storageSize);
 
       /**
        * Resizes the given string buffer to the specified storage size.  This
        * method must not be called on a readonly string buffer.  Use this API
        * carefully!!
        *
        * This method behaves like the ANSI-C realloc function.  (i.e., If the
        * allocation fails, null will be returned and the given string buffer
        * will remain unmodified.)
        *
        * @see IsReadonly
        */
-      NS_COM static nsStringBuffer* Realloc(nsStringBuffer* buf, size_t storageSize);
+      static nsStringBuffer* Realloc(nsStringBuffer* buf, size_t storageSize);
 
       /**
        * Increment the reference count on this string buffer.
        */
-      NS_COM void NS_FASTCALL AddRef();
+      void NS_FASTCALL AddRef();
 
       /**
        * Decrement the reference count on this string buffer.  The string
        * buffer will be destroyed when its reference count reaches zero.
        */
-      NS_COM void NS_FASTCALL Release();
+      void NS_FASTCALL Release();
 
       /**
        * This method returns the string buffer corresponding to the given data
        * pointer.  The data pointer must have been returned previously by a
        * call to the nsStringBuffer::Data method.
        */
       static nsStringBuffer* FromData(void* data)
         {
@@ -143,32 +143,32 @@ class nsStringBuffer
       /**
        * The FromString methods return a string buffer for the given string 
        * object or null if the string object does not have a string buffer.
        * The reference count of the string buffer is NOT incremented by these
        * methods.  If the caller wishes to hold onto the returned value, then
        * the returned string buffer must have its reference count incremented
        * via a call to the AddRef method.
        */
-      NS_COM static nsStringBuffer* FromString(const nsAString &str);
-      NS_COM static nsStringBuffer* FromString(const nsACString &str);
+      static nsStringBuffer* FromString(const nsAString &str);
+      static nsStringBuffer* FromString(const nsACString &str);
 
       /**
        * The ToString methods assign this string buffer to a given string
        * object.  If the string object does not support sharable string
        * buffers, then its value will be set to a copy of the given string
        * buffer.  Otherwise, these methods increment the reference count of the
        * given string buffer.  It is important to specify the length (in
        * storage units) of the string contained in the string buffer since the
        * length of the string may be less than its storage size.  The string
        * must have a null terminator at the offset specified by |len|.
        *
        * NOTE: storage size is measured in bytes even for wide strings;
        *       however, string length is always measured in storage units
        *       (2-byte units for wide strings).
        */
-      NS_COM void ToString(PRUint32 len, nsAString &str,
+      void ToString(PRUint32 len, nsAString &str,
                            PRBool aMoveOwnership = PR_FALSE);
-      NS_COM void ToString(PRUint32 len, nsACString &str,
+      void ToString(PRUint32 len, nsACString &str,
                            PRBool aMoveOwnership = PR_FALSE);
   };
 
 #endif /* !defined(nsStringBuffer_h__ */
--- a/xpcom/string/public/nsTDependentString.h
+++ b/xpcom/string/public/nsTDependentString.h
@@ -112,17 +112,17 @@ class nsTDependentString_CharT : public 
          * allow this class to be bound to a different string...
          */
 
       void Rebind( const char_type* data )
         {
           Rebind(data, PRUint32(char_traits::length(data)));
         }
 
-      NS_COM void Rebind( const char_type* data, size_type length );
+      void Rebind( const char_type* data, size_type length );
 
       void Rebind( const char_type* start, const char_type* end )
         {
           Rebind(start, PRUint32(end - start));
         }
 
     private:
       
--- a/xpcom/string/public/nsTDependentSubstring.h
+++ b/xpcom/string/public/nsTDependentSubstring.h
@@ -52,19 +52,19 @@
 class nsTDependentSubstring_CharT : public nsTSubstring_CharT
   {
     public:
 
       typedef nsTDependentSubstring_CharT    self_type;
 
     public:
 
-      NS_COM void Rebind( const substring_type&, PRUint32 startPos, PRUint32 length = size_type(-1) );
+      void Rebind( const substring_type&, PRUint32 startPos, PRUint32 length = size_type(-1) );
 
-      NS_COM void Rebind( const char_type* start, const char_type* end );
+      void Rebind( const char_type* start, const char_type* end );
 
       nsTDependentSubstring_CharT( const substring_type& str, PRUint32 startPos, PRUint32 length = size_type(-1) )
         : substring_type()
         {
           Rebind(str, startPos, length);
         }
 
       nsTDependentSubstring_CharT( const char_type* start, const char_type* end )
--- a/xpcom/string/public/nsTPromiseFlatString.h
+++ b/xpcom/string/public/nsTPromiseFlatString.h
@@ -94,17 +94,17 @@
 class nsTPromiseFlatString_CharT : public nsTString_CharT
   {
     public:
 
       typedef nsTPromiseFlatString_CharT    self_type;
 
     private:
 
-      NS_COM void Init( const substring_type& );
+      void Init( const substring_type& );
 
         // NOT TO BE IMPLEMENTED
       void operator=( const self_type& );
 
         // NOT TO BE IMPLEMENTED
       nsTPromiseFlatString_CharT();
 
     public:
--- a/xpcom/string/public/nsTString.h
+++ b/xpcom/string/public/nsTString.h
@@ -145,137 +145,137 @@ class nsTString_CharT : public nsTSubstr
          *  @param   aString is substring to be sought in this
          *  @param   aIgnoreCase selects case sensitivity
          *  @param   aOffset tells us where in this string to start searching
          *  @param   aCount tells us how far from the offset we are to search. Use
          *           -1 to search the whole string.
          *  @return  offset in string, or kNotFound
          */
 
-      NS_COM PRInt32 Find( const nsCString& aString, PRBool aIgnoreCase=PR_FALSE, PRInt32 aOffset=0, PRInt32 aCount=-1 ) const;
-      NS_COM PRInt32 Find( const char* aString, PRBool aIgnoreCase=PR_FALSE, PRInt32 aOffset=0, PRInt32 aCount=-1 ) const;
+      PRInt32 Find( const nsCString& aString, PRBool aIgnoreCase=PR_FALSE, PRInt32 aOffset=0, PRInt32 aCount=-1 ) const;
+      PRInt32 Find( const char* aString, PRBool aIgnoreCase=PR_FALSE, PRInt32 aOffset=0, PRInt32 aCount=-1 ) const;
 
 #ifdef CharT_is_PRUnichar
-      NS_COM PRInt32 Find( const nsAFlatString& aString, PRInt32 aOffset=0, PRInt32 aCount=-1 ) const;
-      NS_COM PRInt32 Find( const PRUnichar* aString, PRInt32 aOffset=0, PRInt32 aCount=-1 ) const;
+      PRInt32 Find( const nsAFlatString& aString, PRInt32 aOffset=0, PRInt32 aCount=-1 ) const;
+      PRInt32 Find( const PRUnichar* aString, PRInt32 aOffset=0, PRInt32 aCount=-1 ) const;
 #endif
 
         
         /**
          * This methods scans the string backwards, looking for the given string
          *
          * @param   aString is substring to be sought in this
          * @param   aIgnoreCase tells us whether or not to do caseless compare
          * @param   aOffset tells us where in this string to start searching.
          *          Use -1 to search from the end of the string.
          * @param   aCount tells us how many iterations to make starting at the
          *          given offset.
          * @return  offset in string, or kNotFound
          */
 
-      NS_COM PRInt32 RFind( const nsCString& aString, PRBool aIgnoreCase=PR_FALSE, PRInt32 aOffset=-1, PRInt32 aCount=-1 ) const;
-      NS_COM PRInt32 RFind( const char* aCString, PRBool aIgnoreCase=PR_FALSE, PRInt32 aOffset=-1, PRInt32 aCount=-1 ) const;
+      PRInt32 RFind( const nsCString& aString, PRBool aIgnoreCase=PR_FALSE, PRInt32 aOffset=-1, PRInt32 aCount=-1 ) const;
+      PRInt32 RFind( const char* aCString, PRBool aIgnoreCase=PR_FALSE, PRInt32 aOffset=-1, PRInt32 aCount=-1 ) const;
 
 #ifdef CharT_is_PRUnichar
-      NS_COM PRInt32 RFind( const nsAFlatString& aString, PRInt32 aOffset=-1, PRInt32 aCount=-1 ) const;
-      NS_COM PRInt32 RFind( const PRUnichar* aString, PRInt32 aOffset=-1, PRInt32 aCount=-1 ) const;
+      PRInt32 RFind( const nsAFlatString& aString, PRInt32 aOffset=-1, PRInt32 aCount=-1 ) const;
+      PRInt32 RFind( const PRUnichar* aString, PRInt32 aOffset=-1, PRInt32 aCount=-1 ) const;
 #endif
 
 
         /**
          *  Search for given char within this string
          *  
          *  @param   aChar is the character to search for
          *  @param   aOffset tells us where in this string to start searching
          *  @param   aCount tells us how far from the offset we are to search.
          *           Use -1 to search the whole string.
          *  @return  offset in string, or kNotFound
          */
 
       // PRInt32 FindChar( PRUnichar aChar, PRInt32 aOffset=0, PRInt32 aCount=-1 ) const;
-      NS_COM PRInt32 RFindChar( PRUnichar aChar, PRInt32 aOffset=-1, PRInt32 aCount=-1 ) const;
+      PRInt32 RFindChar( PRUnichar aChar, PRInt32 aOffset=-1, PRInt32 aCount=-1 ) const;
 
 
         /**
          * This method searches this string for the first character found in
          * the given string.
          *
          * @param aString contains set of chars to be found
          * @param aOffset tells us where in this string to start searching
          *        (counting from left)
          * @return offset in string, or kNotFound
          */
 
-      NS_COM PRInt32 FindCharInSet( const char* aString, PRInt32 aOffset=0 ) const;
+      PRInt32 FindCharInSet( const char* aString, PRInt32 aOffset=0 ) const;
       PRInt32 FindCharInSet( const self_type& aString, PRInt32 aOffset=0 ) const
         {
           return FindCharInSet(aString.get(), aOffset);
         }
 
 #ifdef CharT_is_PRUnichar
-      NS_COM PRInt32 FindCharInSet( const PRUnichar* aString, PRInt32 aOffset=0 ) const;
+      PRInt32 FindCharInSet( const PRUnichar* aString, PRInt32 aOffset=0 ) const;
 #endif
 
 
         /**
          * This method searches this string for the last character found in
          * the given string.
          *
          * @param aString contains set of chars to be found
          * @param aOffset tells us where in this string to start searching
          *        (counting from left)
          * @return offset in string, or kNotFound
          */
 
-      NS_COM PRInt32 RFindCharInSet( const char_type* aString, PRInt32 aOffset=-1 ) const;
+      PRInt32 RFindCharInSet( const char_type* aString, PRInt32 aOffset=-1 ) const;
       PRInt32 RFindCharInSet( const self_type& aString, PRInt32 aOffset=-1 ) const
         {
           return RFindCharInSet(aString.get(), aOffset);
         }
 
 
         /**
          * Compares a given string to this string. 
          *
          * @param   aString is the string to be compared
          * @param   aIgnoreCase tells us how to treat case
          * @param   aCount tells us how many chars to compare
          * @return  -1,0,1
          */
 
 #ifdef CharT_is_char
-      NS_COM PRInt32 Compare( const char* aString, PRBool aIgnoreCase=PR_FALSE, PRInt32 aCount=-1 ) const;
+      PRInt32 Compare( const char* aString, PRBool aIgnoreCase=PR_FALSE, PRInt32 aCount=-1 ) const;
 #endif
 
 
         /**
          * Equality check between given string and this string.
          *
          * @param   aString is the string to check
          * @param   aIgnoreCase tells us how to treat case
          * @param   aCount tells us how many chars to compare
          * @return  boolean
          */
 #ifdef CharT_is_char
       PRBool EqualsIgnoreCase( const char* aString, PRInt32 aCount=-1 ) const {
         return Compare(aString, PR_TRUE, aCount) == 0;
       }
 #else
-      NS_COM PRBool EqualsIgnoreCase( const char* aString, PRInt32 aCount=-1 ) const;
+      PRBool EqualsIgnoreCase( const char* aString, PRInt32 aCount=-1 ) const;
 
 
 #endif // !CharT_is_PRUnichar
 
         /**
          * Perform string to double-precision float conversion.
          *
          * @param   aErrorCode will contain error if one occurs
          * @return  double-precision float rep of string value
          */
-      NS_COM double ToDouble( PRInt32* aErrorCode ) const;
+      double ToDouble( PRInt32* aErrorCode ) const;
 
         /**
          * Perform string to single-precision float conversion.
          *
          * @param   aErrorCode will contain error if one occurs
          * @return  single-precision float rep of string value
          */
       float ToFloat( PRInt32* aErrorCode ) const {
@@ -284,17 +284,17 @@ class nsTString_CharT : public nsTSubstr
 
 
         /**
          * Perform string to int conversion.
          * @param   aErrorCode will contain error if one occurs
          * @param   aRadix tells us which radix to assume; kAutoDetect tells us to determine the radix for you.
          * @return  int rep of string value, and possible (out) error code
          */
-      NS_COM PRInt32 ToInteger( PRInt32* aErrorCode, PRUint32 aRadix=kRadix10 ) const;
+      PRInt32 ToInteger( PRInt32* aErrorCode, PRUint32 aRadix=kRadix10 ) const;
       PRInt32 ToInteger( nsresult* aErrorCode, PRUint32 aRadix=kRadix10 ) const {
         return ToInteger(reinterpret_cast<PRInt32*>(aErrorCode), aRadix);
       }
 
         /**
          * |Left|, |Mid|, and |Right| are annoying signatures that seem better almost
          * any _other_ way than they are now.  Consider these alternatives
          * 
@@ -306,17 +306,17 @@ class nsTString_CharT : public nsTSubstr
          * 
          * aReadable.Left(aWritable, 17);    // ...a member function that does the assignment
          * 
          * or maybe just stamping them out in favor of |Substring|, they are just duplicate functionality
          *         
          * aWritable = Substring(aReadable, 0, 17);
          */
 
-      NS_COM size_type Mid( self_type& aResult, PRUint32 aStartPos, PRUint32 aCount ) const;
+      size_type Mid( self_type& aResult, PRUint32 aStartPos, PRUint32 aCount ) const;
 
       size_type Left( self_type& aResult, size_type aCount ) const
         {
           return Mid(aResult, 0, aCount);
         }
 
       size_type Right( self_type& aResult, size_type aCount ) const
         {
@@ -328,76 +328,76 @@ class nsTString_CharT : public nsTSubstr
         /**
          * Set a char inside this string at given index
          *
          * @param aChar is the char you want to write into this string
          * @param anIndex is the ofs where you want to write the given char
          * @return TRUE if successful
          */
 
-      NS_COM PRBool SetCharAt( PRUnichar aChar, PRUint32 aIndex );
+      PRBool SetCharAt( PRUnichar aChar, PRUint32 aIndex );
 
 
         /**
          *  These methods are used to remove all occurrences of the
          *  characters found in aSet from this string.
          *  
          *  @param  aSet -- characters to be cut from this
          */
-      NS_COM void StripChars( const char* aSet );
+      void StripChars( const char* aSet );
 
 
         /**
          *  This method strips whitespace throughout the string.
          */
-      NS_COM void StripWhitespace();
+      void StripWhitespace();
 
 
         /**
          *  swaps occurence of 1 string for another
          */
 
-      NS_COM void ReplaceChar( char_type aOldChar, char_type aNewChar );
-      NS_COM void ReplaceChar( const char* aSet, char_type aNewChar );
-      NS_COM void ReplaceSubstring( const self_type& aTarget, const self_type& aNewValue);
-      NS_COM void ReplaceSubstring( const char_type* aTarget, const char_type* aNewValue);
+      void ReplaceChar( char_type aOldChar, char_type aNewChar );
+      void ReplaceChar( const char* aSet, char_type aNewChar );
+      void ReplaceSubstring( const self_type& aTarget, const self_type& aNewValue);
+      void ReplaceSubstring( const char_type* aTarget, const char_type* aNewValue);
 
 
         /**
          *  This method trims characters found in aTrimSet from
          *  either end of the underlying string.
          *  
          *  @param   aSet -- contains chars to be trimmed from both ends
          *  @param   aEliminateLeading
          *  @param   aEliminateTrailing
          *  @param   aIgnoreQuotes -- if true, causes surrounding quotes to be ignored
          *  @return  this
          */
-      NS_COM void Trim( const char* aSet, PRBool aEliminateLeading=PR_TRUE, PRBool aEliminateTrailing=PR_TRUE, PRBool aIgnoreQuotes=PR_FALSE );
+      void Trim( const char* aSet, PRBool aEliminateLeading=PR_TRUE, PRBool aEliminateTrailing=PR_TRUE, PRBool aIgnoreQuotes=PR_FALSE );
 
         /**
          *  This method strips whitespace from string.
          *  You can control whether whitespace is yanked from start and end of
          *  string as well.
          *  
          *  @param   aEliminateLeading controls stripping of leading ws
          *  @param   aEliminateTrailing controls stripping of trailing ws
          */
-      NS_COM void CompressWhitespace( PRBool aEliminateLeading=PR_TRUE, PRBool aEliminateTrailing=PR_TRUE );
+      void CompressWhitespace( PRBool aEliminateLeading=PR_TRUE, PRBool aEliminateTrailing=PR_TRUE );
 
 
         /**
          * assign/append/insert with _LOSSY_ conversion
          */
 
-      NS_COM void AssignWithConversion( const nsTAString_IncompatibleCharT& aString );
-      NS_COM void AssignWithConversion( const incompatible_char_type* aData, PRInt32 aLength=-1 );
+      void AssignWithConversion( const nsTAString_IncompatibleCharT& aString );
+      void AssignWithConversion( const incompatible_char_type* aData, PRInt32 aLength=-1 );
 
-      NS_COM void AppendWithConversion( const nsTAString_IncompatibleCharT& aString );
-      NS_COM void AppendWithConversion( const incompatible_char_type* aData, PRInt32 aLength=-1 );
+      void AppendWithConversion( const nsTAString_IncompatibleCharT& aString );
+      void AppendWithConversion( const incompatible_char_type* aData, PRInt32 aLength=-1 );
 
 #endif // !MOZ_STRING_WITH_OBSOLETE_API
 
 
     protected:
 
       explicit
       nsTString_CharT( PRUint32 flags )
@@ -696,16 +696,16 @@ class nsTAdoptingString_CharT : public n
 
         // |operator=| does not inherit, so we must define our own
       self_type& operator=( const substring_type& str )                                         { Assign(str);      return *this; }
       self_type& operator=( const substring_tuple_type& tuple )                                 { Assign(tuple);    return *this; }
 
         // Adopt(), if possible, when assigning to a self_type&. Note
         // that this violates the constness of str, str is always
         // truncated when this operator is called.
-      NS_COM self_type& operator=( const self_type& str );
+      self_type& operator=( const self_type& str );
 
     private:
         // NOT TO BE IMPLEMENTED.
       self_type& operator=( const char_type* data );
       self_type& operator=( char_type* data );
   };
 
--- a/xpcom/string/public/nsTSubstring.h
+++ b/xpcom/string/public/nsTSubstring.h
@@ -38,31 +38,31 @@
 
 #ifndef MOZILLA_INTERNAL_API
 #error Cannot use internal string classes without MOZILLA_INTERNAL_API defined. Use the frozen header nsStringAPI.h instead.
 #endif
 
   /**
    * The base for string comparators
    */
-class NS_COM nsTStringComparator_CharT
+class nsTStringComparator_CharT
   {
     public:
       typedef CharT char_type;
 
       nsTStringComparator_CharT() {}
 
       virtual int operator()( const char_type*, const char_type*, PRUint32, PRUint32 ) const = 0;
   };
 
 
   /**
    * The default string comparator (case-sensitive comparision)
    */
-class NS_COM nsTDefaultStringComparator_CharT
+class nsTDefaultStringComparator_CharT
     : public nsTStringComparator_CharT
   {
     public:
       typedef CharT char_type;
 
       nsTDefaultStringComparator_CharT() {}
 
       virtual int operator()( const char_type*, const char_type*, PRUint32, PRUint32 ) const;
@@ -247,42 +247,42 @@ class nsTSubstring_CharT
 
       inline
       char_type Last() const
         {
           NS_ASSERTION(mLength > 0, "|Last()| called on an empty string");
           return mData[mLength - 1];
         }
 
-      NS_COM size_type NS_FASTCALL CountChar( char_type ) const;
-      NS_COM PRInt32 NS_FASTCALL FindChar( char_type, index_type offset = 0 ) const;
+      size_type NS_FASTCALL CountChar( char_type ) const;
+      PRInt32 NS_FASTCALL FindChar( char_type, index_type offset = 0 ) const;
 
 
         /**
          * equality
          */
 
-      NS_COM PRBool NS_FASTCALL Equals( const self_type& ) const;
-      NS_COM PRBool NS_FASTCALL Equals( const self_type&, const comparator_type& ) const;
+      PRBool NS_FASTCALL Equals( const self_type& ) const;
+      PRBool NS_FASTCALL Equals( const self_type&, const comparator_type& ) const;
 
-      NS_COM PRBool NS_FASTCALL Equals( const char_type* data ) const;
-      NS_COM PRBool NS_FASTCALL Equals( const char_type* data, const comparator_type& comp ) const;
+      PRBool NS_FASTCALL Equals( const char_type* data ) const;
+      PRBool NS_FASTCALL Equals( const char_type* data, const comparator_type& comp ) const;
 
         /**
          * An efficient comparison with ASCII that can be used even
          * for wide strings. Call this version when you know the
          * length of 'data'.
          */
-      NS_COM PRBool NS_FASTCALL EqualsASCII( const char* data, size_type len ) const;
+      PRBool NS_FASTCALL EqualsASCII( const char* data, size_type len ) const;
         /**
          * An efficient comparison with ASCII that can be used even
          * for wide strings. Call this version when 'data' is
          * null-terminated.
          */
-      NS_COM PRBool NS_FASTCALL EqualsASCII( const char* data ) const;
+      PRBool NS_FASTCALL EqualsASCII( const char* data ) const;
 
     // EqualsLiteral must ONLY be applied to an actual literal string.
     // Do not attempt to use it with a regular char* pointer, or with a char
     // array variable.
     // The template trick to acquire the array length at compile time without
     // using a macro is due to Corey Kosak, with much thanks.
 #ifdef NS_DISABLE_LITERAL_TEMPLATE
       inline PRBool EqualsLiteral( const char* str ) const
@@ -303,18 +303,18 @@ class nsTSubstring_CharT
         }
 #endif
 
     // The LowerCaseEquals methods compare the lower case version of
     // this string to some ASCII/Literal string. The ASCII string is
     // *not* lowercased for you. If you compare to an ASCII or literal
     // string that contains an uppercase character, it is guaranteed to
     // return false. We will throw assertions too.
-      NS_COM PRBool NS_FASTCALL LowerCaseEqualsASCII( const char* data, size_type len ) const;
-      NS_COM PRBool NS_FASTCALL LowerCaseEqualsASCII( const char* data ) const;
+      PRBool NS_FASTCALL LowerCaseEqualsASCII( const char* data, size_type len ) const;
+      PRBool NS_FASTCALL LowerCaseEqualsASCII( const char* data ) const;
 
     // LowerCaseEqualsLiteral must ONLY be applied to an actual
     // literal string.  Do not attempt to use it with a regular char*
     // pointer, or with a char array variable. Use
     // LowerCaseEqualsASCII for them.
 #ifdef NS_DISABLE_LITERAL_TEMPLATE
       inline PRBool LowerCaseEqualsLiteral( const char* str ) const
         {
@@ -333,23 +333,23 @@ class nsTSubstring_CharT
           return LowerCaseEqualsASCII(s, N-1);
         }
 #endif
 
         /**
          * assignment
          */
 
-      NS_COM void NS_FASTCALL Assign( char_type c );
-      NS_COM void NS_FASTCALL Assign( const char_type* data, size_type length = size_type(-1) );
-      NS_COM void NS_FASTCALL Assign( const self_type& );
-      NS_COM void NS_FASTCALL Assign( const substring_tuple_type& );
+      void NS_FASTCALL Assign( char_type c );
+      void NS_FASTCALL Assign( const char_type* data, size_type length = size_type(-1) );
+      void NS_FASTCALL Assign( const self_type& );
+      void NS_FASTCALL Assign( const substring_tuple_type& );
 
-      NS_COM void NS_FASTCALL AssignASCII( const char* data, size_type length );
-      NS_COM void NS_FASTCALL AssignASCII( const char* data );
+      void NS_FASTCALL AssignASCII( const char* data, size_type length );
+      void NS_FASTCALL AssignASCII( const char* data );
 
     // AssignLiteral must ONLY be applied to an actual literal string.
     // Do not attempt to use it with a regular char* pointer, or with a char
     // array variable. Use AssignASCII for those.
 #ifdef NS_DISABLE_LITERAL_TEMPLATE
       void AssignLiteral( const char* str )
                   { AssignASCII(str); }
 #else
@@ -361,39 +361,39 @@ class nsTSubstring_CharT
                   { AssignASCII(str, N-1); }
 #endif
 
       self_type& operator=( char_type c )                                                       { Assign(c);        return *this; }
       self_type& operator=( const char_type* data )                                             { Assign(data);     return *this; }
       self_type& operator=( const self_type& str )                                              { Assign(str);      return *this; }
       self_type& operator=( const substring_tuple_type& tuple )                                 { Assign(tuple);    return *this; }
 
-      NS_COM void NS_FASTCALL Adopt( char_type* data, size_type length = size_type(-1) );
+      void NS_FASTCALL Adopt( char_type* data, size_type length = size_type(-1) );
 
 
         /**
          * buffer manipulation
          */
 
-      NS_COM void NS_FASTCALL Replace( index_type cutStart, size_type cutLength, char_type c );
-      NS_COM void NS_FASTCALL Replace( index_type cutStart, size_type cutLength, const char_type* data, size_type length = size_type(-1) );
+      void NS_FASTCALL Replace( index_type cutStart, size_type cutLength, char_type c );
+      void NS_FASTCALL Replace( index_type cutStart, size_type cutLength, const char_type* data, size_type length = size_type(-1) );
              void Replace( index_type cutStart, size_type cutLength, const self_type& str )      { Replace(cutStart, cutLength, str.Data(), str.Length()); }
-      NS_COM void NS_FASTCALL Replace( index_type cutStart, size_type cutLength, const substring_tuple_type& tuple );
+      void NS_FASTCALL Replace( index_type cutStart, size_type cutLength, const substring_tuple_type& tuple );
 
-      NS_COM void NS_FASTCALL ReplaceASCII( index_type cutStart, size_type cutLength, const char* data, size_type length = size_type(-1) );
+      void NS_FASTCALL ReplaceASCII( index_type cutStart, size_type cutLength, const char* data, size_type length = size_type(-1) );
 
       void Append( char_type c )                                                                 { Replace(mLength, 0, c); }
       void Append( const char_type* data, size_type length = size_type(-1) )                     { Replace(mLength, 0, data, length); }
       void Append( const self_type& str )                                                        { Replace(mLength, 0, str); }
       void Append( const substring_tuple_type& tuple )                                           { Replace(mLength, 0, tuple); }
 
       void AppendASCII( const char* data, size_type length = size_type(-1) )                     { ReplaceASCII(mLength, 0, data, length); }
 
     // AppendPrintf truncates output to 31 ASCII characters
-      NS_COM void AppendPrintf( const char* format, ... );
+      void AppendPrintf( const char* format, ... );
       void AppendInt( PRInt32 aInteger )
                  { AppendPrintf( "%d", aInteger ); }
       void AppendInt( PRInt32 aInteger, int aRadix )
         {
           const char *fmt = aRadix == 10 ? "%d" : aRadix == 8 ? "%o" : "%x";
           AppendPrintf( fmt, aInteger );
         }
       void AppendInt( PRUint32 aInteger )
@@ -421,17 +421,17 @@ class nsTSubstring_CharT
       /**
        * Append the given float to this string 
        */
       void AppendFloat( float aFloat )
                       { DoAppendFloat(aFloat, 6); }
       void AppendFloat( double aFloat )
                       { DoAppendFloat(aFloat, 15); }
   private:
-      NS_COM void NS_FASTCALL DoAppendFloat( double aFloat, int digits );
+      void NS_FASTCALL DoAppendFloat( double aFloat, int digits );
   public:
 
     // AppendLiteral must ONLY be applied to an actual literal string.
     // Do not attempt to use it with a regular char* pointer, or with a char
     // array variable. Use AppendASCII for those.
 #ifdef NS_DISABLE_LITERAL_TEMPLATE
       void AppendLiteral( const char* str )
                   { AppendASCII(str); }
@@ -464,19 +464,19 @@ class nsTSubstring_CharT
         /**
          * Attempts to set the capacity to the given size, without affecting
          * the length of the string. Also ensures that the buffer is mutable.
          *
          * @returns PR_TRUE on success
          *          PR_FALSE on out-of-memory, or if requesting a size bigger
          *                   than a string can hold (2^31 chars).
          */
-      NS_COM PRBool NS_FASTCALL SetCapacity( size_type newCapacity );
+      PRBool NS_FASTCALL SetCapacity( size_type newCapacity );
 
-      NS_COM void NS_FASTCALL SetLength( size_type newLength );
+      void NS_FASTCALL SetLength( size_type newLength );
 
       void Truncate( size_type newLength = 0 )
         {
           NS_ASSERTION(newLength <= mLength, "Truncate cannot make string longer");
           SetLength(newLength);
         }
 
 
@@ -520,37 +520,37 @@ class nsTSubstring_CharT
         }
 
 
         /**
          * string data is never null, but can be marked void.  if true, the
          * string will be truncated.  @see nsTSubstring::IsVoid
          */
 
-      NS_COM void NS_FASTCALL SetIsVoid( PRBool );
+      void NS_FASTCALL SetIsVoid( PRBool );
 
         /**
          *  This method is used to remove all occurrences of aChar from this
          * string.
          *  
          *  @param  aChar -- char to be stripped
          *  @param  aOffset -- where in this string to start stripping chars
          */
          
-      NS_COM void StripChar( char_type aChar, PRInt32 aOffset=0 );
+      void StripChar( char_type aChar, PRInt32 aOffset=0 );
 
         /**
          *  This method is used to remove all occurrences of aChars from this
          * string.
          *
          *  @param  aChars -- chars to be stripped
          *  @param  aOffset -- where in this string to start stripping chars
          */
 
-      NS_COM void StripChars( const char_type* aChars, PRUint32 aOffset=0 );
+      void StripChars( const char_type* aChars, PRUint32 aOffset=0 );
 
         /**
          * If the string uses a shared buffer, this method
          * clears the pointer without releasing the buffer.
          */
       void ForgetSharedBuffer()
       {
         if (mFlags & nsSubstring::F_SHARED)
@@ -579,17 +579,17 @@ class nsTSubstring_CharT
          * allows for direct initialization of a nsTSubstring object. 
          *
          * NOTE: this constructor is declared public _only_ for convenience
          * inside the string implementation.
          */
         // XXXbz or can I just include nscore.h and use NS_BUILD_REFCNT_LOGGING?
 #if defined(DEBUG) || defined(FORCE_BUILD_REFCNT_LOGGING)
 #define XPCOM_STRING_CONSTRUCTOR_OUT_OF_LINE
-       NS_COM nsTSubstring_CharT( char_type *data, size_type length, PRUint32 flags );
+       nsTSubstring_CharT( char_type *data, size_type length, PRUint32 flags );
 #else
 #undef XPCOM_STRING_CONSTRUCTOR_OUT_OF_LINE
        nsTSubstring_CharT( char_type *data, size_type length, PRUint32 flags )
          : mData(data),
            mLength(length),
            mFlags(flags) {}
 #endif /* DEBUG || FORCE_BUILD_REFCNT_LOGGING */
 
@@ -623,17 +623,17 @@ class nsTSubstring_CharT
           mLength(str.mLength),
           mFlags(str.mFlags & (F_TERMINATED | F_VOIDED)) {}
 
         /**
          * this function releases mData and does not change the value of
          * any of its member variables.  in other words, this function acts
          * like a destructor.
          */
-      void NS_COM NS_FASTCALL Finalize();
+      void NS_FASTCALL Finalize();
 
         /**
          * this function prepares mData to be mutated.
          *
          * @param capacity     specifies the required capacity of mData  
          * @param old_data     returns null or the old value of mData
          * @param old_flags    returns 0 or the old value of mFlags
          *
@@ -697,17 +697,17 @@ class nsTSubstring_CharT
          *       is 0-sized).
          */
       size_type NS_FASTCALL Capacity() const;
 
         /**
          * this helper function can be called prior to directly manipulating
          * the contents of mData.  see, for example, BeginWriting.
          */
-      NS_COM PRBool NS_FASTCALL EnsureMutable( size_type newLen = size_type(-1) );
+      PRBool NS_FASTCALL EnsureMutable( size_type newLen = size_type(-1) );
 
         /**
          * returns true if this string overlaps with the given string fragment.
          */
       PRBool IsDependentOn( const char_type *start, const char_type *end ) const
         {
           /**
            * if it _isn't_ the case that one fragment starts after the other ends,
@@ -782,17 +782,16 @@ class nsTSubstring_CharT
       //   non-terminated substrings are always dependent.
       //
       //   F_VOIDED implies F_TERMINATED, and moreover it implies that mData
       //   points to char_traits::sEmptyBuffer.  Therefore, F_VOIDED is
       //   mutually exclusive with F_SHARED, F_OWNED, and F_FIXED.
       //
   };
 
-NS_COM
 int NS_FASTCALL Compare( const nsTSubstring_CharT::base_string_type& lhs, const nsTSubstring_CharT::base_string_type& rhs, const nsTStringComparator_CharT& = nsTDefaultStringComparator_CharT() );
 
 
 inline
 PRBool operator!=( const nsTSubstring_CharT::base_string_type& lhs, const nsTSubstring_CharT::base_string_type& rhs )
   {
     return !lhs.Equals(rhs);
   }
--- a/xpcom/string/public/nsTSubstringTuple.h
+++ b/xpcom/string/public/nsTSubstringTuple.h
@@ -68,30 +68,30 @@ class nsTSubstringTuple_CharT
       nsTSubstringTuple_CharT(const self_type& head, const base_string_type* b)
         : mHead(&head)
         , mFragA(nsnull) // this fragment is ignored when head != nsnull
         , mFragB(b) {}
 
         /**
          * computes the aggregate string length
          */
-      NS_COM size_type Length() const;
+      size_type Length() const;
 
         /**
          * writes the aggregate string to the given buffer.  bufLen is assumed
          * to be equal to or greater than the value returned by the Length()
          * method.  the string written to |buf| is not null-terminated.
          */
-      NS_COM void WriteTo(char_type *buf, PRUint32 bufLen) const;
+      void WriteTo(char_type *buf, PRUint32 bufLen) const;
 
         /**
          * returns true if this tuple is dependent on (i.e., overlapping with)
          * the given char sequence.
          */
-      NS_COM PRBool IsDependentOn(const char_type *start, const char_type *end) const;
+      PRBool IsDependentOn(const char_type *start, const char_type *end) const;
 
     private:
 
       const self_type*        mHead;
       const base_string_type* mFragA;
       const base_string_type* mFragB;
   };
 
--- a/xpcom/string/src/nsReadableUtils.cpp
+++ b/xpcom/string/src/nsReadableUtils.cpp
@@ -36,77 +36,69 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsReadableUtils.h"
 #include "nsMemory.h"
 #include "nsString.h"
 #include "nsUTF8Utils.h"
 
-NS_COM
 void
 LossyCopyUTF16toASCII( const nsAString& aSource, nsACString& aDest )
   {
     aDest.Truncate();
     LossyAppendUTF16toASCII(aSource, aDest);
   }
 
-NS_COM
 void
 CopyASCIItoUTF16( const nsACString& aSource, nsAString& aDest )
   {
     aDest.Truncate();
     AppendASCIItoUTF16(aSource, aDest);
   }
 
-NS_COM
 void
 LossyCopyUTF16toASCII( const PRUnichar* aSource, nsACString& aDest )
   {
     aDest.Truncate();
     if (aSource) {
       LossyAppendUTF16toASCII(nsDependentString(aSource), aDest);
     }
   }
 
-NS_COM
 void
 CopyASCIItoUTF16( const char* aSource, nsAString& aDest )
   {
     aDest.Truncate();
     if (aSource) {
       AppendASCIItoUTF16(nsDependentCString(aSource), aDest);
     }
   }
 
-NS_COM
 void
 CopyUTF16toUTF8( const nsAString& aSource, nsACString& aDest )
   {
     aDest.Truncate();
     AppendUTF16toUTF8(aSource, aDest);
   }
 
-NS_COM
 void
 CopyUTF8toUTF16( const nsACString& aSource, nsAString& aDest )
   {
     aDest.Truncate();
     AppendUTF8toUTF16(aSource, aDest);
   }
 
-NS_COM
 void
 CopyUTF16toUTF8( const PRUnichar* aSource, nsACString& aDest )
   {
     aDest.Truncate();
     AppendUTF16toUTF8(aSource, aDest);
   }
 
-NS_COM
 void
 CopyUTF8toUTF16( const char* aSource, nsAString& aDest )
   {
     aDest.Truncate();
     AppendUTF8toUTF16(aSource, aDest);
   }
 
 // Like GetMutableData, but returns false if it can't
@@ -125,17 +117,16 @@ PRBool
 SetLengthForWritingC(nsACString& aDest, PRUint32 aDesiredLength)
   {
     char* dummy;
     PRUint32 len = aDest.GetMutableData(&dummy, aDesiredLength);
     return (len >= aDesiredLength);
   }
 
 
-NS_COM
 void
 LossyAppendUTF16toASCII( const nsAString& aSource, nsACString& aDest )
   {
     PRUint32 old_dest_length = aDest.Length();
     if (!SetLengthForWritingC(aDest, old_dest_length + aSource.Length()))
         return;
 
     nsAString::const_iterator fromBegin, fromEnd;
@@ -146,17 +137,16 @@ LossyAppendUTF16toASCII( const nsAString
     dest.advance(old_dest_length);
 
     // right now, this won't work on multi-fragment destinations
     LossyConvertEncoding16to8 converter(dest.get());
 
     copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd), converter);
   }
 
-NS_COM
 void
 AppendASCIItoUTF16( const nsACString& aSource, nsAString& aDest )
   {
     PRUint32 old_dest_length = aDest.Length();
     if (!SetLengthForWriting(aDest, old_dest_length + aSource.Length()))
         return;
 
     nsACString::const_iterator fromBegin, fromEnd;
@@ -167,35 +157,32 @@ AppendASCIItoUTF16( const nsACString& aS
     dest.advance(old_dest_length);
 
       // right now, this won't work on multi-fragment destinations
     LossyConvertEncoding8to16 converter(dest.get());
 
     copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd), converter);
   }
 
-NS_COM
 void
 LossyAppendUTF16toASCII( const PRUnichar* aSource, nsACString& aDest )
   {
     if (aSource) {
       LossyAppendUTF16toASCII(nsDependentString(aSource), aDest);
     }
   }
 
-NS_COM
 void
 AppendASCIItoUTF16( const char* aSource, nsAString& aDest )
   {
     if (aSource) {
       AppendASCIItoUTF16(nsDependentCString(aSource), aDest);
     }
   }
 
-NS_COM
 void
 AppendUTF16toUTF8( const nsAString& aSource, nsACString& aDest )
   {
     nsAString::const_iterator source_start, source_end;
     CalculateUTF8Size calculator;
     copy_string(aSource.BeginReading(source_start),
                 aSource.EndReading(source_end), calculator);
 
@@ -216,17 +203,16 @@ AppendUTF16toUTF8( const nsAString& aSou
                     aSource.EndReading(source_end), converter);
 
         NS_ASSERTION(converter.Size() == count,
                      "Unexpected disparity between CalculateUTF8Size and "
                      "ConvertUTF16toUTF8");
       }
   }
 
-NS_COM
 void
 AppendUTF8toUTF16( const nsACString& aSource, nsAString& aDest )
   {
     nsACString::const_iterator source_start, source_end;
     CalculateUTF8Length calculator;
     copy_string(aSource.BeginReading(source_start),
                 aSource.EndReading(source_end), calculator);
 
@@ -254,26 +240,24 @@ AppendUTF8toUTF16( const nsACString& aSo
         if (converter.ErrorEncountered())
           {
             NS_ERROR("Input wasn't UTF8 or incorrect length was calculated");
             aDest.SetLength(old_dest_length);
           }
       }
   }
 
-NS_COM
 void
 AppendUTF16toUTF8( const PRUnichar* aSource, nsACString& aDest )
   {
     if (aSource) {
       AppendUTF16toUTF8(nsDependentString(aSource), aDest);
     }
   }
 
-NS_COM
 void
 AppendUTF8toUTF16( const char* aSource, nsAString& aDest )
   {
     if (aSource) {
       AppendUTF8toUTF16(nsDependentCString(aSource), aDest);
     }
   }
 
@@ -289,31 +273,29 @@ template <class FromStringT, class ToCha
 inline
 ToCharT*
 AllocateStringCopy( const FromStringT& aSource, ToCharT* )
   {
     return static_cast<ToCharT*>(nsMemory::Alloc((aSource.Length()+1) * sizeof(ToCharT)));
   }
 
 
-NS_COM
 char*
 ToNewCString( const nsAString& aSource )
   {
     char* result = AllocateStringCopy(aSource, (char*)0);
     if (!result)
       return nsnull;
 
     nsAString::const_iterator fromBegin, fromEnd;
     LossyConvertEncoding16to8 converter(result);
     copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd), converter).write_terminator();
     return result;
   }
 
-NS_COM
 char*
 ToNewUTF8String( const nsAString& aSource, PRUint32 *aUTF8Count )
   {
     nsAString::const_iterator start, end;
     CalculateUTF8Size calculator;
     copy_string(aSource.BeginReading(start), aSource.EndReading(end),
                 calculator);
 
@@ -328,63 +310,59 @@ ToNewUTF8String( const nsAString& aSourc
     ConvertUTF16toUTF8 converter(result);
     copy_string(aSource.BeginReading(start), aSource.EndReading(end),
                 converter).write_terminator();
     NS_ASSERTION(calculator.Size() == converter.Size(), "length mismatch");
 
     return result;
   }
 
-NS_COM
 char*
 ToNewCString( const nsACString& aSource )
   {
     // no conversion needed, just allocate a buffer of the correct length and copy into it
 
     char* result = AllocateStringCopy(aSource, (char*)0);
     if (!result)
       return nsnull;
 
     nsACString::const_iterator fromBegin, fromEnd;
     char* toBegin = result;
     *copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd), toBegin) = char(0);
     return result;
   }
 
-NS_COM
 PRUnichar*
 ToNewUnicode( const nsAString& aSource )
   {
     // no conversion needed, just allocate a buffer of the correct length and copy into it
 
     PRUnichar* result = AllocateStringCopy(aSource, (PRUnichar*)0);
     if (!result)
       return nsnull;
 
     nsAString::const_iterator fromBegin, fromEnd;
     PRUnichar* toBegin = result;
     *copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd), toBegin) = PRUnichar(0);
     return result;
   }
 
-NS_COM
 PRUnichar*
 ToNewUnicode( const nsACString& aSource )
   {
     PRUnichar* result = AllocateStringCopy(aSource, (PRUnichar*)0);
     if (!result)
       return nsnull;
 
     nsACString::const_iterator fromBegin, fromEnd;
     LossyConvertEncoding8to16 converter(result);
     copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd), converter).write_terminator();
     return result;
   }
 
-NS_COM
 PRUnichar*
 UTF8ToNewUnicode( const nsACString& aSource, PRUint32 *aUTF16Count )
   {
     nsACString::const_iterator start, end;
     CalculateUTF8Length calculator;
     copy_string(aSource.BeginReading(start), aSource.EndReading(end),
                 calculator);
 
@@ -399,60 +377,56 @@ UTF8ToNewUnicode( const nsACString& aSou
     ConvertUTF8toUTF16 converter(result);
     copy_string(aSource.BeginReading(start), aSource.EndReading(end),
                 converter).write_terminator();
     NS_ASSERTION(calculator.Length() == converter.Length(), "length mismatch");
 
     return result;
   }
 
-NS_COM
 PRUnichar*
 CopyUnicodeTo( const nsAString& aSource, PRUint32 aSrcOffset, PRUnichar* aDest, PRUint32 aLength )
   {
     nsAString::const_iterator fromBegin, fromEnd;
     PRUnichar* toBegin = aDest;    
     copy_string(aSource.BeginReading(fromBegin).advance( PRInt32(aSrcOffset) ), aSource.BeginReading(fromEnd).advance( PRInt32(aSrcOffset+aLength) ), toBegin);
     return aDest;
   }
 
-NS_COM 
-void 
+void
 CopyUnicodeTo( const nsAString::const_iterator& aSrcStart,
                const nsAString::const_iterator& aSrcEnd,
                nsAString& aDest )
   {
     nsAString::iterator writer;
     if (!SetLengthForWriting(aDest, Distance(aSrcStart, aSrcEnd)))
         return;
 
     aDest.BeginWriting(writer);
     nsAString::const_iterator fromBegin(aSrcStart);
     
     copy_string(fromBegin, aSrcEnd, writer);
   }
 
-NS_COM 
-void 
+void
 AppendUnicodeTo( const nsAString::const_iterator& aSrcStart,
                  const nsAString::const_iterator& aSrcEnd,
                  nsAString& aDest )
   {
     nsAString::iterator writer;
     PRUint32 oldLength = aDest.Length();
     if(!SetLengthForWriting(aDest, oldLength + Distance(aSrcStart, aSrcEnd)))
         return;
 
     aDest.BeginWriting(writer).advance(oldLength);
     nsAString::const_iterator fromBegin(aSrcStart);
     
     copy_string(fromBegin, aSrcEnd, writer);
   }
 
-NS_COM
 PRBool
 IsASCII( const nsAString& aString )
   {
     static const PRUnichar NOT_ASCII = PRUnichar(~0x007F);
 
 
     // Don't want to use |copy_string| for this task, since we can stop at the first non-ASCII character
 
@@ -467,17 +441,16 @@ IsASCII( const nsAString& aString )
       {
         if ( *c++ & NOT_ASCII )
           return PR_FALSE;
       }
 
     return PR_TRUE;
   }
 
-NS_COM
 PRBool
 IsASCII( const nsACString& aString )
   {
     static const char NOT_ASCII = char(~0x7F);
 
 
     // Don't want to use |copy_string| for this task, since we can stop at the first non-ASCII character
 
@@ -492,17 +465,16 @@ IsASCII( const nsACString& aString )
       {
         if ( *c++ & NOT_ASCII )
           return PR_FALSE;
       }
 
     return PR_TRUE;
   }
 
-NS_COM
 PRBool
 IsUTF8( const nsACString& aString )
   {
     nsReadingIterator<char> done_reading;
     aString.EndReading(done_reading);
 
     PRInt32 state = 0;
     PRBool overlong = PR_FALSE;
@@ -607,17 +579,16 @@ class ConvertToUpperCase
             if ((ch >= 'a') && (ch <= 'z'))
               *cp = ch - ('a' - 'A');
             ++cp;
           }
           return aSourceLength;
         }
   };
 
-NS_COM
 void
 ToUpperCase( nsCSubstring& aCString )
   {
     ConvertToUpperCase converter;
     char* start;
     converter.write(aCString.BeginWriting(start), aCString.Length());
   }
 
@@ -652,17 +623,16 @@ class CopyToUpperCase
           mIter.advance(len);
           return len;
         }
 
     protected:
       nsACString::iterator& mIter;
   };
 
-NS_COM
 void
 ToUpperCase( const nsACString& aSource, nsACString& aDest )
   {
     nsACString::const_iterator fromBegin, fromEnd;
     nsACString::iterator toBegin;
     if (!SetLengthForWritingC(aDest, aSource.Length()))
         return;
 
@@ -688,17 +658,16 @@ class ConvertToLowerCase
             if ((ch >= 'A') && (ch <= 'Z'))
               *cp = ch + ('a' - 'A');
             ++cp;
           }
           return aSourceLength;
         }
   };
 
-NS_COM
 void
 ToLowerCase( nsCSubstring& aCString )
   {
     ConvertToLowerCase converter;
     char* start;
     converter.write(aCString.BeginWriting(start), aCString.Length());
   }
 
@@ -733,30 +702,28 @@ class CopyToLowerCase
           mIter.advance(len);
           return len;
         }
 
     protected:
       nsACString::iterator& mIter;
   };
 
-NS_COM
 void
 ToLowerCase( const nsACString& aSource, nsACString& aDest )
   {
     nsACString::const_iterator fromBegin, fromEnd;
     nsACString::iterator toBegin;
     if (!SetLengthForWritingC(aDest, aSource.Length()))
         return;
 
     CopyToLowerCase converter(aDest.BeginWriting(toBegin));
     copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd), converter);
   }
 
-NS_COM
 PRBool
 ParseString(const nsACString& aSource, char aDelimiter, 
             nsTArray<nsCString>& aArray)
   {
     nsACString::const_iterator start, end;
     aSource.BeginReading(start);
     aSource.EndReading(end);
 
@@ -905,85 +872,77 @@ RFindInReadable_Impl( const StringT& aPa
             while ( compare(testPattern.get(), testSearch.get(), 1, 1) == 0 );
           }
       }
 
     aSearchStart = aSearchEnd;
     return PR_FALSE;
   }
 
-NS_COM
 PRBool
 FindInReadable( const nsAString& aPattern, nsAString::const_iterator& aSearchStart, nsAString::const_iterator& aSearchEnd, const nsStringComparator& aComparator )
   {
     return FindInReadable_Impl(aPattern, aSearchStart, aSearchEnd, aComparator);
   }
 
-NS_COM
 PRBool
 FindInReadable( const nsACString& aPattern, nsACString::const_iterator& aSearchStart, nsACString::const_iterator& aSearchEnd, const nsCStringComparator& aComparator)
   {
     return FindInReadable_Impl(aPattern, aSearchStart, aSearchEnd, aComparator);
   }
 
-NS_COM
 PRBool
 CaseInsensitiveFindInReadable( const nsACString& aPattern, nsACString::const_iterator& aSearchStart, nsACString::const_iterator& aSearchEnd )
   {
     return FindInReadable_Impl(aPattern, aSearchStart, aSearchEnd, nsCaseInsensitiveCStringComparator());
   }
 
-NS_COM
 PRBool
 RFindInReadable( const nsAString& aPattern, nsAString::const_iterator& aSearchStart, nsAString::const_iterator& aSearchEnd, const nsStringComparator& aComparator)
   {
     return RFindInReadable_Impl(aPattern, aSearchStart, aSearchEnd, aComparator);
   }
 
-NS_COM
 PRBool
 RFindInReadable( const nsACString& aPattern, nsACString::const_iterator& aSearchStart, nsACString::const_iterator& aSearchEnd, const nsCStringComparator& aComparator)
   {
     return RFindInReadable_Impl(aPattern, aSearchStart, aSearchEnd, aComparator);
   }
 
-NS_COM 
-PRBool 
+PRBool
 FindCharInReadable( PRUnichar aChar, nsAString::const_iterator& aSearchStart, const nsAString::const_iterator& aSearchEnd )
   {
     PRInt32 fragmentLength = aSearchEnd.get() - aSearchStart.get();
 
     const PRUnichar* charFoundAt = nsCharTraits<PRUnichar>::find(aSearchStart.get(), fragmentLength, aChar);
     if ( charFoundAt ) {
       aSearchStart.advance( charFoundAt - aSearchStart.get() );
       return PR_TRUE;
     }
 
     aSearchStart.advance(fragmentLength);
     return PR_FALSE;
   }
 
-NS_COM 
-PRBool 
+PRBool
 FindCharInReadable( char aChar, nsACString::const_iterator& aSearchStart, const nsACString::const_iterator& aSearchEnd )
   {
     PRInt32 fragmentLength = aSearchEnd.get() - aSearchStart.get();
 
     const char* charFoundAt = nsCharTraits<char>::find(aSearchStart.get(), fragmentLength, aChar);
     if ( charFoundAt ) {
       aSearchStart.advance( charFoundAt - aSearchStart.get() );
       return PR_TRUE;
     }
 
     aSearchStart.advance(fragmentLength);
     return PR_FALSE;
-  } 
+  }
 
-NS_COM 
-PRUint32 
+PRUint32
 CountCharInReadable( const nsAString& aStr,
                      PRUnichar aChar )
 {
   PRUint32 count = 0;
   nsAString::const_iterator begin, end;
   
   aStr.BeginReading(begin);
   aStr.EndReading(end);
@@ -993,18 +952,17 @@ CountCharInReadable( const nsAString& aS
       ++count;
     }
     ++begin;
   }
 
   return count;
 }
 
-NS_COM 
-PRUint32 
+PRUint32
 CountCharInReadable( const nsACString& aStr,
                      char aChar )
 {
   PRUint32 count = 0;
   nsACString::const_iterator begin, end;
   
   aStr.BeginReading(begin);
   aStr.EndReading(end);
@@ -1014,85 +972,83 @@ CountCharInReadable( const nsACString& a
       ++count;
     }
     ++begin;
   }
 
   return count;
 }
 
-NS_COM PRBool
+PRBool
 StringBeginsWith( const nsAString& aSource, const nsAString& aSubstring,
                   const nsStringComparator& aComparator )
   {
     nsAString::size_type src_len = aSource.Length(),
                          sub_len = aSubstring.Length();
     if (sub_len > src_len)
       return PR_FALSE;
     return Substring(aSource, 0, sub_len).Equals(aSubstring, aComparator);
   }
 
-NS_COM PRBool
+PRBool
 StringBeginsWith( const nsACString& aSource, const nsACString& aSubstring,
                   const nsCStringComparator& aComparator )
   {
     nsACString::size_type src_len = aSource.Length(),
                           sub_len = aSubstring.Length();
     if (sub_len > src_len)
       return PR_FALSE;
     return Substring(aSource, 0, sub_len).Equals(aSubstring, aComparator);
   }
 
-NS_COM PRBool
+PRBool
 StringEndsWith( const nsAString& aSource, const nsAString& aSubstring,
                 const nsStringComparator& aComparator )
   {
     nsAString::size_type src_len = aSource.Length(),
                          sub_len = aSubstring.Length();
     if (sub_len > src_len)
       return PR_FALSE;
     return Substring(aSource, src_len - sub_len, sub_len).Equals(aSubstring,
                                                                  aComparator);
   }
 
-NS_COM PRBool
+PRBool
 StringEndsWith( const nsACString& aSource, const nsACString& aSubstring,
                 const nsCStringComparator& aComparator )
   {
     nsACString::size_type src_len = aSource.Length(),
                           sub_len = aSubstring.Length();
     if (sub_len > src_len)
       return PR_FALSE;
     return Substring(aSource, src_len - sub_len, sub_len).Equals(aSubstring,
                                                                  aComparator);
   }
 
 
 
 static const PRUnichar empty_buffer[1] = { '\0' };
 
-NS_COM
 const nsAFlatString&
 EmptyString()
   {
     static const nsDependentString sEmpty(empty_buffer);
 
     return sEmpty;
   }
 
-NS_COM
 const nsAFlatCString&
 EmptyCString()
   {
     static const nsDependentCString sEmpty((const char *)empty_buffer);
 
     return sEmpty;
   }
 
-NS_COM PRInt32
+PRInt32
 CompareUTF8toUTF16(const nsASingleFragmentCString& aUTF8String,
                    const nsASingleFragmentString& aUTF16String)
   {
     static const PRUint32 NOT_ASCII = PRUint32(~0x7F);
 
     const char *u8, *u8end;
     aUTF8String.BeginReading(u8);
     aUTF8String.EndReading(u8end);
@@ -1159,17 +1115,16 @@ CompareUTF8toUTF16(const nsASingleFragme
         return -1;
       }
 
     // The two strings match.
 
     return 0;
   }
 
-NS_COM
 void
 AppendUCS4ToUTF16(const PRUint32 aSource, nsAString& aDest)
   {
     NS_ASSERTION(IS_VALID_CHAR(aSource), "Invalid UCS4 char");
     if (IS_IN_BMP(aSource))
       {
         aDest.Append(PRUnichar(aSource));
       }
--- a/xpcom/string/src/nsTString.cpp
+++ b/xpcom/string/src/nsTString.cpp
@@ -32,17 +32,17 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-NS_COM nsTAdoptingString_CharT&
+nsTAdoptingString_CharT&
 nsTAdoptingString_CharT::operator=( const self_type& str )
   {
     // This'll violate the constness of this argument, that's just
     // the nature of this class...
     self_type* mutable_str = const_cast<self_type*>(&str);
 
     if (str.mFlags & F_OWNED)
       {
--- a/xpcom/string/src/nsTStringComparator.cpp
+++ b/xpcom/string/src/nsTStringComparator.cpp
@@ -31,17 +31,17 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
-NS_COM int NS_FASTCALL
+int NS_FASTCALL
 Compare( const nsTSubstring_CharT::base_string_type& lhs, const nsTSubstring_CharT::base_string_type& rhs, const nsTStringComparator_CharT& comp )
   {
     typedef nsTSubstring_CharT::size_type size_type;
 
     if ( &lhs == &rhs )
       return 0;
 
     nsTSubstring_CharT::const_iterator leftIter, rightIter;
--- a/xpcom/tests/TestPipes.cpp
+++ b/xpcom/tests/TestPipes.cpp
@@ -467,17 +467,17 @@ RunTests(PRUint32 segSize, PRUint32 segC
     NS_ASSERTION(NS_SUCCEEDED(rv), "TP_NewPipe failed");
     rv = TestShortWrites(in, out);
     NS_ASSERTION(NS_SUCCEEDED(rv), "TestPipe failed");
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #if 0
-extern NS_COM void
+extern void
 TestSegmentedBuffer();
 #endif
 
 int
 main(int argc, char* argv[])
 {
     nsresult rv;
 
--- a/xpcom/threads/nsEventQueue.h
+++ b/xpcom/threads/nsEventQueue.h
@@ -39,17 +39,17 @@
 #ifndef nsEventQueue_h__
 #define nsEventQueue_h__
 
 #include <stdlib.h>
 #include "mozilla/ReentrantMonitor.h"
 #include "nsIRunnable.h"
 
 // A threadsafe FIFO event queue...
-class NS_COM nsEventQueue
+class nsEventQueue
 {
   typedef mozilla::ReentrantMonitor ReentrantMonitor;
 
 public:
   nsEventQueue();
   ~nsEventQueue();
 
   // This method adds a new event to the pending event queue.  The event object
--- a/xpcom/threads/nsThreadUtilsInternal.h
+++ b/xpcom/threads/nsThreadUtilsInternal.h
@@ -49,13 +49,13 @@ class nsIThreadObserver;
  * posted to threads.  Only one global observer can be set at a time; an
  * attempt to change the value without setting it to null first will throw.
  * This function does NOT take a reference to the observer; the caller of this
  * function is responsible for setting the observer to null when it goes away.
  * This method may only be called on the main thread; attempts to do it on
  * other threads will return an error.
  */
 extern nsresult
-NS_COM NS_SetGlobalThreadObserver(nsIThreadObserver* aObserver);
+NS_SetGlobalThreadObserver(nsIThreadObserver* aObserver);
 
 #endif // MOZILLA_INTERNAL_API
 
 #endif  // nsThreadUtilsInternal_h_