mozilla
/
pjs
зеркало из https://github.com/mozilla/pjs.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

argh, back out my last checkin because Ts went UP not down!

This commit is contained in:
alecf%netscape.com 2002-11-09 01:31:32 +00:00
Родитель d281d67805
Коммит 50a35c0245
16 изменённых файлов: 156 добавлений и 157 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
caps/include/nsBasePrincipal.h
Просмотреть файл

@ -86,7 +86,7 @@ protected:
nsJSPrincipals mJSPrincipals;
nsVoidArray mAnnotations;
nsHashtable *mCapabilities;
nsCString mPrefName;
char *mPrefName;
static int mCapabilitiesOrdinal;
};

4
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_

14
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;

37
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);
}

10
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);

8
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;
}

5
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;

7
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));

10
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;
}

7
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;
}

12
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);
}

1
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>

159
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;
}

1
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"

14
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;
}

22
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;
}