corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 931571, part 9 - Turn most of the nsVariant setters into nsDiscriminated methods. r=froydnj

Browse Source 
This also adds a new nsDiscriminatedUnion method SetFromDOMString, as somebody added an nsVariant method without the corresponding helper.
This commit is contained in:
Andrew McCreight
2015-07-23 12:28:30 -07:00
parent db5382cb28
commit 675f9543a5
3 changed files with 217 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
js/xpconnect/src/XPCVariant.cpp
View File

@@ -259,16 +259,16 @@ bool XPCVariant::InitializeData(JSContext* cx)
RootedValue val(cx, GetJSVal()); RootedValue val(cx, GetJSVal());
if (val.isInt32()) if (val.isInt32())
return NS_SUCCEEDED(nsVariant::SetFromInt32(&mData, val.toInt32())); return NS_SUCCEEDED(mData.SetFromInt32(val.toInt32()));
if (val.isDouble()) if (val.isDouble())
return NS_SUCCEEDED(nsVariant::SetFromDouble(&mData, val.toDouble())); return NS_SUCCEEDED(mData.SetFromDouble(val.toDouble()));
if (val.isBoolean()) if (val.isBoolean())
return NS_SUCCEEDED(nsVariant::SetFromBool(&mData, val.toBoolean())); return NS_SUCCEEDED(mData.SetFromBool(val.toBoolean()));
// We can't represent symbol on C++ side, so pretend it is void. // We can't represent symbol on C++ side, so pretend it is void.
if (val.isUndefined() || val.isSymbol()) if (val.isUndefined() || val.isSymbol())
return NS_SUCCEEDED(nsVariant::SetToVoid(&mData)); return NS_SUCCEEDED(mData.SetToVoid());
if (val.isNull()) if (val.isNull())
return NS_SUCCEEDED(nsVariant::SetToEmpty(&mData)); return NS_SUCCEEDED(mData.SetToEmpty());
if (val.isString()) { if (val.isString()) {
JSString* str = val.toString(); JSString* str = val.toString();
if (!str) if (!str)
@@ -278,7 +278,7 @@ bool XPCVariant::InitializeData(JSContext* cx)
"Why do we already have data?"); "Why do we already have data?");
size_t length = JS_GetStringLength(str); size_t length = JS_GetStringLength(str);
if (!NS_SUCCEEDED(nsVariant::AllocateWStringWithSize(&mData, length))) if (!NS_SUCCEEDED(mData.AllocateWStringWithSize(length)))
return false; return false;
mozilla::Range<char16_t> destChars(mData.u.wstr.mWStringValue, length); mozilla::Range<char16_t> destChars(mData.u.wstr.mWStringValue, length);
@@ -298,7 +298,7 @@ bool XPCVariant::InitializeData(JSContext* cx)
const nsID* id = xpc_JSObjectToID(cx, jsobj); const nsID* id = xpc_JSObjectToID(cx, jsobj);
if (id) if (id)
return NS_SUCCEEDED(nsVariant::SetFromID(&mData, *id)); return NS_SUCCEEDED(mData.SetFromID(*id));
// Let's see if it is a js array object. // Let's see if it is a js array object.
@@ -307,7 +307,7 @@ bool XPCVariant::InitializeData(JSContext* cx)
if (JS_IsArrayObject(cx, jsobj) && JS_GetArrayLength(cx, jsobj, &len)) { if (JS_IsArrayObject(cx, jsobj) && JS_GetArrayLength(cx, jsobj, &len)) {
if (!len) { if (!len) {
// Zero length array // Zero length array
nsVariant::SetToEmptyArray(&mData); mData.SetToEmptyArray();
return true; return true;
} }
@@ -338,7 +338,7 @@ bool XPCVariant::InitializeData(JSContext* cx)
return NS_SUCCEEDED(xpc->WrapJS(cx, jsobj, return NS_SUCCEEDED(xpc->WrapJS(cx, jsobj,
iid, getter_AddRefs(wrapper))) && iid, getter_AddRefs(wrapper))) &&
NS_SUCCEEDED(nsVariant::SetFromInterface(&mData, iid, wrapper)); NS_SUCCEEDED(mData.SetFromInterface(iid, wrapper));
} }
NS_IMETHODIMP NS_IMETHODIMP

343
xpcom/ds/nsVariant.cpp
View File

@@ -1196,22 +1196,22 @@ nsDiscriminatedUnion::ConvertToArray(uint16_t* aType, nsIID* aIID,
/***************************************************************************/ /***************************************************************************/
// static setter functions... // static setter functions...
#define DATA_SETTER_PROLOGUE(data_) \ #define DATA_SETTER_PROLOGUE \
data_->Cleanup(); Cleanup()
#define DATA_SETTER_EPILOGUE(data_, type_) \ #define DATA_SETTER_EPILOGUE(type_) \
data_->mType = nsIDataType :: type_; \ mType = nsIDataType :: type_; \
return NS_OK; return NS_OK
#define DATA_SETTER(data_, type_, member_, value_) \ #define DATA_SETTER(type_, member_, value_) \
DATA_SETTER_PROLOGUE(data_) \ DATA_SETTER_PROLOGUE; \
data_->u.member_ = value_; \ u.member_ = value_; \
DATA_SETTER_EPILOGUE(data_, type_) DATA_SETTER_EPILOGUE(type_)
#define DATA_SETTER_WITH_CAST(data_, type_, member_, cast_, value_) \ #define DATA_SETTER_WITH_CAST(type_, member_, cast_, value_) \
DATA_SETTER_PROLOGUE(data_) \ DATA_SETTER_PROLOGUE; \
data_->u.member_ = cast_ value_; \ u.member_ = cast_ value_; \
DATA_SETTER_EPILOGUE(data_, type_) DATA_SETTER_EPILOGUE(type_)
/********************************************/ /********************************************/
@@ -1340,13 +1340,13 @@ nsVariant::SetFromVariant(nsDiscriminatedUnion* aData, nsIVariant* aValue)
CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(VTYPE_ARRAY) CASE__SET_FROM_VARIANT_VTYPE_EPILOGUE(VTYPE_ARRAY)
case nsIDataType::VTYPE_VOID: case nsIDataType::VTYPE_VOID:
rv = nsVariant::SetToVoid(aData); rv = aData->SetToVoid();
break; break;
case nsIDataType::VTYPE_EMPTY_ARRAY: case nsIDataType::VTYPE_EMPTY_ARRAY:
rv = nsVariant::SetToEmptyArray(aData); rv = aData->SetToEmptyArray();
break; break;
case nsIDataType::VTYPE_EMPTY: case nsIDataType::VTYPE_EMPTY:
rv = nsVariant::SetToEmpty(aData); rv = aData->SetToEmpty();
break; break;
default: default:
NS_ERROR("bad type in variant!"); NS_ERROR("bad type in variant!");
@@ -1356,219 +1356,226 @@ nsVariant::SetFromVariant(nsDiscriminatedUnion* aData, nsIVariant* aValue)
return rv; return rv;
} }
/* static */ nsresult nsresult
nsVariant::SetFromInt8(nsDiscriminatedUnion* aData, uint8_t aValue) nsDiscriminatedUnion::SetFromInt8(uint8_t aValue)
{ {
DATA_SETTER_WITH_CAST(aData, VTYPE_INT8, mInt8Value, (uint8_t), aValue) DATA_SETTER_WITH_CAST(VTYPE_INT8, mInt8Value, (uint8_t), aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromInt16(nsDiscriminatedUnion* aData, int16_t aValue) nsDiscriminatedUnion::SetFromInt16(int16_t aValue)
{ {
DATA_SETTER(aData, VTYPE_INT16, mInt16Value, aValue) DATA_SETTER(VTYPE_INT16, mInt16Value, aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromInt32(nsDiscriminatedUnion* aData, int32_t aValue) nsDiscriminatedUnion::SetFromInt32(int32_t aValue)
{ {
DATA_SETTER(aData, VTYPE_INT32, mInt32Value, aValue) DATA_SETTER(VTYPE_INT32, mInt32Value, aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromInt64(nsDiscriminatedUnion* aData, int64_t aValue) nsDiscriminatedUnion::SetFromInt64(int64_t aValue)
{ {
DATA_SETTER(aData, VTYPE_INT64, mInt64Value, aValue) DATA_SETTER(VTYPE_INT64, mInt64Value, aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromUint8(nsDiscriminatedUnion* aData, uint8_t aValue) nsDiscriminatedUnion::SetFromUint8(uint8_t aValue)
{ {
DATA_SETTER(aData, VTYPE_UINT8, mUint8Value, aValue) DATA_SETTER(VTYPE_UINT8, mUint8Value, aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromUint16(nsDiscriminatedUnion* aData, uint16_t aValue) nsDiscriminatedUnion::SetFromUint16(uint16_t aValue)
{ {
DATA_SETTER(aData, VTYPE_UINT16, mUint16Value, aValue) DATA_SETTER(VTYPE_UINT16, mUint16Value, aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromUint32(nsDiscriminatedUnion* aData, uint32_t aValue) nsDiscriminatedUnion::SetFromUint32(uint32_t aValue)
{ {
DATA_SETTER(aData, VTYPE_UINT32, mUint32Value, aValue) DATA_SETTER(VTYPE_UINT32, mUint32Value, aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromUint64(nsDiscriminatedUnion* aData, uint64_t aValue) nsDiscriminatedUnion::SetFromUint64(uint64_t aValue)
{ {
DATA_SETTER(aData, VTYPE_UINT64, mUint64Value, aValue) DATA_SETTER(VTYPE_UINT64, mUint64Value, aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromFloat(nsDiscriminatedUnion* aData, float aValue) nsDiscriminatedUnion::SetFromFloat(float aValue)
{ {
DATA_SETTER(aData, VTYPE_FLOAT, mFloatValue, aValue) DATA_SETTER(VTYPE_FLOAT, mFloatValue, aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromDouble(nsDiscriminatedUnion* aData, double aValue) nsDiscriminatedUnion::SetFromDouble(double aValue)
{ {
DATA_SETTER(aData, VTYPE_DOUBLE, mDoubleValue, aValue) DATA_SETTER(VTYPE_DOUBLE, mDoubleValue, aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromBool(nsDiscriminatedUnion* aData, bool aValue) nsDiscriminatedUnion::SetFromBool(bool aValue)
{ {
DATA_SETTER(aData, VTYPE_BOOL, mBoolValue, aValue) DATA_SETTER(VTYPE_BOOL, mBoolValue, aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromChar(nsDiscriminatedUnion* aData, char aValue) nsDiscriminatedUnion::SetFromChar(char aValue)
{ {
DATA_SETTER(aData, VTYPE_CHAR, mCharValue, aValue) DATA_SETTER(VTYPE_CHAR, mCharValue, aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromWChar(nsDiscriminatedUnion* aData, char16_t aValue) nsDiscriminatedUnion::SetFromWChar(char16_t aValue)
{ {
DATA_SETTER(aData, VTYPE_WCHAR, mWCharValue, aValue) DATA_SETTER(VTYPE_WCHAR, mWCharValue, aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromID(nsDiscriminatedUnion* aData, const nsID& aValue) nsDiscriminatedUnion::SetFromID(const nsID& aValue)
{ {
DATA_SETTER(aData, VTYPE_ID, mIDValue, aValue) DATA_SETTER(VTYPE_ID, mIDValue, aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromAString(nsDiscriminatedUnion* aData, const nsAString& aValue) nsDiscriminatedUnion::SetFromAString(const nsAString& aValue)
{ {
DATA_SETTER_PROLOGUE(aData); DATA_SETTER_PROLOGUE;
if (!(aData->u.mAStringValue = new nsString(aValue))) { if (!(u.mAStringValue = new nsString(aValue))) {
return NS_ERROR_OUT_OF_MEMORY; return NS_ERROR_OUT_OF_MEMORY;
} }
DATA_SETTER_EPILOGUE(aData, VTYPE_ASTRING); DATA_SETTER_EPILOGUE(VTYPE_ASTRING);
} }
/* static */ nsresult nsresult
nsVariant::SetFromACString(nsDiscriminatedUnion* aData, nsDiscriminatedUnion::SetFromDOMString(const nsAString& aValue)
const nsACString& aValue)
{ {
DATA_SETTER_PROLOGUE(aData); DATA_SETTER_PROLOGUE;
if (!(aData->u.mCStringValue = new nsCString(aValue))) { if (!(u.mAStringValue = new nsString(aValue))) {
return NS_ERROR_OUT_OF_MEMORY; return NS_ERROR_OUT_OF_MEMORY;
} }
DATA_SETTER_EPILOGUE(aData, VTYPE_CSTRING); DATA_SETTER_EPILOGUE(VTYPE_DOMSTRING);
} }
/* static */ nsresult nsresult
nsVariant::SetFromAUTF8String(nsDiscriminatedUnion* aData, nsDiscriminatedUnion::SetFromACString(const nsACString& aValue)
const nsAUTF8String& aValue)
{ {
DATA_SETTER_PROLOGUE(aData); DATA_SETTER_PROLOGUE;
if (!(aData->u.mUTF8StringValue = new nsUTF8String(aValue))) { if (!(u.mCStringValue = new nsCString(aValue))) {
return NS_ERROR_OUT_OF_MEMORY; return NS_ERROR_OUT_OF_MEMORY;
} }
DATA_SETTER_EPILOGUE(aData, VTYPE_UTF8STRING); DATA_SETTER_EPILOGUE(VTYPE_CSTRING);
} }
/* static */ nsresult nsresult
nsVariant::SetFromString(nsDiscriminatedUnion* aData, const char* aValue) nsDiscriminatedUnion::SetFromAUTF8String(const nsAUTF8String& aValue)
{ {
DATA_SETTER_PROLOGUE(aData); DATA_SETTER_PROLOGUE;
if (!(u.mUTF8StringValue = new nsUTF8String(aValue))) {
return NS_ERROR_OUT_OF_MEMORY;
}
DATA_SETTER_EPILOGUE(VTYPE_UTF8STRING);
}
nsresult
nsDiscriminatedUnion::SetFromString(const char* aValue)
{
DATA_SETTER_PROLOGUE;
if (!aValue) { if (!aValue) {
return NS_ERROR_NULL_POINTER; return NS_ERROR_NULL_POINTER;
} }
return SetFromStringWithSize(aData, strlen(aValue), aValue); return SetFromStringWithSize(strlen(aValue), aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromWString(nsDiscriminatedUnion* aData, const char16_t* aValue) nsDiscriminatedUnion::SetFromWString(const char16_t* aValue)
{ {
DATA_SETTER_PROLOGUE(aData); DATA_SETTER_PROLOGUE;
if (!aValue) { if (!aValue) {
return NS_ERROR_NULL_POINTER; return NS_ERROR_NULL_POINTER;
} }
return SetFromWStringWithSize(aData, NS_strlen(aValue), aValue); return SetFromWStringWithSize(NS_strlen(aValue), aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromISupports(nsDiscriminatedUnion* aData, nsISupports* aValue) nsDiscriminatedUnion::SetFromISupports(nsISupports* aValue)
{ {
return SetFromInterface(aData, NS_GET_IID(nsISupports), aValue); return SetFromInterface(NS_GET_IID(nsISupports), aValue);
} }
/* static */ nsresult nsresult
nsVariant::SetFromInterface(nsDiscriminatedUnion* aData, const nsIID& aIID, nsDiscriminatedUnion::SetFromInterface(const nsIID& aIID, nsISupports* aValue)
nsISupports* aValue)
{ {
DATA_SETTER_PROLOGUE(aData); DATA_SETTER_PROLOGUE;
NS_IF_ADDREF(aValue); NS_IF_ADDREF(aValue);
aData->u.iface.mInterfaceValue = aValue; u.iface.mInterfaceValue = aValue;
aData->u.iface.mInterfaceID = aIID; u.iface.mInterfaceID = aIID;
DATA_SETTER_EPILOGUE(aData, VTYPE_INTERFACE_IS); DATA_SETTER_EPILOGUE(VTYPE_INTERFACE_IS);
} }
/* static */ nsresult nsresult
nsVariant::SetFromArray(nsDiscriminatedUnion* aData, uint16_t aType, nsDiscriminatedUnion::SetFromArray(uint16_t aType, const nsIID* aIID,
const nsIID* aIID, uint32_t aCount, void* aValue) uint32_t aCount, void* aValue)
{ {
DATA_SETTER_PROLOGUE(aData); DATA_SETTER_PROLOGUE;
if (!aValue || !aCount) { if (!aValue || !aCount) {
return NS_ERROR_NULL_POINTER; return NS_ERROR_NULL_POINTER;
} }
nsresult rv = CloneArray(aType, aIID, aCount, aValue, nsresult rv = CloneArray(aType, aIID, aCount, aValue,
&aData->u.array.mArrayType, &u.array.mArrayType,
&aData->u.array.mArrayInterfaceID, &u.array.mArrayInterfaceID,
&aData->u.array.mArrayCount, &u.array.mArrayCount,
&aData->u.array.mArrayValue); &u.array.mArrayValue);
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
return rv; return rv;
} }
DATA_SETTER_EPILOGUE(aData, VTYPE_ARRAY); DATA_SETTER_EPILOGUE(VTYPE_ARRAY);
} }
/* static */ nsresult nsresult
nsVariant::SetFromStringWithSize(nsDiscriminatedUnion* aData, uint32_t aSize, nsDiscriminatedUnion::SetFromStringWithSize(uint32_t aSize,
const char* aValue) const char* aValue)
{ {
DATA_SETTER_PROLOGUE(aData); DATA_SETTER_PROLOGUE;
if (!aValue) { if (!aValue) {
return NS_ERROR_NULL_POINTER; return NS_ERROR_NULL_POINTER;
} }
if (!(aData->u.str.mStringValue = if (!(u.str.mStringValue =
(char*)nsMemory::Clone(aValue, (aSize + 1) * sizeof(char)))) { (char*)nsMemory::Clone(aValue, (aSize + 1) * sizeof(char)))) {
return NS_ERROR_OUT_OF_MEMORY; return NS_ERROR_OUT_OF_MEMORY;
} }
aData->u.str.mStringLength = aSize; u.str.mStringLength = aSize;
DATA_SETTER_EPILOGUE(aData, VTYPE_STRING_SIZE_IS); DATA_SETTER_EPILOGUE(VTYPE_STRING_SIZE_IS);
} }
/* static */ nsresult nsresult
nsVariant::SetFromWStringWithSize(nsDiscriminatedUnion* aData, uint32_t aSize, nsDiscriminatedUnion::SetFromWStringWithSize(uint32_t aSize,
const char16_t* aValue) const char16_t* aValue)
{ {
DATA_SETTER_PROLOGUE(aData); DATA_SETTER_PROLOGUE;
if (!aValue) { if (!aValue) {
return NS_ERROR_NULL_POINTER; return NS_ERROR_NULL_POINTER;
} }
if (!(aData->u.wstr.mWStringValue = if (!(u.wstr.mWStringValue =
(char16_t*)nsMemory::Clone(aValue, (aSize + 1) * sizeof(char16_t)))) { (char16_t*)nsMemory::Clone(aValue, (aSize + 1) * sizeof(char16_t)))) {
return NS_ERROR_OUT_OF_MEMORY; return NS_ERROR_OUT_OF_MEMORY;
} }
aData->u.wstr.mWStringLength = aSize; u.wstr.mWStringLength = aSize;
DATA_SETTER_EPILOGUE(aData, VTYPE_WSTRING_SIZE_IS); DATA_SETTER_EPILOGUE(VTYPE_WSTRING_SIZE_IS);
} }
/* static */ nsresult nsresult
nsVariant::AllocateWStringWithSize(nsDiscriminatedUnion* aData, uint32_t aSize) nsDiscriminatedUnion::AllocateWStringWithSize(uint32_t aSize)
{ {
DATA_SETTER_PROLOGUE(aData); DATA_SETTER_PROLOGUE;
if (!(aData->u.wstr.mWStringValue = if (!(u.wstr.mWStringValue =
(char16_t*)moz_xmalloc((aSize + 1) * sizeof(char16_t)))) { (char16_t*)moz_xmalloc((aSize + 1) * sizeof(char16_t)))) {
return NS_ERROR_OUT_OF_MEMORY; return NS_ERROR_OUT_OF_MEMORY;
} }
aData->u.wstr.mWStringValue[aSize] = '\0'; u.wstr.mWStringValue[aSize] = '\0';
aData->u.wstr.mWStringLength = aSize; u.wstr.mWStringLength = aSize;
DATA_SETTER_EPILOGUE(aData, VTYPE_WSTRING_SIZE_IS); DATA_SETTER_EPILOGUE(VTYPE_WSTRING_SIZE_IS);
} }
/* static */ nsresult nsresult
nsVariant::SetToVoid(nsDiscriminatedUnion* aData) nsDiscriminatedUnion::SetToVoid()
{ {
DATA_SETTER_PROLOGUE(aData); DATA_SETTER_PROLOGUE;
DATA_SETTER_EPILOGUE(aData, VTYPE_VOID); DATA_SETTER_EPILOGUE(VTYPE_VOID);
} }
/* static */ nsresult nsresult
nsVariant::SetToEmpty(nsDiscriminatedUnion* aData) nsDiscriminatedUnion::SetToEmpty()
{ {
DATA_SETTER_PROLOGUE(aData); DATA_SETTER_PROLOGUE;
DATA_SETTER_EPILOGUE(aData, VTYPE_EMPTY); DATA_SETTER_EPILOGUE(VTYPE_EMPTY);
} }
/* static */ nsresult nsresult
nsVariant::SetToEmptyArray(nsDiscriminatedUnion* aData) nsDiscriminatedUnion::SetToEmptyArray()
{ {
DATA_SETTER_PROLOGUE(aData); DATA_SETTER_PROLOGUE;
DATA_SETTER_EPILOGUE(aData, VTYPE_EMPTY_ARRAY); DATA_SETTER_EPILOGUE(VTYPE_EMPTY_ARRAY);
} }
/***************************************************************************/ /***************************************************************************/
@@ -1948,7 +1955,7 @@ nsVariant::SetAsInt8(uint8_t aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromInt8(&mData, aValue); return mData.SetFromInt8(aValue);
} }
/* void setAsInt16 (in int16_t aValue); */ /* void setAsInt16 (in int16_t aValue); */
@@ -1958,7 +1965,7 @@ nsVariant::SetAsInt16(int16_t aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromInt16(&mData, aValue); return mData.SetFromInt16(aValue);
} }
/* void setAsInt32 (in int32_t aValue); */ /* void setAsInt32 (in int32_t aValue); */
@@ -1968,7 +1975,7 @@ nsVariant::SetAsInt32(int32_t aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromInt32(&mData, aValue); return mData.SetFromInt32(aValue);
} }
/* void setAsInt64 (in int64_t aValue); */ /* void setAsInt64 (in int64_t aValue); */
@@ -1978,7 +1985,7 @@ nsVariant::SetAsInt64(int64_t aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromInt64(&mData, aValue); return mData.SetFromInt64(aValue);
} }
/* void setAsUint8 (in uint8_t aValue); */ /* void setAsUint8 (in uint8_t aValue); */
@@ -1988,7 +1995,7 @@ nsVariant::SetAsUint8(uint8_t aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromUint8(&mData, aValue); return mData.SetFromUint8(aValue);
} }
/* void setAsUint16 (in uint16_t aValue); */ /* void setAsUint16 (in uint16_t aValue); */
@@ -1998,7 +2005,7 @@ nsVariant::SetAsUint16(uint16_t aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromUint16(&mData, aValue); return mData.SetFromUint16(aValue);
} }
/* void setAsUint32 (in uint32_t aValue); */ /* void setAsUint32 (in uint32_t aValue); */
@@ -2008,7 +2015,7 @@ nsVariant::SetAsUint32(uint32_t aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromUint32(&mData, aValue); return mData.SetFromUint32(aValue);
} }
/* void setAsUint64 (in uint64_t aValue); */ /* void setAsUint64 (in uint64_t aValue); */
@@ -2018,7 +2025,7 @@ nsVariant::SetAsUint64(uint64_t aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromUint64(&mData, aValue); return mData.SetFromUint64(aValue);
} }
/* void setAsFloat (in float aValue); */ /* void setAsFloat (in float aValue); */
@@ -2028,7 +2035,7 @@ nsVariant::SetAsFloat(float aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromFloat(&mData, aValue); return mData.SetFromFloat(aValue);
} }
/* void setAsDouble (in double aValue); */ /* void setAsDouble (in double aValue); */
@@ -2038,7 +2045,7 @@ nsVariant::SetAsDouble(double aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromDouble(&mData, aValue); return mData.SetFromDouble(aValue);
} }
/* void setAsBool (in bool aValue); */ /* void setAsBool (in bool aValue); */
@@ -2048,7 +2055,7 @@ nsVariant::SetAsBool(bool aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromBool(&mData, aValue); return mData.SetFromBool(aValue);
} }
/* void setAsChar (in char aValue); */ /* void setAsChar (in char aValue); */
@@ -2058,7 +2065,7 @@ nsVariant::SetAsChar(char aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromChar(&mData, aValue); return mData.SetFromChar(aValue);
} }
/* void setAsWChar (in wchar aValue); */ /* void setAsWChar (in wchar aValue); */
@@ -2068,7 +2075,7 @@ nsVariant::SetAsWChar(char16_t aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromWChar(&mData, aValue); return mData.SetFromWChar(aValue);
} }
/* void setAsID (in nsIDRef aValue); */ /* void setAsID (in nsIDRef aValue); */
@@ -2078,7 +2085,7 @@ nsVariant::SetAsID(const nsID& aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromID(&mData, aValue); return mData.SetFromID(aValue);
} }
/* void setAsAString (in AString aValue); */ /* void setAsAString (in AString aValue); */
@@ -2088,7 +2095,7 @@ nsVariant::SetAsAString(const nsAString& aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromAString(&mData, aValue); return mData.SetFromAString(aValue);
} }
/* void setAsDOMString (in DOMString aValue); */ /* void setAsDOMString (in DOMString aValue); */
@@ -2099,11 +2106,7 @@ nsVariant::SetAsDOMString(const nsAString& aValue)
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
DATA_SETTER_PROLOGUE((&mData)); return mData.SetFromDOMString(aValue);
if (!(mData.u.mAStringValue = new nsString(aValue))) {
return NS_ERROR_OUT_OF_MEMORY;
}
DATA_SETTER_EPILOGUE((&mData), VTYPE_DOMSTRING);
} }
/* void setAsACString (in ACString aValue); */ /* void setAsACString (in ACString aValue); */
@@ -2113,7 +2116,7 @@ nsVariant::SetAsACString(const nsACString& aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromACString(&mData, aValue); return mData.SetFromACString(aValue);
} }
/* void setAsAUTF8String (in AUTF8String aValue); */ /* void setAsAUTF8String (in AUTF8String aValue); */
@@ -2123,7 +2126,7 @@ nsVariant::SetAsAUTF8String(const nsAUTF8String& aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromAUTF8String(&mData, aValue); return mData.SetFromAUTF8String(aValue);
} }
/* void setAsString (in string aValue); */ /* void setAsString (in string aValue); */
@@ -2133,7 +2136,7 @@ nsVariant::SetAsString(const char* aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromString(&mData, aValue); return mData.SetFromString(aValue);
} }
/* void setAsWString (in wstring aValue); */ /* void setAsWString (in wstring aValue); */
@@ -2143,7 +2146,7 @@ nsVariant::SetAsWString(const char16_t* aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromWString(&mData, aValue); return mData.SetFromWString(aValue);
} }
/* void setAsISupports (in nsISupports aValue); */ /* void setAsISupports (in nsISupports aValue); */
@@ -2153,7 +2156,7 @@ nsVariant::SetAsISupports(nsISupports* aValue)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromISupports(&mData, aValue); return mData.SetFromISupports(aValue);
} }
/* void setAsInterface (in nsIIDRef iid, [iid_is (iid)] in nsQIResult iface); */ /* void setAsInterface (in nsIIDRef iid, [iid_is (iid)] in nsQIResult iface); */
@@ -2163,7 +2166,7 @@ nsVariant::SetAsInterface(const nsIID& aIID, void* aInterface)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromInterface(&mData, aIID, (nsISupports*)aInterface); return mData.SetFromInterface(aIID, (nsISupports*)aInterface);
} }
/* [noscript] void setAsArray (in uint16_t type, in nsIIDPtr iid, in uint32_t count, in voidPtr ptr); */ /* [noscript] void setAsArray (in uint16_t type, in nsIIDPtr iid, in uint32_t count, in voidPtr ptr); */
@@ -2174,7 +2177,7 @@ nsVariant::SetAsArray(uint16_t aType, const nsIID* aIID,
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromArray(&mData, aType, aIID, aCount, aPtr); return mData.SetFromArray(aType, aIID, aCount, aPtr);
} }
/* void setAsStringWithSize (in uint32_t size, [size_is (size)] in string str); */ /* void setAsStringWithSize (in uint32_t size, [size_is (size)] in string str); */
@@ -2184,7 +2187,7 @@ nsVariant::SetAsStringWithSize(uint32_t aSize, const char* aStr)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromStringWithSize(&mData, aSize, aStr); return mData.SetFromStringWithSize(aSize, aStr);
} }
/* void setAsWStringWithSize (in uint32_t size, [size_is (size)] in wstring str); */ /* void setAsWStringWithSize (in uint32_t size, [size_is (size)] in wstring str); */
@@ -2194,7 +2197,7 @@ nsVariant::SetAsWStringWithSize(uint32_t aSize, const char16_t* aStr)
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetFromWStringWithSize(&mData, aSize, aStr); return mData.SetFromWStringWithSize(aSize, aStr);
} }
/* void setAsVoid (); */ /* void setAsVoid (); */
@@ -2204,7 +2207,7 @@ nsVariant::SetAsVoid()
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetToVoid(&mData); return mData.SetToVoid();
} }
/* void setAsEmpty (); */ /* void setAsEmpty (); */
@@ -2214,7 +2217,7 @@ nsVariant::SetAsEmpty()
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetToEmpty(&mData); return mData.SetToEmpty();
} }
/* void setAsEmptyArray (); */ /* void setAsEmptyArray (); */
@@ -2224,7 +2227,7 @@ nsVariant::SetAsEmptyArray()
if (!mWritable) { if (!mWritable) {
return NS_ERROR_OBJECT_IS_IMMUTABLE; return NS_ERROR_OBJECT_IS_IMMUTABLE;
} }
return nsVariant::SetToEmptyArray(&mData); return mData.SetToEmptyArray();
} }
/* void setFromVariant (in nsIVariant aValue); */ /* void setFromVariant (in nsIVariant aValue); */

81
xpcom/ds/nsVariant.h
View File

@@ -64,6 +64,41 @@ public:
nsresult ConvertToArray(uint16_t* aType, nsIID* aIID, nsresult ConvertToArray(uint16_t* aType, nsIID* aIID,
uint32_t* aCount, void** aPtr) const; uint32_t* aCount, void** aPtr) const;
nsresult SetFromInt8(uint8_t aValue);
nsresult SetFromInt16(int16_t aValue);
nsresult SetFromInt32(int32_t aValue);
nsresult SetFromInt64(int64_t aValue);
nsresult SetFromUint8(uint8_t aValue);
nsresult SetFromUint16(uint16_t aValue);
nsresult SetFromUint32(uint32_t aValue);
nsresult SetFromUint64(uint64_t aValue);
nsresult SetFromFloat(float aValue);
nsresult SetFromDouble(double aValue);
nsresult SetFromBool(bool aValue);
nsresult SetFromChar(char aValue);
nsresult SetFromWChar(char16_t aValue);
nsresult SetFromID(const nsID& aValue);
nsresult SetFromAString(const nsAString& aValue);
nsresult SetFromDOMString(const nsAString& aValue);
nsresult SetFromAUTF8String(const nsAUTF8String& aValue);
nsresult SetFromACString(const nsACString& aValue);
nsresult SetFromString(const char* aValue);
nsresult SetFromWString(const char16_t* aValue);
nsresult SetFromISupports(nsISupports* aValue);
nsresult SetFromInterface(const nsIID& aIID, nsISupports* aValue);
nsresult SetFromArray(uint16_t aType, const nsIID* aIID, uint32_t aCount,
void* aValue);
nsresult SetFromStringWithSize(uint32_t aSize, const char* aValue);
nsresult SetFromWStringWithSize(uint32_t aSize, const char16_t* aValue);
// Like SetFromWStringWithSize, but leaves the string uninitialized. It does
// does write the null-terminator.
nsresult AllocateWStringWithSize(uint32_t aSize);
nsresult SetToVoid();
nsresult SetToEmpty();
nsresult SetToEmptyArray();
private: private:
nsresult ToManageableNumber(nsDiscriminatedUnion* aOutData) const; nsresult ToManageableNumber(nsDiscriminatedUnion* aOutData) const;
void FreeArray(); void FreeArray();
@@ -142,52 +177,6 @@ public:
static nsresult SetFromVariant(nsDiscriminatedUnion* aData, static nsresult SetFromVariant(nsDiscriminatedUnion* aData,
nsIVariant* aValue); nsIVariant* aValue);
static nsresult SetFromInt8(nsDiscriminatedUnion* aData, uint8_t aValue);
static nsresult SetFromInt16(nsDiscriminatedUnion* aData, int16_t aValue);
static nsresult SetFromInt32(nsDiscriminatedUnion* aData, int32_t aValue);
static nsresult SetFromInt64(nsDiscriminatedUnion* aData, int64_t aValue);
static nsresult SetFromUint8(nsDiscriminatedUnion* aData, uint8_t aValue);
static nsresult SetFromUint16(nsDiscriminatedUnion* aData, uint16_t aValue);
static nsresult SetFromUint32(nsDiscriminatedUnion* aData, uint32_t aValue);
static nsresult SetFromUint64(nsDiscriminatedUnion* aData, uint64_t aValue);
static nsresult SetFromFloat(nsDiscriminatedUnion* aData, float aValue);
static nsresult SetFromDouble(nsDiscriminatedUnion* aData, double aValue);
static nsresult SetFromBool(nsDiscriminatedUnion* aData, bool aValue);
static nsresult SetFromChar(nsDiscriminatedUnion* aData, char aValue);
static nsresult SetFromWChar(nsDiscriminatedUnion* aData, char16_t aValue);
static nsresult SetFromID(nsDiscriminatedUnion* aData, const nsID& aValue);
static nsresult SetFromAString(nsDiscriminatedUnion* aData,
const nsAString& aValue);
static nsresult SetFromAUTF8String(nsDiscriminatedUnion* aData,
const nsAUTF8String& aValue);
static nsresult SetFromACString(nsDiscriminatedUnion* aData,
const nsACString& aValue);
static nsresult SetFromString(nsDiscriminatedUnion* aData,
const char* aValue);
static nsresult SetFromWString(nsDiscriminatedUnion* aData,
const char16_t* aValue);
static nsresult SetFromISupports(nsDiscriminatedUnion* aData,
nsISupports* aValue);
static nsresult SetFromInterface(nsDiscriminatedUnion* aData,
const nsIID& aIID, nsISupports* aValue);
static nsresult SetFromArray(nsDiscriminatedUnion* aData, uint16_t aType,
const nsIID* aIID, uint32_t aCount,
void* aValue);
static nsresult SetFromStringWithSize(nsDiscriminatedUnion* aData,
uint32_t aSize, const char* aValue);
static nsresult SetFromWStringWithSize(nsDiscriminatedUnion* aData,
uint32_t aSize,
const char16_t* aValue);
// Like SetFromWStringWithSize, but leaves the string uninitialized. It does
// does write the null-terminator.
static nsresult AllocateWStringWithSize(nsDiscriminatedUnion* aData,
uint32_t aSize);
static nsresult SetToVoid(nsDiscriminatedUnion* aData);
static nsresult SetToEmpty(nsDiscriminatedUnion* aData);
static nsresult SetToEmptyArray(nsDiscriminatedUnion* aData);
static void Traverse(const nsDiscriminatedUnion& aData, static void Traverse(const nsDiscriminatedUnion& aData,
nsCycleCollectionTraversalCallback& aCb); nsCycleCollectionTraversalCallback& aCb);