diff --git a/caps/include/nsBasePrincipal.h b/caps/include/nsBasePrincipal.h
index 56a1fb8cacd..e83be39fa0f 100644
--- a/caps/include/nsBasePrincipal.h
+++ b/caps/include/nsBasePrincipal.h
@@ -86,7 +86,7 @@ protected:
     nsJSPrincipals mJSPrincipals;
     nsVoidArray mAnnotations;
     nsHashtable *mCapabilities;
-    nsCString mPrefName;
+    char *mPrefName;
     static int mCapabilitiesOrdinal;
 };
 
diff --git a/caps/include/nsCertificatePrincipal.h b/caps/include/nsCertificatePrincipal.h
index 65976044002..0d30e619059 100644
--- a/caps/include/nsCertificatePrincipal.h
+++ b/caps/include/nsCertificatePrincipal.h
@@ -82,8 +82,8 @@ public:
 	virtual ~nsCertificatePrincipal(void);
 
 protected:
-    nsCString mCertificateID;
-    nsCString mCommonName;
+    char* mCertificateID;
+    char* mCommonName;
 };
 
 #endif // _NS_CERTIFICATE_PRINCIPAL_H_
diff --git a/caps/src/nsBasePrincipal.cpp b/caps/src/nsBasePrincipal.cpp
index cf9bbc6f2e2..3101ad3f12a 100644
--- a/caps/src/nsBasePrincipal.cpp
+++ b/caps/src/nsBasePrincipal.cpp
@@ -32,7 +32,7 @@
 //////////////////////////
 
 nsBasePrincipal::nsBasePrincipal()
-    : mCapabilities(nsnull)
+    : mCapabilities(nsnull), mPrefName(nsnull)
 {
 }
 
@@ -48,6 +48,8 @@ nsBasePrincipal::~nsBasePrincipal(void)
 {
     mAnnotations.EnumerateForwards(deleteElement, nsnull);
     delete mCapabilities;
+    if (mPrefName)
+        Recycle(mPrefName);
 }
 
 NS_IMETHODIMP
@@ -235,7 +237,9 @@ nsBasePrincipal::InitFromPersistent(const char* aPrefName, const char* aID,
         mCapabilities->Reset();
 
     //-- Save the preference name
-    mPrefName = aPrefName;
+    mPrefName = PL_strdup(aPrefName);
+    if (!mPrefName)
+        return NS_ERROR_OUT_OF_MEMORY;
 
     const char* ordinalBegin = PL_strpbrk(aPrefName, "1234567890");
     if (ordinalBegin) {
@@ -284,7 +288,7 @@ nsBasePrincipal::GetPreferences(char** aPrefName, char** aID,
                                 char** aGrantedList, char** aDeniedList)
 {
     //-- Preference name
-    *aPrefName = ToNewCString(mPrefName);
+    *aPrefName = nsCRT::strdup(mPrefName);
     if (!aPrefName)
         return NS_ERROR_OUT_OF_MEMORY;
 
@@ -380,7 +384,7 @@ nsBasePrincipal::Read(nsIObjectInputStream* aStream)
     }
     if (NS_FAILED(rv)) return rv;
 
-    rv = NS_ReadOptionalCString(aStream, mPrefName);
+    rv = NS_ReadOptionalStringZ(aStream, &mPrefName);
     if (NS_FAILED(rv)) return rv;
 
     return NS_OK;
@@ -415,7 +419,7 @@ nsBasePrincipal::Write(nsIObjectOutputStream* aStream)
         rv = mCapabilities->Write(aStream, WriteScalarValue);
     if (NS_FAILED(rv)) return rv;
 
-    rv = NS_WriteOptionalStringZ(aStream, mPrefName.get());
+    rv = NS_WriteOptionalStringZ(aStream, mPrefName);
     if (NS_FAILED(rv)) return rv;
 
     return NS_OK;
diff --git a/caps/src/nsCertificatePrincipal.cpp b/caps/src/nsCertificatePrincipal.cpp
index bf51ff2fcea..51c09bb3115 100644
--- a/caps/src/nsCertificatePrincipal.cpp
+++ b/caps/src/nsCertificatePrincipal.cpp
@@ -64,22 +64,23 @@ NSBASEPRINCIPALS_RELEASE(nsCertificatePrincipal);
 NS_IMETHODIMP
 nsCertificatePrincipal::GetCertificateID(char** aCertificateID) 
 {
-    *aCertificateID = ToNewCString(mCertificateID);
+    *aCertificateID = nsCRT::strdup(mCertificateID);
     return *aCertificateID ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 }
 
 NS_IMETHODIMP
 nsCertificatePrincipal::GetCommonName(char** aCommonName)
 {
-    *aCommonName = ToNewCString(mCommonName);
+    *aCommonName = nsCRT::strdup(mCommonName);
     return *aCommonName ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 }
 
 NS_IMETHODIMP
 nsCertificatePrincipal::SetCommonName(const char* aCommonName)
 {
-    mCommonName = aCommonName;
-    return NS_OK;
+    PR_FREEIF(mCommonName);
+    mCommonName = nsCRT::strdup(aCommonName);
+    return mCommonName ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 }
 
 ///////////////////////////////////////
@@ -112,10 +113,12 @@ NS_IMETHODIMP
 nsCertificatePrincipal::GetPreferences(char** aPrefName, char** aID, 
                                        char** aGrantedList, char** aDeniedList)
 {
-    if (mPrefName.IsEmpty()) {
-        mPrefName.Assign("capability.principal.certificate.p");
-        mPrefName.AppendInt(mCapabilitiesOrdinal++);
-        mPrefName.Append(".id");
+    if (!mPrefName) {
+        nsCAutoString s;
+        s.Assign("capability.principal.certificate.p");
+        s.AppendInt(mCapabilitiesOrdinal++);
+        s.Append(".id");
+        mPrefName = ToNewCString(s);
     }
     return nsBasePrincipal::GetPreferences(aPrefName, aID, 
                                            aGrantedList, aDeniedList);
@@ -144,7 +147,7 @@ nsCertificatePrincipal::Equals(nsIPrincipal * other, PRBool * result)
         PR_FREEIF(otherID);
         return rv;
     }
-    *result = mCertificateID.Equals(otherID);
+    *result = (PL_strcmp(mCertificateID, otherID) == 0);
     PR_FREEIF(otherID);
     return NS_OK;
 }
@@ -171,10 +174,10 @@ nsCertificatePrincipal::Read(nsIObjectInputStream* aStream)
     rv = nsBasePrincipal::Read(aStream);
     if (NS_FAILED(rv)) return rv;
 
-    rv = aStream->ReadCString(mCertificateID);
+    rv = aStream->ReadStringZ(&mCertificateID);
     if (NS_FAILED(rv)) return rv;
 
-    rv = NS_ReadOptionalCString(aStream, mCommonName);
+    rv = NS_ReadOptionalStringZ(aStream, &mCommonName);
     if (NS_FAILED(rv)) return rv;
 
     return NS_OK;
@@ -188,10 +191,10 @@ nsCertificatePrincipal::Write(nsIObjectOutputStream* aStream)
     rv = nsBasePrincipal::Write(aStream);
     if (NS_FAILED(rv)) return rv;
 
-    rv = aStream->WriteStringZ(mCertificateID.get());
+    rv = aStream->WriteStringZ(mCertificateID);
     if (NS_FAILED(rv)) return rv;
 
-    rv = NS_WriteOptionalStringZ(aStream, mCommonName.get());
+    rv = NS_WriteOptionalStringZ(aStream, mCommonName);
     if (NS_FAILED(rv)) return rv;
 
     return NS_OK;
@@ -214,15 +217,19 @@ nsCertificatePrincipal::InitFromPersistent(const char* aPrefName, const char*  a
 NS_IMETHODIMP
 nsCertificatePrincipal::Init(const char* aCertificateID)
 {
-    mCertificateID = aCertificateID;
+    mCertificateID = nsCRT::strdup(aCertificateID);
+    if (!mCertificateID) return NS_ERROR_OUT_OF_MEMORY;
     return NS_OK;
 }
 
-nsCertificatePrincipal::nsCertificatePrincipal()
+nsCertificatePrincipal::nsCertificatePrincipal() : mCertificateID(nsnull),
+                                                   mCommonName(nsnull)
 {
     NS_INIT_ISUPPORTS();
 }
 
 nsCertificatePrincipal::~nsCertificatePrincipal()
 {
+    PR_FREEIF(mCertificateID);
+    PR_FREEIF(mCommonName);
 }
diff --git a/caps/src/nsCodebasePrincipal.cpp b/caps/src/nsCodebasePrincipal.cpp
index bdb5bb8f39d..d5481fca4d1 100644
--- a/caps/src/nsCodebasePrincipal.cpp
+++ b/caps/src/nsCodebasePrincipal.cpp
@@ -82,11 +82,13 @@ NS_IMETHODIMP
 nsCodebasePrincipal::GetPreferences(char** aPrefName, char** aID, 
                                     char** aGrantedList, char** aDeniedList)
 {
-    if (mPrefName.IsEmpty())
+    if (!mPrefName)
 	{
-        mPrefName.Assign("capability.principal.codebase.p");
-        mPrefName.AppendInt(mCapabilitiesOrdinal++);
-        mPrefName.Append(".id");
+        nsCAutoString s;
+        s.Assign("capability.principal.codebase.p");
+        s.AppendInt(mCapabilitiesOrdinal++);
+        s.Append(".id");
+        mPrefName = ToNewCString(s);
     }
     return nsBasePrincipal::GetPreferences(aPrefName, aID, 
                                            aGrantedList, aDeniedList);
diff --git a/content/xul/content/src/nsXULElement.cpp b/content/xul/content/src/nsXULElement.cpp
index f61c02b3f83..70e95a4e390 100644
--- a/content/xul/content/src/nsXULElement.cpp
+++ b/content/xul/content/src/nsXULElement.cpp
@@ -4939,14 +4939,14 @@ nsXULPrototypeElement::Deserialize(nsIObjectInputStream* aStream,
         if (! mAttributes)
             return NS_ERROR_OUT_OF_MEMORY;
 
-        nsAutoString attributeValue;
+        nsXPIDLString attributeValue, attributeNamespaceURI, attributeName;
         for (i = 0; i < mNumAttributes; ++i) {
             rv |= aStream->Read32(&number);
             mAttributes[i].mNodeInfo = do_QueryElementAt(aNodeInfos, number);
             if (!mAttributes[i].mNodeInfo)
                 return NS_ERROR_UNEXPECTED;
 
-            rv |= aStream->ReadString(attributeValue);
+            rv |= aStream->ReadWStringZ(getter_Copies(attributeValue));
             mAttributes[i].mValue.SetValue(attributeValue);
         }
 
@@ -5461,7 +5461,9 @@ nsXULPrototypeText::Deserialize(nsIObjectInputStream* aStream,
     nsresult rv;
 
     // Write basic prototype data
-    rv = aStream->ReadString(mValue);
+    PRUnichar* str = nsnull;
+    rv = aStream->ReadWStringZ(&str);
+    mValue.Adopt(str);
     
     return rv;
 }
diff --git a/content/xul/document/src/nsXULPrototypeCache.cpp b/content/xul/document/src/nsXULPrototypeCache.cpp
index 8eeb67ee749..fa78ca52e01 100644
--- a/content/xul/document/src/nsXULPrototypeCache.cpp
+++ b/content/xul/document/src/nsXULPrototypeCache.cpp
@@ -950,8 +950,9 @@ nsXULPrototypeCache::StartFastLoad(nsIURI* aURI)
 #endif
                         rv = NS_ERROR_UNEXPECTED;
                     } else {
-                        nsCAutoString fileChromePath;
-                        rv = objectInput->ReadCString(fileChromePath);
+                        nsXPIDLCString fileChromePath;
+                        rv = objectInput->ReadStringZ(
+                                                 getter_Copies(fileChromePath));
                         if (NS_SUCCEEDED(rv) && 
                             !fileChromePath.Equals(chromePath)) { 
                             rv = NS_ERROR_UNEXPECTED;
diff --git a/content/xul/document/src/nsXULPrototypeDocument.cpp b/content/xul/document/src/nsXULPrototypeDocument.cpp
index 117ebc1ae18..594885a4f99 100644
--- a/content/xul/document/src/nsXULPrototypeDocument.cpp
+++ b/content/xul/document/src/nsXULPrototypeDocument.cpp
@@ -47,7 +47,6 @@
 */
 
 #include "nsCOMPtr.h"
-#include "nsAString.h"
 #include "nsIObjectInputStream.h"
 #include "nsIObjectOutputStream.h"
 #include "nsIPrincipal.h"
@@ -374,10 +373,10 @@ nsXULPrototypeDocument::Read(nsIObjectInputStream* aStream)
     NS_ENSURE_TRUE(nodeInfos, rv);
 
     rv |= aStream->Read32(&referenceCount);
-    nsAutoString namespaceURI, qualifiedName;
+    nsXPIDLString namespaceURI, qualifiedName;
     for (i = 0; i < referenceCount; ++i) {
-        rv |= aStream->ReadString(namespaceURI);
-        rv |= aStream->ReadString(qualifiedName);
+        rv |= aStream->ReadWStringZ(getter_Copies(namespaceURI));
+        rv |= aStream->ReadWStringZ(getter_Copies(qualifiedName));
 
         nsCOMPtr<nsINodeInfo> nodeInfo;
         rv |= mNodeInfoManager->GetNodeInfo(qualifiedName, namespaceURI, *getter_AddRefs(nodeInfo));
diff --git a/netwerk/base/src/nsSimpleURI.cpp b/netwerk/base/src/nsSimpleURI.cpp
index b8623ec02a4..a6c3d37b293 100644
--- a/netwerk/base/src/nsSimpleURI.cpp
+++ b/netwerk/base/src/nsSimpleURI.cpp
@@ -98,11 +98,15 @@ nsSimpleURI::Read(nsIObjectInputStream* aStream)
 {
     nsresult rv;
 
-    rv = aStream->ReadCString(mScheme);
-    if (NS_FAILED(rv)) return rv;
+    nsXPIDLCString buf;
 
-    rv = aStream->ReadCString(mPath);
+    rv = aStream->ReadStringZ(getter_Copies(buf));
     if (NS_FAILED(rv)) return rv;
+    mScheme = buf;
+
+    rv = aStream->ReadStringZ(getter_Copies(buf));
+    if (NS_FAILED(rv)) return rv;
+    mPath = buf;
 
     return NS_OK;
 }
diff --git a/netwerk/base/src/nsStandardURL.cpp b/netwerk/base/src/nsStandardURL.cpp
index 823e9e27af4..80b059a1d3c 100644
--- a/netwerk/base/src/nsStandardURL.cpp
+++ b/netwerk/base/src/nsStandardURL.cpp
@@ -2325,6 +2325,7 @@ NS_IMETHODIMP
 nsStandardURL::Read(nsIObjectInputStream *stream)
 {
     nsresult rv;
+    nsXPIDLCString buf;
     
     rv = stream->Read32(&mURLType);
     if (NS_FAILED(rv)) return rv;
@@ -2349,8 +2350,9 @@ nsStandardURL::Read(nsIObjectInputStream *stream)
     rv = stream->Read32((PRUint32 *) &mDefaultPort);
     if (NS_FAILED(rv)) return rv;
 
-    rv = NS_ReadOptionalCString(stream, mSpec);
+    rv = NS_ReadOptionalStringZ(stream, getter_Copies(buf));
     if (NS_FAILED(rv)) return rv;
+    mSpec = buf;
 
     rv = ReadSegment(stream, mScheme);
     if (NS_FAILED(rv)) return rv;
@@ -2391,8 +2393,9 @@ nsStandardURL::Read(nsIObjectInputStream *stream)
     rv = ReadSegment(stream, mRef);
     if (NS_FAILED(rv)) return rv;
 
-    rv = NS_ReadOptionalCString(stream, mOriginCharset);
+    rv = NS_ReadOptionalStringZ(stream, getter_Copies(buf));
     if (NS_FAILED(rv)) return rv;
+    mOriginCharset = buf;
 
     return NS_OK;
 }
diff --git a/xpcom/ds/nsHashtable.cpp b/xpcom/ds/nsHashtable.cpp
index cb35abdad1b..abf46736487 100644
--- a/xpcom/ds/nsHashtable.cpp
+++ b/xpcom/ds/nsHashtable.cpp
@@ -639,11 +639,9 @@ nsCStringKey::Clone() const
 nsCStringKey::nsCStringKey(nsIObjectInputStream* aStream, nsresult *aResult)
     : mStr(nsnull), mStrLen(0), mOwnership(OWN)
 {
-    nsCAutoString str;
-    nsresult rv = aStream->ReadCString(str);
-    mStr = ToNewCString(str);
+    nsresult rv = aStream->ReadStringZ(&mStr);
     if (NS_SUCCEEDED(rv))
-        mStrLen = str.Length();
+        mStrLen = strlen(mStr);
     *aResult = rv;
     MOZ_COUNT_CTOR(nsCStringKey);
 }
@@ -761,11 +759,9 @@ nsStringKey::Clone() const
 nsStringKey::nsStringKey(nsIObjectInputStream* aStream, nsresult *aResult)
     : mStr(nsnull), mStrLen(0), mOwnership(OWN)
 {
-    nsAutoString str;
-    nsresult rv = aStream->ReadString(str);
-    mStr = ToNewUnicode(str);
+    nsresult rv = aStream->ReadWStringZ(&mStr);
     if (NS_SUCCEEDED(rv))
-        mStrLen = str.Length();
+        mStrLen = nsCRT::strlen(mStr);
     *aResult = rv;
     MOZ_COUNT_CTOR(nsStringKey);
 }
diff --git a/xpcom/ds/nsSupportsArray.cpp b/xpcom/ds/nsSupportsArray.cpp
index 8f10e700123..a3f52fb52f0 100644
--- a/xpcom/ds/nsSupportsArray.cpp
+++ b/xpcom/ds/nsSupportsArray.cpp
@@ -40,7 +40,6 @@
 #include <string.h>
 #include "nsSupportsArray.h"
 #include "nsSupportsArrayEnumerator.h"
-#include "nsAString.h"
 #include "nsIObjectInputStream.h"
 #include "nsIObjectOutputStream.h"
 #include <string.h>
diff --git a/xpcom/io/nsBinaryStream.cpp b/xpcom/io/nsBinaryStream.cpp
index 565abcbad7b..d463bd0cba1 100644
--- a/xpcom/io/nsBinaryStream.cpp
+++ b/xpcom/io/nsBinaryStream.cpp
@@ -291,43 +291,11 @@ nsBinaryInputStream::Read(char* aBuffer, PRUint32 aCount, PRUint32 *aNumRead)
     return mInputStream->Read(aBuffer, aCount, aNumRead);
 }
 
-
-// when forwarding ReadSegments to mInputStream, we need to make sure
-// 'this' is being passed to the writer each time. To do this, we need
-// a thunking function which keeps the real input stream around.
-
-// the closure wrapper
-struct ReadSegmentsClosure {
-    nsIInputStream* mRealInputStream;
-    void* mRealClosure;
-    nsWriteSegmentFun mRealWriter;
-};
-
-// the thunking function
-static NS_METHOD
-ReadSegmentForwardingThunk(nsIInputStream* aStream,
-                           void *aClosure,
-                           const char* aFromSegment,
-                           PRUint32 aToOffset,
-                           PRUint32 aCount,
-                           PRUint32 *aWriteCount)
-{
-    ReadSegmentsClosure* thunkClosure =
-        NS_REINTERPRET_CAST(ReadSegmentsClosure*, aClosure);
-
-    return thunkClosure->mRealWriter(thunkClosure->mRealInputStream,
-                                     thunkClosure->mRealClosure,
-                                     aFromSegment, aToOffset,
-                                     aCount, aWriteCount);
-}
-
-
 NS_IMETHODIMP
 nsBinaryInputStream::ReadSegments(nsWriteSegmentFun writer, void * closure, PRUint32 count, PRUint32 *_retval)
 {
-    ReadSegmentsClosure thunkClosure = { this, closure, writer };
-    
-    return mInputStream->ReadSegments(ReadSegmentForwardingThunk, &thunkClosure, count, _retval);
+    NS_NOTREACHED("ReadSegments");
+    return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
@@ -427,86 +395,70 @@ nsBinaryInputStream::ReadDouble(double* aDouble)
     return Read64(NS_REINTERPRET_CAST(PRUint64*, aDouble));
 }
 
-static NS_METHOD
-WriteSegmentToCString(nsIInputStream* aStream,
-                      void *aClosure,
-                      const char* aFromSegment,
-                      PRUint32 aToOffset,
-                      PRUint32 aCount,
-                      PRUint32 *aWriteCount)
-{
-    nsACString* outString = NS_STATIC_CAST(nsACString*,aClosure);
-
-    outString->Append(aFromSegment, aCount);
-
-    *aWriteCount = aCount;
-    
-    return NS_OK;
-}
-
 NS_IMETHODIMP
-nsBinaryInputStream::ReadCString(nsACString& aString)
+nsBinaryInputStream::ReadStringZ(char* *aString)
 {
     nsresult rv;
     PRUint32 length, bytesRead;
+    char *s;
 
     rv = Read32(&length);
     if (NS_FAILED(rv)) return rv;
 
-    aString.Truncate();
-    rv = ReadSegments(WriteSegmentToCString, &aString, length, &bytesRead);
-    if (NS_FAILED(rv)) return rv;
-    
-    if (bytesRead != length)
-        return NS_ERROR_FAILURE;
+    s = NS_REINTERPRET_CAST(char*, nsMemory::Alloc(length + 1));
+    if (!s)
+        return NS_ERROR_OUT_OF_MEMORY;
 
+    rv = Read(s, length, &bytesRead);
+    if (NS_FAILED(rv)) return rv;
+    if (bytesRead != length) {
+        nsMemory::Free(s);
+        return NS_ERROR_FAILURE;
+    }
+
+    s[length] = '\0';
+    *aString = s;
     return NS_OK;
 }
 
-// same version of the above, but with correct casting and endian swapping
-static NS_METHOD
-WriteSegmentToString(nsIInputStream* aStream,
-                     void *aClosure,
-                     const char* aFromSegment,
-                     PRUint32 aToOffset,
-                     PRUint32 aCount,
-                     PRUint32 *aWriteCount)
+NS_IMETHODIMP
+nsBinaryInputStream::ReadWStringZ(PRUnichar* *aString)
 {
-    nsAString* outString = NS_STATIC_CAST(nsAString*,aClosure);
-    const PRUnichar *unicodeSegment =
-        NS_REINTERPRET_CAST(const PRUnichar*, aFromSegment);
-    PRUint32 segmentLength = aCount / sizeof(PRUnichar);
+    nsresult rv;
+    PRUint32 length, byteCount, bytesRead;
+    PRUnichar *ws;
+
+    rv = Read32(&length);
+    if (NS_FAILED(rv)) return rv;
+ 
+    byteCount = length * sizeof(PRUnichar);
+    ws = NS_REINTERPRET_CAST(PRUnichar*,
+                             nsMemory::Alloc(byteCount + sizeof(PRUnichar)));
+    if (!ws)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    rv = Read(NS_REINTERPRET_CAST(char*, ws), byteCount, &bytesRead);
+    if (NS_FAILED(rv)) return rv;
+    if (bytesRead != byteCount) {
+        nsMemory::Free(ws);
+        return NS_ERROR_FAILURE;
+    }
 
-    // this sucks. we have to swap every 2 bytes on some machines
 #ifdef IS_LITTLE_ENDIAN
-    for (PRUint32 i = 0; i < segmentLength; i++)
-        outString->Append(PRUnichar(NS_SWAP16(unicodeSegment[i])));
-#else    
-    outString->Append(unicodeSegment, segmentLength);
+    for (PRUint32 i = 0; i < length; i++)
+        ws[i] = NS_SWAP16(ws[i]);
 #endif
 
-    *aWriteCount = aCount;
+    ws[length] = 0;
+    *aString = ws;
     return NS_OK;
 }
 
-
 NS_IMETHODIMP
-nsBinaryInputStream::ReadString(nsAString& aString)
+nsBinaryInputStream::ReadUtf8Z(PRUnichar* *aString)
 {
-    nsresult rv;
-    PRUint32 length, bytesRead;
-
-    rv = Read32(&length);
-    if (NS_FAILED(rv)) return rv;
-
-    aString.Truncate();
-    rv = ReadSegments(WriteSegmentToString, &aString, length, &bytesRead);
-    if (NS_FAILED(rv)) return rv;
-    
-    if (bytesRead != length)
-        return NS_ERROR_FAILURE;
-
-    return NS_OK;
+    NS_NOTREACHED("ReadUtf8Z");
+    return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
@@ -560,3 +512,26 @@ nsBinaryInputStream::PutBuffer(char* aBuffer, PRUint32 aLength)
         mBufferAccess->PutBuffer(aBuffer, aLength);
 }
 
+NS_COM nsresult
+NS_NewBinaryOutputStream(nsIBinaryOutputStream* *aResult, nsIOutputStream* aDestStream)
+{
+    NS_ENSURE_ARG_POINTER(aResult);
+    nsIBinaryOutputStream *stream = new nsBinaryOutputStream(aDestStream);
+    if (!stream)
+        return NS_ERROR_OUT_OF_MEMORY;
+    NS_ADDREF(stream);
+    *aResult = stream;
+    return NS_OK;
+}
+
+NS_COM nsresult
+NS_NewBinaryInputStream(nsIBinaryInputStream* *aResult, nsIInputStream* aSrcStream)
+{
+    NS_ENSURE_ARG_POINTER(aResult);
+    nsIBinaryInputStream *stream = new nsBinaryInputStream(aSrcStream);
+    if (!stream)
+        return NS_ERROR_OUT_OF_MEMORY;
+    NS_ADDREF(stream);
+    *aResult = stream;
+    return NS_OK;
+}
diff --git a/xpcom/io/nsBinaryStream.h b/xpcom/io/nsBinaryStream.h
index 107ae922d60..33d53cb6127 100644
--- a/xpcom/io/nsBinaryStream.h
+++ b/xpcom/io/nsBinaryStream.h
@@ -23,7 +23,6 @@
 #define nsBinaryStream_h___
 
 #include "nsCOMPtr.h"
-#include "nsAString.h"
 #include "nsIObjectInputStream.h"
 #include "nsIObjectOutputStream.h"
 #include "nsIStreamBufferAccess.h"
diff --git a/xpcom/io/nsFastLoadFile.cpp b/xpcom/io/nsFastLoadFile.cpp
index 247f1dc603e..b7f1253ea7a 100644
--- a/xpcom/io/nsFastLoadFile.cpp
+++ b/xpcom/io/nsFastLoadFile.cpp
@@ -743,9 +743,9 @@ nsFastLoadFileReader::ReadFooter(nsFastLoadFooter *aFooter)
     if (NS_FAILED(rv))
         return rv;
 
-    nsCAutoString filename;
     for (i = 0, n = aFooter->mNumDependencies; i < n; i++) {
-        rv = ReadCString(filename);
+        nsXPIDLCString filename;
+        rv = ReadStringZ(getter_Copies(filename));
         if (NS_FAILED(rv))
             return rv;
 
@@ -868,16 +868,18 @@ nsFastLoadFileReader::ReadMuxedDocumentInfo(nsFastLoadMuxedDocumentInfo *aInfo)
 {
     nsresult rv;
 
-    nsCAutoString spec;
-    rv = ReadCString(spec);
+    char *spec;
+    rv = ReadStringZ(&spec);
     if (NS_FAILED(rv))
         return rv;
 
     rv = Read32(&aInfo->mInitialSegmentOffset);
-    if (NS_FAILED(rv))
+    if (NS_FAILED(rv)) {
+        nsMemory::Free((void*) spec);
         return rv;
+    }
 
-    aInfo->mURISpec = ToNewCString(spec);
+    aInfo->mURISpec = spec;
     return NS_OK;
 }
 
diff --git a/xpcom/io/nsIBinaryInputStream.idl b/xpcom/io/nsIBinaryInputStream.idl
index 35e3569a5cf..56a4d604d0d 100644
--- a/xpcom/io/nsIBinaryInputStream.idl
+++ b/xpcom/io/nsIBinaryInputStream.idl
@@ -50,12 +50,18 @@ interface nsIBinaryInputStream : nsIInputStream {
     /**
      * Read a NUL-terminated 8-bit char* string from a binary stream.
      */
-    ACString readCString();
+    string readStringZ();
 
     /**
      * Read a NUL-terminated 16-bit PRUnichar* string from a binary stream.
      */
-    AString readString();
+    wstring readWStringZ();
+
+    /**
+     * Read a NUL-terminated UTF8-encoded string from a binary stream, producing
+     * a NUL-terminated 16-bit PRUnichar* string argument as a result.
+     */
+    wstring readUtf8Z();
 
     /**
      * Read an opaque byte array from a binary stream.
@@ -69,29 +75,29 @@ NS_COM nsresult
 NS_NewBinaryInputStream(nsIBinaryInputStream* *aResult, nsIInputStream* aSrcStream);
 
 inline nsresult
-NS_ReadOptionalCString(nsIBinaryInputStream* aStream, nsACString& aResult)
+NS_ReadOptionalStringZ(nsIBinaryInputStream* aStream, char* *aResult)
 {
     PRBool nonnull;
     nsresult rv = aStream->ReadBoolean(&nonnull);
     if (NS_SUCCEEDED(rv)) {
         if (nonnull)
-            rv = aStream->ReadCString(aResult);
+            rv = aStream->ReadStringZ(aResult);
         else
-            aResult.Truncate();
+            *aResult = nsnull;
     }
     return rv;
 }
 
 inline nsresult
-NS_ReadOptionalString(nsIBinaryInputStream* aStream, nsAString& aResult)
+NS_ReadOptionalWStringZ(nsIBinaryInputStream* aStream, PRUnichar* *aResult)
 {
     PRBool nonnull;
     nsresult rv = aStream->ReadBoolean(&nonnull);
     if (NS_SUCCEEDED(rv)) {
         if (nonnull)
-            rv = aStream->ReadString(aResult);
+            rv = aStream->ReadWStringZ(aResult);
         else
-            aResult.Truncate();
+            *aResult = nsnull;
     }
     return rv;
 }