--- a/js/xpconnect/loader/mozJSComponentLoader.cpp
+++ b/js/xpconnect/loader/mozJSComponentLoader.cpp
@@ -194,17 +194,17 @@ File(JSContext *cx, unsigned argc, Value
nsCOMPtr<nsISupports> native;
nsresult rv = nsDOMMultipartFile::NewFile(getter_AddRefs(native));
if (NS_FAILED(rv)) {
XPCThrower::Throw(rv, cx);
return false;
}
nsCOMPtr<nsIJSNativeInitializer> initializer = do_QueryInterface(native);
- NS_ASSERTION(initializer, "what?");
+ MOZ_ASSERT(initializer);
rv = initializer->Initialize(nullptr, cx, nullptr, args);
if (NS_FAILED(rv)) {
XPCThrower::Throw(rv, cx);
return false;
}
nsXPConnect* xpc = nsXPConnect::XPConnect();
@@ -229,17 +229,17 @@ Blob(JSContext *cx, unsigned argc, Value
nsCOMPtr<nsISupports> native;
nsresult rv = nsDOMMultipartFile::NewBlob(getter_AddRefs(native));
if (NS_FAILED(rv)) {
XPCThrower::Throw(rv, cx);
return false;
}
nsCOMPtr<nsIJSNativeInitializer> initializer = do_QueryInterface(native);
- NS_ASSERTION(initializer, "what?");
+ MOZ_ASSERT(initializer);
rv = initializer->Initialize(nullptr, cx, nullptr, args);
if (NS_FAILED(rv)) {
XPCThrower::Throw(rv, cx);
return false;
}
nsXPConnect* xpc = nsXPConnect::XPConnect();
@@ -342,17 +342,17 @@ ReportOnCaller(JSCLContextHelper &helper
}
mozJSComponentLoader::mozJSComponentLoader()
: mRuntime(nullptr),
mContext(nullptr),
mInitialized(false),
mReuseLoaderGlobal(false)
{
- NS_ASSERTION(!sSelf, "mozJSComponentLoader should be a singleton");
+ MOZ_ASSERT(!sSelf, "mozJSComponentLoader should be a singleton");
#ifdef PR_LOGGING
if (!gJSCLLog) {
gJSCLLog = PR_NewLogModule("JSComponentLoader");
}
#endif
sSelf = this;
@@ -1267,17 +1267,17 @@ mozJSComponentLoader::ImportInto(const n
// about:memory may use that information
if (!mReuseLoaderGlobal) {
xpc::SetLocationForGlobal(newEntry->obj, aLocation);
}
mod = newEntry;
}
- NS_ASSERTION(mod->obj, "Import table contains entry with no object");
+ MOZ_ASSERT(mod->obj, "Import table contains entry with no object");
vp.set(mod->obj);
if (targetObj) {
JSCLContextHelper cxhelper(mContext);
JSAutoCompartment ac(mContext, mod->obj);
RootedValue symbols(mContext);
if (!JS_GetProperty(mContext, mod->obj,
@@ -1412,17 +1412,17 @@ mozJSComponentLoader::Observe(nsISupport
return NS_OK;
}
/* static */ already_AddRefed<nsIFactory>
mozJSComponentLoader::ModuleEntry::GetFactory(const mozilla::Module& module,
const mozilla::Module::CIDEntry& entry)
{
const ModuleEntry& self = static_cast<const ModuleEntry&>(module);
- NS_ASSERTION(self.getfactoryobj, "Handing out an uninitialized module?");
+ MOZ_ASSERT(self.getfactoryobj, "Handing out an uninitialized module?");
nsCOMPtr<nsIFactory> f;
nsresult rv = self.getfactoryobj->Get(*entry.cid, getter_AddRefs(f));
if (NS_FAILED(rv))
return nullptr;
return f.forget();
}
@@ -1449,11 +1449,11 @@ JSCLContextHelper::~JSCLContextHelper()
if (mBuf) {
JS_smprintf_free(mBuf);
}
}
void
JSCLContextHelper::reportErrorAfterPop(char *buf)
{
- NS_ASSERTION(!mBuf, "Already called reportErrorAfterPop");
+ MOZ_ASSERT(!mBuf, "Already called reportErrorAfterPop");
mBuf = buf;
}
--- a/js/xpconnect/public/nsAutoJSValHolder.h
+++ b/js/xpconnect/public/nsAutoJSValHolder.h
@@ -120,17 +120,17 @@ public:
nsAutoJSValHolder &operator=(JSObject* aOther) {
return *this = OBJECT_TO_JSVAL(aOther);
}
nsAutoJSValHolder &operator=(jsval aOther) {
#ifdef DEBUG
if (JSVAL_IS_GCTHING(aOther) && !JSVAL_IS_NULL(aOther)) {
- NS_ASSERTION(IsHeld(), "Not rooted!");
+ MOZ_ASSERT(IsHeld(), "Not rooted!");
}
#endif
mVal = aOther;
return *this;
}
private:
jsval mVal;
--- a/js/xpconnect/shell/xpcshell.cpp
+++ b/js/xpconnect/shell/xpcshell.cpp
@@ -742,17 +742,17 @@ Blob(JSContext *cx, unsigned argc, jsval
nsCOMPtr<nsISupports> native =
do_CreateInstance("@mozilla.org/dom/multipart-blob;1");
if (!native) {
JS_ReportError(cx, "Could not create native object!");
return false;
}
nsCOMPtr<nsIJSNativeInitializer> initializer = do_QueryInterface(native);
- NS_ASSERTION(initializer, "what?");
+ MOZ_ASSERT(initializer);
nsresult rv = initializer->Initialize(nullptr, cx, nullptr, args);
if (NS_FAILED(rv)) {
JS_ReportError(cx, "Could not initialize native object!");
return false;
}
nsCOMPtr<nsIXPConnect> xpc = do_GetService(kXPConnectServiceContractID, &rv);
@@ -781,17 +781,17 @@ File(JSContext *cx, unsigned argc, jsval
nsCOMPtr<nsISupports> native =
do_CreateInstance("@mozilla.org/dom/multipart-file;1");
if (!native) {
JS_ReportError(cx, "Could not create native object!");
return false;
}
nsCOMPtr<nsIJSNativeInitializer> initializer = do_QueryInterface(native);
- NS_ASSERTION(initializer, "what?");
+ MOZ_ASSERT(initializer);
nsresult rv = initializer->Initialize(nullptr, cx, nullptr, args);
if (NS_FAILED(rv)) {
JS_ReportError(cx, "Could not initialize native object!");
return false;
}
nsCOMPtr<nsIXPConnect> xpc = do_GetService(kXPConnectServiceContractID, &rv);
@@ -1679,17 +1679,17 @@ main(int argc, char **argv, char **envp)
JS_HoldPrincipals(gJSPrincipals);
}
} else {
fprintf(gErrFile, "+++ Failed to get ScriptSecurityManager service, running without principals");
}
}
const JSSecurityCallbacks *scb = JS_GetSecurityCallbacks(rt);
- NS_ASSERTION(scb, "We are assuming that nsScriptSecurityManager::Init() has been run");
+ MOZ_ASSERT(scb, "We are assuming that nsScriptSecurityManager::Init() has been run");
shellSecurityCallbacks = *scb;
JS_SetSecurityCallbacks(rt, &shellSecurityCallbacks);
#ifdef TEST_TranslateThis
nsCOMPtr<nsIXPCFunctionThisTranslator>
translator(new nsXPCFunctionThisTranslator);
xpc->SetFunctionThisTranslator(NS_GET_IID(nsITestXPCFunctionCallback), translator);
#endif
@@ -1775,17 +1775,17 @@ main(int argc, char **argv, char **envp)
// Get the crashreporter service while XPCOM is still active.
// This is a special exception: it will remain usable after NS_ShutdownXPCOM().
nsCOMPtr<nsICrashReporter> crashReporter =
do_GetService("@mozilla.org/toolkit/crash-reporter;1");
#endif
// no nsCOMPtrs are allowed to be alive when you call NS_ShutdownXPCOM
rv = NS_ShutdownXPCOM( NULL );
- NS_ASSERTION(NS_SUCCEEDED(rv), "NS_ShutdownXPCOM failed");
+ MOZ_ASSERT(NS_SUCCEEDED(rv), "NS_ShutdownXPCOM failed");
#ifdef TEST_CALL_ON_WRAPPED_JS_AFTER_SHUTDOWN
// test of late call and release (see above)
JSContext* bogusCX;
bogus->Peek(&bogusCX);
bogus = nullptr;
#endif
--- a/js/xpconnect/src/XPCCallContext.cpp
+++ b/js/xpconnect/src/XPCCallContext.cpp
@@ -34,17 +34,16 @@ XPCCallContext::XPCCallContext(XPCContex
mCallerLanguage(callerLanguage),
mFlattenedJSObject(cx),
mWrapper(nullptr),
mTearOff(nullptr),
mName(cx)
{
MOZ_ASSERT(cx);
- NS_ASSERTION(mJSContext, "No JSContext supplied to XPCCallContext");
if (!mXPC)
return;
mXPCContext = XPCContext::GetXPCContext(mJSContext);
mPrevCallerLanguage = mXPCContext->SetCallingLangType(mCallerLanguage);
// hook into call context chain.
mPrevCallContext = XPCJSRuntime::Get()->SetCallContext(this);
@@ -82,17 +81,17 @@ XPCCallContext::XPCCallContext(XPCContex
if (mWrapper) {
mFlattenedJSObject = mWrapper->GetFlatJSObject();
if (mTearOff)
mScriptableInfo = nullptr;
else
mScriptableInfo = mWrapper->GetScriptableInfo();
} else {
- NS_ABORT_IF_FALSE(!mFlattenedJSObject, "What object do we have?");
+ MOZ_ASSERT(!mFlattenedJSObject, "What object do we have?");
}
if (!JSID_IS_VOID(name))
SetName(name);
if (argc != NO_ARGS)
SetArgsAndResultPtr(argc, argv, rval);
@@ -235,17 +234,17 @@ XPCCallContext::SystemIsBeingShutDown()
}
XPCCallContext::~XPCCallContext()
{
if (mXPCContext) {
mXPCContext->SetCallingLangType(mPrevCallerLanguage);
DebugOnly<XPCCallContext*> old = XPCJSRuntime::Get()->SetCallContext(mPrevCallContext);
- NS_ASSERTION(old == this, "bad pop from per thread data");
+ MOZ_ASSERT(old == this, "bad pop from per thread data");
}
}
/* readonly attribute nsISupports Callee; */
NS_IMETHODIMP
XPCCallContext::GetCallee(nsISupports * *aCallee)
{
nsISupports* temp = mWrapper ? mWrapper->GetIdentityObject() : nullptr;
--- a/js/xpconnect/src/XPCComponents.cpp
+++ b/js/xpconnect/src/XPCComponents.cpp
@@ -3256,18 +3256,17 @@ xpc_CreateSandboxObject(JSContext *cx, j
nsCOMPtr<nsIPrincipal> principal = do_QueryInterface(prinOrSop);
if (!principal) {
nsCOMPtr<nsIScriptObjectPrincipal> sop = do_QueryInterface(prinOrSop);
if (sop) {
principal = sop->GetPrincipal();
} else {
principal = do_CreateInstance("@mozilla.org/nullprincipal;1", &rv);
- NS_ASSERTION(NS_FAILED(rv) || principal,
- "Bad return from do_CreateInstance");
+ MOZ_ASSERT(NS_FAILED(rv) || principal, "Bad return from do_CreateInstance");
if (!principal || NS_FAILED(rv)) {
if (NS_SUCCEEDED(rv)) {
rv = NS_ERROR_FAILURE;
}
return rv;
}
@@ -3855,17 +3854,17 @@ xpc_EvalInSandbox(JSContext *cx, HandleO
bool waiveXray = xpc::WrapperFactory::HasWaiveXrayFlag(sandboxArg);
RootedObject sandbox(cx, js::CheckedUnwrap(sandboxArg));
if (!sandbox || js::GetObjectJSClass(sandbox) != &SandboxClass) {
return NS_ERROR_INVALID_ARG;
}
nsIScriptObjectPrincipal *sop =
(nsIScriptObjectPrincipal*)xpc_GetJSPrivate(sandbox);
- NS_ASSERTION(sop, "Invalid sandbox passed");
+ MOZ_ASSERT(sop, "Invalid sandbox passed");
nsCOMPtr<nsIPrincipal> prin = sop->GetPrincipal();
NS_ENSURE_TRUE(prin, NS_ERROR_FAILURE);
nsAutoCString filenameBuf;
if (!filename) {
// Default to the spec of the principal.
nsJSPrincipals::get(prin)->GetScriptLocation(filenameBuf);
filename = filenameBuf.get();
@@ -4206,17 +4205,17 @@ nsXPCComponents_Utils::CreateDateIn(cons
}
bool
FunctionWrapper(JSContext *cx, unsigned argc, Value *vp)
{
CallArgs args = CallArgsFromVp(argc, vp);
RootedValue v(cx, js::GetFunctionNativeReserved(&args.callee(), 0));
- NS_ASSERTION(v.isObject(), "weird function");
+ MOZ_ASSERT(v.isObject(), "weird function");
JSObject *obj = JS_THIS_OBJECT(cx, vp);
if (!obj) {
return false;
}
return JS_CallFunctionValue(cx, obj, v, args.length(), args.array(), vp);
}
@@ -4730,17 +4729,17 @@ nsXPCComponents::GetStack(nsIStackFrame
nsXPConnect* xpc = nsXPConnect::XPConnect();
rv = xpc->GetCurrentJSStack(aStack);
return rv;
}
NS_IMETHODIMP
nsXPCComponents::GetManager(nsIComponentManager * *aManager)
{
- NS_ASSERTION(aManager, "bad param");
+ MOZ_ASSERT(aManager, "bad param");
return NS_GetComponentManager(aManager);
}
/**********************************************/
// The nsIXPCScriptable map declaration that will generate stubs for us...
#define XPC_MAP_CLASSNAME nsXPCComponents
#define XPC_MAP_QUOTED_CLASSNAME "nsXPCComponents"
--- a/js/xpconnect/src/XPCContext.cpp
+++ b/js/xpconnect/src/XPCContext.cpp
@@ -20,24 +20,24 @@ XPCContext::XPCContext(XPCJSRuntime* aRu
mPendingResult(NS_OK),
mException(nullptr),
mCallingLangType(LANG_UNKNOWN)
{
MOZ_COUNT_CTOR(XPCContext);
PR_INIT_CLIST(&mScopes);
- NS_ASSERTION(!JS_GetSecondContextPrivate(mJSContext), "Must be null");
+ MOZ_ASSERT(!JS_GetSecondContextPrivate(mJSContext), "Must be null");
JS_SetSecondContextPrivate(mJSContext, this);
}
XPCContext::~XPCContext()
{
MOZ_COUNT_DTOR(XPCContext);
- NS_ASSERTION(JS_GetSecondContextPrivate(mJSContext) == this, "Must match this");
+ MOZ_ASSERT(JS_GetSecondContextPrivate(mJSContext) == this, "Must match this");
JS_SetSecondContextPrivate(mJSContext, nullptr);
NS_IF_RELEASE(mException);
// Iterate over our scopes and tell them that we have been destroyed
for (PRCList *scopeptr = PR_NEXT_LINK(&mScopes);
scopeptr != &mScopes;
scopeptr = PR_NEXT_LINK(scopeptr)) {
XPCWrappedNativeScope *scope =
--- a/js/xpconnect/src/XPCConvert.cpp
+++ b/js/xpconnect/src/XPCConvert.cpp
@@ -77,17 +77,17 @@ UnwrapNativeCPOW(nsISupports* wrapper)
/***************************************************************************/
// static
bool
XPCConvert::GetISupportsFromJSObject(JSObject* obj, nsISupports** iface)
{
JSClass* jsclass = js::GetObjectJSClass(obj);
- NS_ASSERTION(jsclass, "obj has no class");
+ MOZ_ASSERT(jsclass, "obj has no class");
if (jsclass &&
(jsclass->flags & JSCLASS_HAS_PRIVATE) &&
(jsclass->flags & JSCLASS_PRIVATE_IS_NSISUPPORTS)) {
*iface = (nsISupports*) xpc_GetJSPrivate(obj);
return true;
}
*iface = UnwrapDOMObjectToISupports(obj);
return !!*iface;
@@ -129,17 +129,17 @@ XPCConvert::NativeData2JS(jsval* d, cons
}
case nsXPTType::T_CHAR :
{
char* p = (char*)s;
if (!p)
return false;
#ifdef STRICT_CHECK_OF_UNICODE
- NS_ASSERTION(! ILLEGAL_CHAR_RANGE(p) , "passing non ASCII data");
+ MOZ_ASSERT(! ILLEGAL_CHAR_RANGE(p) , "passing non ASCII data");
#endif // STRICT_CHECK_OF_UNICODE
JSString* str;
if (!(str = JS_NewStringCopyN(cx, p, 1)))
return false;
*d = STRING_TO_JSVAL(str);
break;
}
@@ -220,17 +220,17 @@ XPCConvert::NativeData2JS(jsval* d, cons
#ifdef STRICT_CHECK_OF_UNICODE
bool isAscii = true;
char* t;
for (t=p; *t && isAscii ; t++) {
if (ILLEGAL_CHAR_RANGE(*t))
isAscii = false;
}
- NS_ASSERTION(isAscii, "passing non ASCII data");
+ MOZ_ASSERT(isAscii, "passing non ASCII data");
#endif // STRICT_CHECK_OF_UNICODE
JSString* str;
if (!(str = JS_NewStringCopyZ(cx, p)))
return false;
*d = STRING_TO_JSVAL(str);
break;
}
@@ -331,18 +331,18 @@ XPCConvert::NativeData2JS(jsval* d, cons
xpcObjectHelper helper(iface);
if (!NativeInterface2JSObject(d, nullptr, helper, iid,
nullptr, true, pErr))
return false;
#ifdef DEBUG
JSObject* jsobj = JSVAL_TO_OBJECT(*d);
if (jsobj && !js::GetObjectParent(jsobj))
- NS_ASSERTION(js::GetObjectClass(jsobj)->flags & JSCLASS_IS_GLOBAL,
- "Why did we recreate this wrapper?");
+ MOZ_ASSERT(js::GetObjectClass(jsobj)->flags & JSCLASS_IS_GLOBAL,
+ "Why did we recreate this wrapper?");
#endif
}
break;
}
default:
NS_ERROR("bad type");
return false;
@@ -719,17 +719,17 @@ XPCConvert::JSData2Native(void* d, Handl
JS_EncodeStringToBuffer(cx, str, rs->BeginWriting(), length);
return true;
}
case nsXPTType::T_INTERFACE:
case nsXPTType::T_INTERFACE_IS:
{
- NS_ASSERTION(iid,"can't do interface conversions without iid");
+ MOZ_ASSERT(iid,"can't do interface conversions without iid");
if (iid->Equals(NS_GET_IID(nsIVariant))) {
XPCVariant* variant = XPCVariant::newVariant(cx, s);
if (!variant)
return false;
*((nsISupports**)d) = static_cast<nsIVariant*>(variant);
return true;
} else if (iid->Equals(NS_GET_IID(nsIAtom)) &&
@@ -795,18 +795,18 @@ bool
XPCConvert::NativeInterface2JSObject(jsval* d,
nsIXPConnectJSObjectHolder** dest,
xpcObjectHelper& aHelper,
const nsID* iid,
XPCNativeInterface** Interface,
bool allowNativeWrapper,
nsresult* pErr)
{
- NS_ASSERTION(!Interface || iid,
- "Need the iid if you pass in an XPCNativeInterface cache.");
+ MOZ_ASSERT(!Interface || iid,
+ "Need the iid if you pass in an XPCNativeInterface cache.");
*d = JSVAL_NULL;
if (dest)
*dest = nullptr;
if (!aHelper.Object())
return true;
if (pErr)
*pErr = NS_ERROR_XPC_BAD_CONVERT_NATIVE;
@@ -878,17 +878,17 @@ XPCConvert::NativeInterface2JSObject(jsv
if (!iface)
return false;
if (Interface)
*Interface = iface;
}
}
- NS_ASSERTION(!flat || IS_WN_REFLECTOR(flat), "What kind of wrapper is this?");
+ MOZ_ASSERT(!flat || IS_WN_REFLECTOR(flat), "What kind of wrapper is this?");
nsresult rv;
XPCWrappedNative* wrapper;
nsRefPtr<XPCWrappedNative> strongWrapper;
if (!flat) {
rv = XPCWrappedNative::GetNewOrUsed(aHelper, xpcscope, iface,
getter_AddRefs(strongWrapper));
@@ -961,19 +961,19 @@ XPCConvert::NativeInterface2JSObject(jsv
// static
bool
XPCConvert::JSObject2NativeInterface(void** dest, HandleObject src,
const nsID* iid,
nsISupports* aOuter,
nsresult* pErr)
{
- NS_ASSERTION(dest, "bad param");
- NS_ASSERTION(src, "bad param");
- NS_ASSERTION(iid, "bad param");
+ MOZ_ASSERT(dest, "bad param");
+ MOZ_ASSERT(src, "bad param");
+ MOZ_ASSERT(iid, "bad param");
AutoJSContext cx;
JSAutoCompartment ac(cx, src);
*dest = nullptr;
if (pErr)
*pErr = NS_ERROR_XPC_BAD_CONVERT_JS;
@@ -1052,17 +1052,17 @@ XPCConvert::JSObject2NativeInterface(voi
nsresult
XPCConvert::ConstructException(nsresult rv, const char* message,
const char* ifaceName, const char* methodName,
nsISupports* data,
nsIException** exceptn,
JSContext* cx,
jsval* jsExceptionPtr)
{
- NS_ASSERTION(!cx == !jsExceptionPtr, "Expected cx and jsExceptionPtr to cooccur.");
+ MOZ_ASSERT(!cx == !jsExceptionPtr, "Expected cx and jsExceptionPtr to cooccur.");
static const char format[] = "\'%s\' when calling method: [%s::%s]";
const char * msg = message;
char* sz = nullptr;
nsXPIDLString xmsg;
nsAutoCString sxmsg;
nsCOMPtr<nsIScriptError> errorObject = do_QueryInterface(data);
@@ -1471,19 +1471,19 @@ CheckTargetAndPopulate(const nsXPTType&
// static
bool
XPCConvert::JSTypedArray2Native(void** d,
JSObject* jsArray,
uint32_t count,
const nsXPTType& type,
nsresult* pErr)
{
- NS_ABORT_IF_FALSE(jsArray, "bad param");
- NS_ABORT_IF_FALSE(d, "bad param");
- NS_ABORT_IF_FALSE(JS_IsTypedArrayObject(jsArray), "not a typed array");
+ MOZ_ASSERT(jsArray, "bad param");
+ MOZ_ASSERT(d, "bad param");
+ MOZ_ASSERT(JS_IsTypedArrayObject(jsArray), "not a typed array");
// Check the actual length of the input array against the
// given size_is.
uint32_t len = JS_GetTypedArrayLength(jsArray);
if (len < count) {
if (pErr)
*pErr = NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY;
@@ -1574,17 +1574,17 @@ XPCConvert::JSTypedArray2Native(void** d
}
// static
bool
XPCConvert::JSArray2Native(void** d, HandleValue s,
uint32_t count, const nsXPTType& type,
const nsID* iid, nsresult* pErr)
{
- NS_ABORT_IF_FALSE(d, "bad param");
+ MOZ_ASSERT(d, "bad param");
AutoJSContext cx;
// XXX add support for getting chars from strings
// XXX add support to indicate *which* array element was not convertable
if (s.isNullOrUndefined()) {
--- a/js/xpconnect/src/XPCInlines.h
+++ b/js/xpconnect/src/XPCInlines.h
@@ -464,22 +464,22 @@ inline void XPCNativeSet::Mark()
(*pp)->Mark();
MarkSelfOnly();
}
#ifdef DEBUG
inline void XPCNativeSet::ASSERT_NotMarked()
{
- NS_ASSERTION(!IsMarked(), "bad");
+ MOZ_ASSERT(!IsMarked(), "bad");
XPCNativeInterface* const * pp = mInterfaces;
for (int i = (int) mInterfaceCount; i > 0; i--, pp++)
- NS_ASSERTION(!(*pp)->IsMarked(), "bad");
+ MOZ_ASSERT(!(*pp)->IsMarked(), "bad");
}
#endif
/***************************************************************************/
inline
JSObject* XPCWrappedNativeTearOff::GetJSObjectPreserveColor() const
{
@@ -499,18 +499,18 @@ void XPCWrappedNativeTearOff::SetJSObjec
{
MOZ_ASSERT(!IsMarked());
mJSObject = JSObj;
}
inline
XPCWrappedNativeTearOff::~XPCWrappedNativeTearOff()
{
- NS_ASSERTION(!(GetInterface()||GetNative()||GetJSObjectPreserveColor()),
- "tearoff not empty in dtor");
+ MOZ_ASSERT(!(GetInterface() || GetNative() || GetJSObjectPreserveColor()),
+ "tearoff not empty in dtor");
}
/***************************************************************************/
inline bool
XPCWrappedNative::HasInterfaceNoQI(const nsIID& iid)
{
return nullptr != GetSet()->FindInterfaceWithIID(iid);
--- a/js/xpconnect/src/XPCJSID.cpp
+++ b/js/xpconnect/src/XPCJSID.cpp
@@ -46,31 +46,31 @@ void nsJSID::Reset()
NS_Free(mName);
mNumber = mName = nullptr;
}
bool
nsJSID::SetName(const char* name)
{
- NS_ASSERTION(!mName || mName == gNoString ,"name already set");
- NS_ASSERTION(name,"null name");
+ MOZ_ASSERT(!mName || mName == gNoString ,"name already set");
+ MOZ_ASSERT(name,"null name");
mName = NS_strdup(name);
return mName ? true : false;
}
NS_IMETHODIMP
nsJSID::GetName(char * *aName)
{
if (!aName)
return NS_ERROR_NULL_POINTER;
if (!NameIsSet())
SetNameToNoString();
- NS_ASSERTION(mName, "name not set");
+ MOZ_ASSERT(mName, "name not set");
*aName = NS_strdup(mName);
return *aName ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
NS_IMETHODIMP
nsJSID::GetNumber(char * *aNumber)
{
if (!aNumber)
@@ -135,17 +135,17 @@ nsJSID::Initialize(const char *idString)
}
}
return NS_ERROR_FAILURE;
}
bool
nsJSID::InitWithName(const nsID& id, const char *nameString)
{
- NS_ASSERTION(nameString, "no name");
+ MOZ_ASSERT(nameString, "no name");
Reset();
mID = id;
return SetName(nameString);
}
// try to use the name, if no name, then use the number
NS_IMETHODIMP
nsJSID::ToString(char **_retval)
@@ -748,17 +748,17 @@ nsJSCID::CreateInstance(const JS::Value&
nsCOMPtr<nsIComponentManager> compMgr;
nsresult rv = NS_GetComponentManager(getter_AddRefs(compMgr));
if (NS_FAILED(rv))
return NS_ERROR_UNEXPECTED;
nsCOMPtr<nsISupports> inst;
rv = compMgr->CreateInstance(mDetails.ID(), nullptr, *iid, getter_AddRefs(inst));
- NS_ASSERTION(NS_FAILED(rv) || inst, "component manager returned success, but instance is null!");
+ MOZ_ASSERT(NS_FAILED(rv) || inst, "component manager returned success, but instance is null!");
if (NS_FAILED(rv) || !inst)
return NS_ERROR_XPC_CI_RETURNED_FAILURE;
rv = nsXPConnect::XPConnect()->WrapNativeToJSVal(cx, obj, inst, nullptr, iid, true, retval, nullptr);
if (NS_FAILED(rv) || JSVAL_IS_PRIMITIVE(*retval))
return NS_ERROR_XPC_CANT_CREATE_WN;
return NS_OK;
@@ -776,34 +776,34 @@ nsJSCID::GetService(const JS::Value& iid
GetWrapperObject(&obj);
if (!obj) {
return NS_ERROR_UNEXPECTED;
}
nsIXPCSecurityManager* sm;
sm = nsXPConnect::XPConnect()->GetDefaultSecurityManager();
if (sm && NS_FAILED(sm->CanCreateInstance(cx, mDetails.ID()))) {
- NS_ASSERTION(JS_IsExceptionPending(cx),
- "security manager vetoed GetService without setting exception");
+ MOZ_ASSERT(JS_IsExceptionPending(cx),
+ "security manager vetoed GetService without setting exception");
return NS_OK;
}
// If an IID was passed in then use it
const nsID* iid = GetIIDArg(optionalArgc, iidval, cx);
if (!iid)
return NS_ERROR_XPC_BAD_IID;
nsCOMPtr<nsIServiceManager> svcMgr;
nsresult rv = NS_GetServiceManager(getter_AddRefs(svcMgr));
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsISupports> srvc;
rv = svcMgr->GetService(mDetails.ID(), *iid, getter_AddRefs(srvc));
- NS_ASSERTION(NS_FAILED(rv) || srvc, "service manager returned success, but service is null!");
+ MOZ_ASSERT(NS_FAILED(rv) || srvc, "service manager returned success, but service is null!");
if (NS_FAILED(rv) || !srvc)
return NS_ERROR_XPC_GS_RETURNED_FAILURE;
RootedObject instJSObj(cx);
nsCOMPtr<nsIXPConnectJSObjectHolder> holder;
rv = nsXPConnect::XPConnect()->WrapNative(cx, obj, srvc, *iid, getter_AddRefs(holder));
if (NS_FAILED(rv) || !holder ||
// Assign, not compare
@@ -842,17 +842,17 @@ nsJSCID::HasInstance(nsIXPConnectWrapped
{
*bp = false;
nsresult rv = NS_OK;
if (!JSVAL_IS_PRIMITIVE(val)) {
// we have a JSObject
RootedObject obj(cx, &val.toObject());
- NS_ASSERTION(obj, "when is an object not an object?");
+ MOZ_ASSERT(obj, "when is an object not an object?");
// is this really a native xpcom object with a wrapper?
nsIClassInfo* ci = nullptr;
obj = FindObjectForHasInstance(cx, obj);
if (!obj || !IS_WN_REFLECTOR(obj))
return rv;
if (XPCWrappedNative* other_wrapper = XPCWrappedNative::Get(obj))
ci = other_wrapper->GetClassInfo();
@@ -913,17 +913,17 @@ xpc_JSObjectToID(JSContext *cx, JSObject
return ((nsIJSID*)wrapper->GetIdentityObject())->GetID();
}
return nullptr;
}
bool
xpc_JSObjectIsID(JSContext *cx, JSObject* obj)
{
- NS_ASSERTION(cx && obj, "bad param");
+ MOZ_ASSERT(cx && obj, "bad param");
// NOTE: this call does NOT addref
XPCWrappedNative* wrapper = nullptr;
obj = js::CheckedUnwrap(obj);
if (obj && IS_WN_REFLECTOR(obj))
wrapper = XPCWrappedNative::Get(obj);
return wrapper &&
(wrapper->HasInterfaceNoQI(NS_GET_IID(nsIJSID)) ||
wrapper->HasInterfaceNoQI(NS_GET_IID(nsIJSIID)) ||
--- a/js/xpconnect/src/XPCJSRuntime.cpp
+++ b/js/xpconnect/src/XPCJSRuntime.cpp
@@ -664,22 +664,22 @@ XPCJSRuntime::FinalizeCallback(JSFreeOp
{
XPCJSRuntime* self = nsXPConnect::GetRuntimeInstance();
if (!self)
return;
switch (status) {
case JSFINALIZE_GROUP_START:
{
- NS_ASSERTION(!self->mDoingFinalization, "bad state");
+ MOZ_ASSERT(!self->mDoingFinalization, "bad state");
// mThreadRunningGC indicates that GC is running
{ // scoped lock
XPCAutoLock lock(self->GetMapLock());
- NS_ASSERTION(!self->mThreadRunningGC, "bad state");
+ MOZ_ASSERT(!self->mThreadRunningGC, "bad state");
self->mThreadRunningGC = PR_GetCurrentThread();
}
nsTArray<nsXPCWrappedJS*>* dyingWrappedJSArray =
&self->mWrappedJSToReleaseArray;
// Add any wrappers whose JSObjects are to be finalized to
// this array. Note that we do not want to be changing the
@@ -694,43 +694,43 @@ XPCJSRuntime::FinalizeCallback(JSFreeOp
XPCStringConvert::ClearCache();
self->mDoingFinalization = true;
break;
}
case JSFINALIZE_GROUP_END:
{
- NS_ASSERTION(self->mDoingFinalization, "bad state");
+ MOZ_ASSERT(self->mDoingFinalization, "bad state");
self->mDoingFinalization = false;
// Release all the members whose JSObjects are now known
// to be dead.
DoDeferredRelease(self->mWrappedJSToReleaseArray);
// Sweep scopes needing cleanup
XPCWrappedNativeScope::FinishedFinalizationPhaseOfGC();
// mThreadRunningGC indicates that GC is running.
// Clear it and notify waiters.
{ // scoped lock
XPCAutoLock lock(self->GetMapLock());
- NS_ASSERTION(self->mThreadRunningGC == PR_GetCurrentThread(), "bad state");
+ MOZ_ASSERT(self->mThreadRunningGC == PR_GetCurrentThread(), "bad state");
self->mThreadRunningGC = nullptr;
xpc_NotifyAll(self->GetMapLock());
}
break;
}
case JSFINALIZE_COLLECTION_END:
{
// mThreadRunningGC indicates that GC is running
{ // scoped lock
XPCAutoLock lock(self->GetMapLock());
- NS_ASSERTION(!self->mThreadRunningGC, "bad state");
+ MOZ_ASSERT(!self->mThreadRunningGC, "bad state");
self->mThreadRunningGC = PR_GetCurrentThread();
}
#ifdef XPC_REPORT_NATIVE_INTERFACE_AND_SET_FLUSHING
printf("--------------------------------------------------------------\n");
int setsBefore = (int) self->mNativeSetMap->Count();
int ifacesBefore = (int) self->mIID2NativeInterfaceMap->Count();
#endif
@@ -881,17 +881,17 @@ XPCJSRuntime::FinalizeCallback(JSFreeOp
self->mDyingWrappedNativeProtoMap->
Enumerate(DyingProtoKiller, nullptr);
// mThreadRunningGC indicates that GC is running.
// Clear it and notify waiters.
{ // scoped lock
XPCAutoLock lock(self->GetMapLock());
- NS_ASSERTION(self->mThreadRunningGC == PR_GetCurrentThread(), "bad state");
+ MOZ_ASSERT(self->mThreadRunningGC == PR_GetCurrentThread(), "bad state");
self->mThreadRunningGC = nullptr;
xpc_NotifyAll(self->GetMapLock());
}
break;
}
}
}
@@ -1347,17 +1347,17 @@ XPCJSRuntime::DeleteString(nsAString *st
/***************************************************************************/
#ifdef XPC_CHECK_WRAPPERS_AT_SHUTDOWN
static PLDHashOperator
DEBUG_WrapperChecker(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
{
XPCWrappedNative* wrapper = (XPCWrappedNative*)((PLDHashEntryStub*)hdr)->key;
- NS_ASSERTION(!wrapper->IsValid(), "found a 'valid' wrapper!");
+ MOZ_ASSERT(!wrapper->IsValid(), "found a 'valid' wrapper!");
++ *((int*)arg);
return PL_DHASH_NEXT;
}
#endif
static PLDHashOperator
DetachedWrappedNativeProtoShutdownMarker(PLDHashTable *table, PLDHashEntryHdr *hdr,
uint32_t number, void *arg)
@@ -1508,17 +1508,17 @@ XPCJSRuntime::~XPCJSRuntime()
#ifdef MOZ_ENABLE_PROFILER_SPS
// Tell the profiler that the runtime is gone
if (PseudoStack *stack = mozilla_get_pseudo_stack())
stack->sampleRuntime(nullptr);
#endif
#ifdef DEBUG
for (uint32_t i = 0; i < XPCCCX_STRING_CACHE_SIZE; ++i) {
- NS_ASSERTION(!mScratchStrings[i].mInUse, "Uh, string wrapper still in use!");
+ MOZ_ASSERT(!mScratchStrings[i].mInUse, "Uh, string wrapper still in use!");
}
#endif
}
static void
GetCompartmentName(JSCompartment *c, nsCString &name, bool replaceSlashes)
{
if (js::IsAtomsCompartment(c)) {
@@ -2021,17 +2021,17 @@ ReportCompartmentStats(const JS::Compart
// asm.js arrays are heap-allocated on some platforms and
// non-heap-allocated on others. We never put them under sundries,
// because (a) in practice they're almost always larger than the sundries
// threshold, and (b) we'd need a third category of non-heap, non-GC
// sundries, which would be a pain.
size_t asmJSHeap = cStats.objectsExtra.elementsAsmJSHeap;
size_t asmJSNonHeap = cStats.objectsExtra.elementsAsmJSNonHeap;
- JS_ASSERT(asmJSHeap == 0 || asmJSNonHeap == 0);
+ MOZ_ASSERT(asmJSHeap == 0 || asmJSNonHeap == 0);
if (asmJSHeap > 0) {
REPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/malloc-heap/elements/asm.js"),
KIND_HEAP, asmJSHeap,
"Memory allocated on the malloc heap for object element arrays used as asm.js "
"array buffers.");
}
if (asmJSNonHeap > 0) {
REPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/non-heap/elements/asm.js"),
@@ -2800,17 +2800,17 @@ ReadSourceFromFilename(JSContext *cx, co
return NS_ERROR_OUT_OF_MEMORY;
unsigned char *ptr = buf, *end = ptr + rawLen;
while (ptr < end) {
uint32_t bytesRead;
rv = scriptStream->Read(reinterpret_cast<char *>(ptr), end - ptr, &bytesRead);
if (NS_FAILED(rv))
return rv;
- NS_ASSERTION(bytesRead > 0, "stream promised more bytes before EOF");
+ MOZ_ASSERT(bytesRead > 0, "stream promised more bytes before EOF");
ptr += bytesRead;
}
nsString decoded;
rv = nsScriptLoader::ConvertToUTF16(scriptChannel, buf, rawLen, EmptyString(), NULL, decoded);
NS_ENSURE_SUCCESS(rv, rv);
// Copy to JS engine.
@@ -3172,77 +3172,77 @@ XPCJSRuntime::DebugDump(int16_t depth)
#endif
}
/***************************************************************************/
void
XPCRootSetElem::AddToRootSet(XPCLock *lock, XPCRootSetElem **listHead)
{
- NS_ASSERTION(!mSelfp, "Must be not linked");
+ MOZ_ASSERT(!mSelfp, "Must be not linked");
XPCAutoLock autoLock(lock);
mSelfp = listHead;
mNext = *listHead;
if (mNext) {
- NS_ASSERTION(mNext->mSelfp == listHead, "Must be list start");
+ MOZ_ASSERT(mNext->mSelfp == listHead, "Must be list start");
mNext->mSelfp = &mNext;
}
*listHead = this;
}
void
XPCRootSetElem::RemoveFromRootSet(XPCLock *lock)
{
nsXPConnect *xpc = nsXPConnect::XPConnect();
JS::PokeGC(xpc->GetRuntime()->Runtime());
- NS_ASSERTION(mSelfp, "Must be linked");
+ MOZ_ASSERT(mSelfp, "Must be linked");
XPCAutoLock autoLock(lock);
- NS_ASSERTION(*mSelfp == this, "Link invariant");
+ MOZ_ASSERT(*mSelfp == this, "Link invariant");
*mSelfp = mNext;
if (mNext)
mNext->mSelfp = mSelfp;
#ifdef DEBUG
mSelfp = nullptr;
mNext = nullptr;
#endif
}
void
XPCJSRuntime::AddGCCallback(xpcGCCallback cb)
{
- NS_ASSERTION(cb, "null callback");
+ MOZ_ASSERT(cb, "null callback");
extraGCCallbacks.AppendElement(cb);
}
void
XPCJSRuntime::RemoveGCCallback(xpcGCCallback cb)
{
- NS_ASSERTION(cb, "null callback");
+ MOZ_ASSERT(cb, "null callback");
bool found = extraGCCallbacks.RemoveElement(cb);
if (!found) {
NS_ERROR("Removing a callback which was never added.");
}
}
void
XPCJSRuntime::AddContextCallback(xpcContextCallback cb)
{
- NS_ASSERTION(cb, "null callback");
+ MOZ_ASSERT(cb, "null callback");
extraContextCallbacks.AppendElement(cb);
}
void
XPCJSRuntime::RemoveContextCallback(xpcContextCallback cb)
{
- NS_ASSERTION(cb, "null callback");
+ MOZ_ASSERT(cb, "null callback");
bool found = extraContextCallbacks.RemoveElement(cb);
if (!found) {
NS_ERROR("Removing a callback which was never added.");
}
}
JSObject *
XPCJSRuntime::GetJunkScope()
--- a/js/xpconnect/src/XPCLocale.cpp
+++ b/js/xpconnect/src/XPCLocale.cpp
@@ -178,17 +178,17 @@ private:
do_GetService(NS_LOCALESERVICE_CONTRACTID, &rv);
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsILocale> appLocale;
rv = localeService->GetApplicationLocale(getter_AddRefs(appLocale));
if (NS_SUCCEEDED(rv)) {
nsAutoString localeStr;
rv = appLocale->
GetCategory(NS_LITERAL_STRING(NSILOCALE_TIME), localeStr);
- NS_ASSERTION(NS_SUCCEEDED(rv), "failed to get app locale info");
+ MOZ_ASSERT(NS_SUCCEEDED(rv), "failed to get app locale info");
nsCOMPtr<nsIPlatformCharset> platformCharset =
do_GetService(NS_PLATFORMCHARSET_CONTRACTID, &rv);
if (NS_SUCCEEDED(rv)) {
nsAutoCString charset;
rv = platformCharset->GetDefaultCharsetForLocale(localeStr, charset);
if (NS_SUCCEEDED(rv)) {
@@ -263,17 +263,17 @@ xpc_LocalizeRuntime(JSRuntime *rt)
nsCOMPtr<nsILocale> appLocale;
nsresult rv = localeService->GetApplicationLocale(getter_AddRefs(appLocale));
if (NS_FAILED(rv))
return false;
nsAutoString localeStr;
rv = appLocale->GetCategory(NS_LITERAL_STRING(NSILOCALE_TIME), localeStr);
- NS_ASSERTION(NS_SUCCEEDED(rv), "failed to get app locale info");
+ MOZ_ASSERT(NS_SUCCEEDED(rv), "failed to get app locale info");
NS_LossyConvertUTF16toASCII locale(localeStr);
return !!JS_SetDefaultLocale(rt, locale.get());
}
NS_EXPORT_(void)
xpc_DelocalizeRuntime(JSRuntime *rt)
{
--- a/js/xpconnect/src/XPCMaps.cpp
+++ b/js/xpconnect/src/XPCMaps.cpp
@@ -49,17 +49,17 @@ HashNativeKey(PLDHashTable *table, const
Position = Key->GetPosition();
} else {
Set = (XPCNativeSet*) Key;
Addition = nullptr;
Position = 0;
}
if (!Set) {
- NS_ASSERTION(Addition, "bad key");
+ MOZ_ASSERT(Addition, "bad key");
// This would be an XOR like below.
// But "0 ^ x == x". So it does not matter.
h = (js::HashNumber) NS_PTR_TO_INT32(Addition) >> 2;
} else {
XPCNativeInterface** Current = Set->GetInterfaceArray();
uint16_t count = Set->GetInterfaceCount();
if (Addition) {
count++;
@@ -81,34 +81,34 @@ HashNativeKey(PLDHashTable *table, const
/***************************************************************************/
// implement JSObject2WrappedJSMap...
void
JSObject2WrappedJSMap::FindDyingJSObjects(nsTArray<nsXPCWrappedJS*>* dying)
{
for (Map::Range r = mTable.all(); !r.empty(); r.popFront()) {
nsXPCWrappedJS* wrapper = r.front().value;
- NS_ASSERTION(wrapper, "found a null JS wrapper!");
+ MOZ_ASSERT(wrapper, "found a null JS wrapper!");
// walk the wrapper chain and find any whose JSObject is to be finalized
while (wrapper) {
if (wrapper->IsSubjectToFinalization() && wrapper->IsObjectAboutToBeFinalized())
dying->AppendElement(wrapper);
wrapper = wrapper->GetNextWrapper();
}
}
}
void
JSObject2WrappedJSMap::ShutdownMarker(JSRuntime* rt)
{
for (Map::Range r = mTable.all(); !r.empty(); r.popFront()) {
nsXPCWrappedJS* wrapper = r.front().value;
- NS_ASSERTION(wrapper, "found a null JS wrapper!");
- NS_ASSERTION(wrapper->IsValid(), "found an invalid JS wrapper!");
+ MOZ_ASSERT(wrapper, "found a null JS wrapper!");
+ MOZ_ASSERT(wrapper->IsValid(), "found an invalid JS wrapper!");
wrapper->SystemIsBeingShutDown(rt);
}
}
/***************************************************************************/
// implement Native2WrappedNativeMap...
// static
--- a/js/xpconnect/src/XPCMaps.h
+++ b/js/xpconnect/src/XPCMaps.h
@@ -137,20 +137,20 @@ public:
return wrapper;
}
inline void Remove(XPCWrappedNative* wrapper)
{
NS_PRECONDITION(wrapper,"bad param");
#ifdef DEBUG
XPCWrappedNative* wrapperInMap = Find(wrapper->GetIdentityObject());
- NS_ASSERTION(!wrapperInMap || wrapperInMap == wrapper,
- "About to remove a different wrapper with the same "
- "nsISupports identity! This will most likely cause serious "
- "problems!");
+ MOZ_ASSERT(!wrapperInMap || wrapperInMap == wrapper,
+ "About to remove a different wrapper with the same "
+ "nsISupports identity! This will most likely cause serious "
+ "problems!");
#endif
PL_DHashTableOperate(mTable, wrapper->GetIdentityObject(), PL_DHASH_REMOVE);
}
inline uint32_t Count() {return mTable->entryCount;}
inline uint32_t Enumerate(PLDHashEnumerator f, void *arg)
{return PL_DHashTableEnumerate(mTable, f, arg);}
--- a/js/xpconnect/src/XPCQuickStubs.cpp
+++ b/js/xpconnect/src/XPCQuickStubs.cpp
@@ -64,17 +64,17 @@ LookupInterfaceOrAncestor(uint32_t table
}
}
return entry;
}
static MOZ_ALWAYS_INLINE bool
HasBitInInterfacesBitmap(JSObject *obj, uint32_t interfaceBit)
{
- NS_ASSERTION(IS_WN_REFLECTOR(obj), "Not a wrapper?");
+ MOZ_ASSERT(IS_WN_REFLECTOR(obj), "Not a wrapper?");
XPCWrappedNativeJSClass *clasp =
(XPCWrappedNativeJSClass*)js::GetObjectClass(obj);
return (clasp->interfacesBitmap & (1 << interfaceBit)) != 0;
}
static void
PointerFinalize(JSFreeOp *fop, JSObject *obj)
@@ -193,18 +193,18 @@ GetMemberInfo(JSObject *obj, jsid member
}
}
}
static void
GetMethodInfo(JSContext *cx, jsval *vp, const char **ifaceNamep, jsid *memberIdp)
{
RootedObject funobj(cx, JSVAL_TO_OBJECT(JS_CALLEE(cx, vp)));
- NS_ASSERTION(JS_ObjectIsFunction(cx, funobj),
- "JSNative callee should be Function object");
+ MOZ_ASSERT(JS_ObjectIsFunction(cx, funobj),
+ "JSNative callee should be Function object");
RootedString str(cx, JS_GetFunctionId(JS_GetObjectFunction(funobj)));
RootedId methodId(cx, str ? INTERNED_STRING_TO_JSID(cx, str) : JSID_VOID);
GetMemberInfo(JSVAL_TO_OBJECT(vp[1]), methodId, ifaceNamep);
*memberIdp = methodId;
}
static bool
ThrowCallFailed(JSContext *cx, nsresult rv,
@@ -844,18 +844,18 @@ xpc_qsXPCOMObjectToJsval(JSContext *cx,
if (!JS_IsExceptionPending(cx))
xpc_qsThrow(cx, NS_FAILED(rv) ? rv : NS_ERROR_UNEXPECTED);
return false;
}
#ifdef DEBUG
JSObject* jsobj = JSVAL_TO_OBJECT(*rval);
if (jsobj && !js::GetObjectParent(jsobj))
- NS_ASSERTION(js::GetObjectClass(jsobj)->flags & JSCLASS_IS_GLOBAL,
- "Why did we recreate this wrapper?");
+ MOZ_ASSERT(js::GetObjectClass(jsobj)->flags & JSCLASS_IS_GLOBAL,
+ "Why did we recreate this wrapper?");
#endif
return true;
}
bool
xpc_qsVariantToJsval(JSContext *aCx,
nsIVariant *p,
@@ -878,11 +878,11 @@ xpc_qsVariantToJsval(JSContext *aCx,
void
xpc_qsAssertContextOK(JSContext *cx)
{
XPCJSContextStack* stack = XPCJSRuntime::Get()->GetJSContextStack();
JSContext *topJSContext = stack->Peek();
// This is what we're actually trying to assert here.
- NS_ASSERTION(cx == topJSContext, "wrong context on XPCJSContextStack!");
+ MOZ_ASSERT(cx == topJSContext, "wrong context on XPCJSContextStack!");
}
#endif
--- a/js/xpconnect/src/XPCVariant.cpp
+++ b/js/xpconnect/src/XPCVariant.cpp
@@ -49,17 +49,17 @@ XPCVariant::XPCVariant(JSContext* cx, js
} else
mReturnRawObject = false;
}
XPCTraceableVariant::~XPCTraceableVariant()
{
jsval val = GetJSValPreserveColor();
- NS_ASSERTION(JSVAL_IS_GCTHING(val), "Must be traceable or unlinked");
+ MOZ_ASSERT(JSVAL_IS_GCTHING(val), "Must be traceable or unlinked");
// If val is JSVAL_STRING, we don't need to clean anything up; simply
// removing the string from the root set is good.
if (!JSVAL_IS_STRING(val))
nsVariant::Cleanup(&mData);
if (!JSVAL_IS_NULL(val))
RemoveFromRootSet(nsXPConnect::GetRuntimeInstance()->GetMapLock());
@@ -200,35 +200,35 @@ XPCArrayHomogenizer::GetTypeForArray(JSC
} else if (val.isUndefined()) {
state = tVar;
break;
} else if (val.isNull()) {
type = tNull;
} else if (val.isString()) {
type = tStr;
} else {
- NS_ASSERTION(val.isObject(), "invalid type of jsval!");
+ MOZ_ASSERT(val.isObject(), "invalid type of jsval!");
jsobj = &val.toObject();
if (JS_IsArrayObject(cx, jsobj))
type = tArr;
else if (xpc_JSObjectIsID(cx, jsobj))
type = tID;
else
type = tISup;
}
- NS_ASSERTION(state != tErr, "bad state table!");
- NS_ASSERTION(type != tErr, "bad type!");
- NS_ASSERTION(type != tVar, "bad type!");
- NS_ASSERTION(type != tUnk, "bad type!");
+ MOZ_ASSERT(state != tErr, "bad state table!");
+ MOZ_ASSERT(type != tErr, "bad type!");
+ MOZ_ASSERT(type != tVar, "bad type!");
+ MOZ_ASSERT(type != tUnk, "bad type!");
state = StateTable[state][type];
- NS_ASSERTION(state != tErr, "bad state table!");
- NS_ASSERTION(state != tUnk, "bad state table!");
+ MOZ_ASSERT(state != tErr, "bad state table!");
+ MOZ_ASSERT(state != tUnk, "bad state table!");
if (state == tVar)
break;
}
switch (state) {
case tInt :
*resultType = nsXPTType((uint8_t)TD_INT32);
@@ -287,18 +287,18 @@ bool XPCVariant::InitializeData(JSContex
if (val.isString()) {
JSString* str = val.toString();
if (!str)
return false;
// Don't use nsVariant::SetFromWStringWithSize, because that will copy
// the data. Just handle this ourselves. Note that it's ok to not
// copy because we added mJSVal as a GC root.
- NS_ASSERTION(mData.mType == nsIDataType::VTYPE_EMPTY,
- "Why do we already have data?");
+ MOZ_ASSERT(mData.mType == nsIDataType::VTYPE_EMPTY,
+ "Why do we already have data?");
// Despite the fact that the variant holds the length, there are
// implicit assumptions that mWStringValue[mWStringLength] == 0
size_t length;
const jschar *chars = JS_GetStringCharsZAndLength(cx, str, &length);
if (!chars)
return false;
@@ -307,17 +307,17 @@ bool XPCVariant::InitializeData(JSContex
// uint32_t is not valid on some platforms.
mData.u.wstr.mWStringLength = (uint32_t)length;
mData.mType = nsIDataType::VTYPE_WSTRING_SIZE_IS;
return true;
}
// leaving only JSObject...
- NS_ASSERTION(val.isObject(), "invalid type of jsval!");
+ MOZ_ASSERT(val.isObject(), "invalid type of jsval!");
RootedObject jsobj(cx, &val.toObject());
// Let's see if it is a xpcJSID.
const nsID* id = xpc_JSObjectToID(cx, jsobj);
if (id)
return NS_SUCCEEDED(nsVariant::SetFromID(&mData, *id));
@@ -393,19 +393,19 @@ XPCVariant::VariantDataToJS(nsIVariant*
if (!JS_WrapValue(cx, realVal.address()))
return false;
*pJSVal = realVal;
return true;
}
nsCOMPtr<XPCVariant> xpcvariant = do_QueryInterface(variant);
if (xpcvariant && xpcvariant->mReturnRawObject) {
- NS_ASSERTION(type == nsIDataType::VTYPE_INTERFACE ||
- type == nsIDataType::VTYPE_INTERFACE_IS,
- "Weird variant");
+ MOZ_ASSERT(type == nsIDataType::VTYPE_INTERFACE ||
+ type == nsIDataType::VTYPE_INTERFACE_IS,
+ "Weird variant");
if (!JS_WrapValue(cx, realVal.address()))
return false;
*pJSVal = realVal;
return true;
}
// else, it's an object and we really need to double wrap it if we've
--- a/js/xpconnect/src/XPCWrappedJS.cpp
+++ b/js/xpconnect/src/XPCWrappedJS.cpp
@@ -18,18 +18,17 @@ using namespace mozilla;
// NOTE: much of the fancy footwork is done in xpcstubs.cpp
NS_IMETHODIMP
NS_CYCLE_COLLECTION_CLASSNAME(nsXPCWrappedJS)::Traverse
(void *p, nsCycleCollectionTraversalCallback &cb)
{
nsISupports *s = static_cast<nsISupports*>(p);
- NS_ASSERTION(CheckForRightISupports(s),
- "not the nsISupports pointer we expect");
+ MOZ_ASSERT(CheckForRightISupports(s), "not the nsISupports pointer we expect");
nsXPCWrappedJS *tmp = Downcast(s);
nsrefcnt refcnt = tmp->mRefCnt.get();
if (cb.WantDebugInfo()) {
char name[72];
if (tmp->GetClass())
JS_snprintf(name, sizeof(name), "nsXPCWrappedJS (%s)",
tmp->GetClass()->GetInterfaceName());
@@ -70,17 +69,17 @@ NS_IMPL_CYCLE_COLLECTION_CLASS(nsXPCWrap
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsXPCWrappedJS)
tmp->Unlink();
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
NS_IMETHODIMP
nsXPCWrappedJS::AggregatedQueryInterface(REFNSIID aIID, void** aInstancePtr)
{
- NS_ASSERTION(IsAggregatedToNative(), "bad AggregatedQueryInterface call");
+ MOZ_ASSERT(IsAggregatedToNative(), "bad AggregatedQueryInterface call");
if (!IsValid())
return NS_ERROR_UNEXPECTED;
// Put this here rather that in DelegatedQueryInterface because it needs
// to be in QueryInterface before the possible delegation to 'outer', but
// we don't want to do this check twice in one call in the normal case:
// once in QueryInterface and once in DelegatedQueryInterface.
@@ -176,18 +175,17 @@ nsXPCWrappedJS::Release(void)
NS_PRECONDITION(0 != mRefCnt, "dup release");
if (mMainThreadOnly && !NS_IsMainThread()) {
// We'd like to abort here, but this can happen if someone uses a proxy
// for the nsXPCWrappedJS.
nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
// If we can't get the main thread anymore we just leak, but this really
// shouldn't happen.
- NS_ASSERTION(mainThread,
- "Can't get main thread, leaking nsXPCWrappedJS!");
+ MOZ_ASSERT(mainThread, "Can't get main thread, leaking nsXPCWrappedJS!");
if (mainThread) {
NS_ProxyRelease(mainThread,
static_cast<nsIXPConnectWrappedJS*>(this));
}
return mRefCnt;
}
// need to take the map lock here to prevent GetNewOrUsed from trying
@@ -216,17 +214,17 @@ do_decrement:
goto do_decrement;
}
return cnt;
}
void
nsXPCWrappedJS::TraceJS(JSTracer* trc)
{
- NS_ASSERTION(mRefCnt >= 2 && IsValid(), "must be strongly referenced");
+ MOZ_ASSERT(mRefCnt >= 2 && IsValid(), "must be strongly referenced");
JS_SET_TRACING_DETAILS(trc, GetTraceName, this, 0);
JS_CallHeapObjectTracer(trc, &mJSObj, "nsXPCWrappedJS::mJSObj");
}
// static
void
nsXPCWrappedJS::GetTraceName(JSTracer* trc, char *buf, size_t bufsize)
{
@@ -289,17 +287,17 @@ nsXPCWrappedJS::GetNewOrUsed(JS::HandleO
nsXPCWrappedJS* root = nullptr;
nsXPCWrappedJS* wrapper = nullptr;
nsXPCWrappedJSClass* clazz = nullptr;
XPCJSRuntime* rt = nsXPConnect::GetRuntimeInstance();
bool release_root = false;
map = rt->GetWrappedJSMap();
if (!map) {
- NS_ASSERTION(map,"bad map");
+ MOZ_ASSERT(map,"bad map");
return NS_ERROR_FAILURE;
}
nsXPCWrappedJSClass::GetNewOrUsed(cx, aIID, &clazz);
if (!clazz)
return NS_ERROR_FAILURE;
// from here on we need to return through 'return_wrapper'
@@ -379,18 +377,18 @@ nsXPCWrappedJS::GetNewOrUsed(JS::HandleO
map->Remove(root);
goto return_wrapper;
}
}
}
// at this point we have a root and may need to build the specific wrapper
- NS_ASSERTION(root,"bad root");
- NS_ASSERTION(clazz,"bad clazz");
+ MOZ_ASSERT(root,"bad root");
+ MOZ_ASSERT(clazz,"bad clazz");
if (!wrapper) {
wrapper = new nsXPCWrappedJS(cx, jsObj, clazz, root, aOuter);
if (!wrapper)
goto return_wrapper;
#if DEBUG_xpc_leaks
printf("Created nsXPCWrappedJS %p, JSObject is %p\n",
(void*)wrapper, (void*)jsObj);
@@ -493,17 +491,17 @@ nsXPCWrappedJS::Unlink()
// unlink this wrapper
nsXPCWrappedJS* cur = mRoot;
while (1) {
if (cur->mNext == this) {
cur->mNext = mNext;
break;
}
cur = cur->mNext;
- NS_ASSERTION(cur, "failed to find wrapper in its own chain");
+ MOZ_ASSERT(cur, "failed to find wrapper in its own chain");
}
// let the root go
NS_RELEASE(mRoot);
}
NS_IF_RELEASE(mClass);
if (mOuter) {
XPCJSRuntime* rt = nsXPConnect::GetRuntimeInstance();
@@ -529,33 +527,33 @@ nsXPCWrappedJS::Find(REFNSIID aIID)
return nullptr;
}
// check if asking for an interface that some wrapper in the chain inherits from
nsXPCWrappedJS*
nsXPCWrappedJS::FindInherited(REFNSIID aIID)
{
- NS_ASSERTION(!aIID.Equals(NS_GET_IID(nsISupports)), "bad call sequence");
+ MOZ_ASSERT(!aIID.Equals(NS_GET_IID(nsISupports)), "bad call sequence");
for (nsXPCWrappedJS* cur = mRoot; cur; cur = cur->mNext) {
bool found;
if (NS_SUCCEEDED(cur->GetClass()->GetInterfaceInfo()->
HasAncestor(&aIID, &found)) && found)
return cur;
}
return nullptr;
}
NS_IMETHODIMP
nsXPCWrappedJS::GetInterfaceInfo(nsIInterfaceInfo** info)
{
- NS_ASSERTION(GetClass(), "wrapper without class");
- NS_ASSERTION(GetClass()->GetInterfaceInfo(), "wrapper class without interface");
+ MOZ_ASSERT(GetClass(), "wrapper without class");
+ MOZ_ASSERT(GetClass()->GetInterfaceInfo(), "wrapper class without interface");
// Since failing to get this info will crash some platforms(!), we keep
// mClass valid at shutdown time.
if (!(*info = GetClass()->GetInterfaceInfo()))
return NS_ERROR_UNEXPECTED;
NS_ADDREF(*info);
return NS_OK;
--- a/js/xpconnect/src/XPCWrappedJSClass.cpp
+++ b/js/xpconnect/src/XPCWrappedJSClass.cpp
@@ -261,18 +261,18 @@ nsXPCWrappedJSClass::CallQueryInterfaceO
JS_SetOptions(cx, JS_GetOptions(cx) | JSOPTION_DONT_REPORT_UNCAUGHT);
jsval args[1] = {OBJECT_TO_JSVAL(id)};
success = JS_CallFunctionValue(cx, jsobj, fun, 1, args, retval.address());
JS_SetOptions(cx, oldOpts);
if (!success) {
- NS_ASSERTION(JS_IsExceptionPending(cx),
- "JS failed without setting an exception!");
+ MOZ_ASSERT(JS_IsExceptionPending(cx),
+ "JS failed without setting an exception!");
RootedValue jsexception(cx, NullValue());
if (JS_GetPendingException(cx, jsexception.address())) {
nsresult rv;
if (jsexception.isObject()) {
// XPConnect may have constructed an object to represent a
// C++ QI failure. See if that is the case.
@@ -838,18 +838,18 @@ nsXPCWrappedJSClass::GetArraySizeFromPar
rv = mInfo->GetSizeIsArgNumberForParam(methodIndex, ¶m, 0, &argnum);
if (NS_FAILED(rv))
return false;
const nsXPTParamInfo& arg_param = method->params[argnum];
// This should be enforced by the xpidl compiler, but it's not.
// See bug 695235.
- NS_ABORT_IF_FALSE(arg_param.GetType().TagPart() == nsXPTType::T_U32,
- "size_is references parameter of invalid type.");
+ MOZ_ASSERT(arg_param.GetType().TagPart() == nsXPTType::T_U32,
+ "size_is references parameter of invalid type.");
if (arg_param.IsIndirect())
*result = *(uint32_t*)nativeParams[argnum].val.p;
else
*result = nativeParams[argnum].val.u32;
return true;
}
@@ -918,17 +918,17 @@ nsXPCWrappedJSClass::CleanupPointerArray
}
}
}
void
nsXPCWrappedJSClass::CleanupPointerTypeObject(const nsXPTType& type,
void** pp)
{
- NS_ASSERTION(pp,"null pointer");
+ MOZ_ASSERT(pp,"null pointer");
if (type.IsInterfacePointer()) {
nsISupports* p = *((nsISupports**)pp);
if (p) p->Release();
} else {
void* p = *((void**)pp);
if (p) nsMemory::Free(p);
}
}
@@ -1486,17 +1486,17 @@ pre_call_clean_up:
// Convert independent params only.
// When we later convert the dependent params (if any) we will know that
// the params upon which they depend will have already been converted -
// regardless of ordering.
foundDependentParam = false;
for (i = 0; i < paramCount; i++) {
const nsXPTParamInfo& param = info->params[i];
- NS_ABORT_IF_FALSE(!param.IsShared(), "[shared] implies [noscript]!");
+ MOZ_ASSERT(!param.IsShared(), "[shared] implies [noscript]!");
if (!param.IsOut() && !param.IsDipper())
continue;
const nsXPTType& type = param.GetType();
if (type.IsDependent()) {
foundDependentParam = true;
continue;
}
--- a/js/xpconnect/src/XPCWrappedNative.cpp
+++ b/js/xpconnect/src/XPCWrappedNative.cpp
@@ -30,19 +30,19 @@
using namespace xpc;
using namespace mozilla;
using namespace mozilla::dom;
using namespace JS;
bool
xpc_OkToHandOutWrapper(nsWrapperCache *cache)
{
- NS_ABORT_IF_FALSE(cache->GetWrapper(), "Must have wrapper");
- NS_ABORT_IF_FALSE(IS_WN_REFLECTOR(cache->GetWrapper()),
- "Must have XPCWrappedNative wrapper");
+ MOZ_ASSERT(cache->GetWrapper(), "Must have wrapper");
+ MOZ_ASSERT(IS_WN_REFLECTOR(cache->GetWrapper()),
+ "Must have XPCWrappedNative wrapper");
return !XPCWrappedNative::Get(cache->GetWrapper())->NeedsSOW();
}
/***************************************************************************/
NS_IMPL_CYCLE_COLLECTION_CLASS(XPCWrappedNative)
NS_IMETHODIMP
@@ -420,24 +420,24 @@ nsresult
XPCWrappedNative::GetNewOrUsed(xpcObjectHelper& helper,
XPCWrappedNativeScope* Scope,
XPCNativeInterface* Interface,
XPCWrappedNative** resultWrapper)
{
AutoJSContext cx;
nsWrapperCache *cache = helper.GetWrapperCache();
- NS_ASSERTION(!cache || !cache->GetWrapperPreserveColor(),
- "We assume the caller already checked if it could get the "
- "wrapper from the cache.");
+ MOZ_ASSERT(!cache || !cache->GetWrapperPreserveColor(),
+ "We assume the caller already checked if it could get the "
+ "wrapper from the cache.");
nsresult rv;
- NS_ASSERTION(!Scope->GetRuntime()->GetThreadRunningGC(),
- "XPCWrappedNative::GetNewOrUsed called during GC");
+ MOZ_ASSERT(!Scope->GetRuntime()->GetThreadRunningGC(),
+ "XPCWrappedNative::GetNewOrUsed called during GC");
nsISupports *identity = helper.GetCanonical();
if (!identity) {
NS_ERROR("This XPCOM object fails in QueryInterface to nsISupports!");
return NS_ERROR_FAILURE;
}
@@ -452,17 +452,17 @@ XPCWrappedNative::GetNewOrUsed(xpcObject
{ // scoped lock
XPCAutoLock lock(mapLock);
wrapper = map->Find(identity);
}
if (wrapper) {
if (Interface &&
!wrapper->FindTearOff(Interface, false, &rv)) {
- NS_ASSERTION(NS_FAILED(rv), "returning NS_OK on failure");
+ MOZ_ASSERT(NS_FAILED(rv), "returning NS_OK on failure");
return rv;
}
*resultWrapper = wrapper.forget().get();
return NS_OK;
}
// There is a chance that the object wants to have the self-same JSObject
// reflection regardless of the scope into which we are reflecting it.
@@ -518,18 +518,18 @@ XPCWrappedNative::GetNewOrUsed(xpcObject
parent, parent.address());
if (NS_FAILED(rv))
return rv;
if (rv == NS_SUCCESS_CHROME_ACCESS_ONLY)
needsSOW = true;
rv = NS_OK;
- NS_ASSERTION(!xpc::WrapperFactory::IsXrayWrapper(parent),
- "Xray wrapper being used to parent XPCWrappedNative?");
+ MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(parent),
+ "Xray wrapper being used to parent XPCWrappedNative?");
ac.construct(static_cast<JSContext*>(cx), parent);
if (parent != plannedParent) {
XPCWrappedNativeScope* betterScope = GetObjectScope(parent);
if (betterScope != Scope)
return GetNewOrUsed(helper, betterScope, Interface, resultWrapper);
@@ -547,17 +547,17 @@ XPCWrappedNative::GetNewOrUsed(xpcObject
} else {
// scoped lock
XPCAutoLock lock(mapLock);
wrapper = map->Find(identity);
}
if (wrapper) {
if (Interface && !wrapper->FindTearOff(Interface, false, &rv)) {
- NS_ASSERTION(NS_FAILED(rv), "returning NS_OK on failure");
+ MOZ_ASSERT(NS_FAILED(rv), "returning NS_OK on failure");
return rv;
}
*resultWrapper = wrapper.forget().get();
return NS_OK;
}
} else {
ac.construct(static_cast<JSContext*>(cx), parent);
@@ -597,30 +597,30 @@ XPCWrappedNative::GetNewOrUsed(xpcObject
return NS_ERROR_FAILURE;
wrapper =
new XPCWrappedNative(helper.forgetCanonical(), Scope, set);
DEBUG_ReportShadowedMembers(set, wrapper, nullptr);
}
- NS_ASSERTION(!xpc::WrapperFactory::IsXrayWrapper(parent),
- "Xray wrapper being used to parent XPCWrappedNative?");
+ MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(parent),
+ "Xray wrapper being used to parent XPCWrappedNative?");
// We use an AutoMarkingPtr here because it is possible for JS gc to happen
// after we have Init'd the wrapper but *before* we add it to the hashtable.
// This would cause the mSet to get collected and we'd later crash. I've
// *seen* this happen.
AutoMarkingWrappedNativePtr wrapperMarker(cx, wrapper);
if (!wrapper->Init(parent, &sciWrapper))
return NS_ERROR_FAILURE;
if (Interface && !wrapper->FindTearOff(Interface, false, &rv)) {
- NS_ASSERTION(NS_FAILED(rv), "returning NS_OK on failure");
+ MOZ_ASSERT(NS_FAILED(rv), "returning NS_OK on failure");
return rv;
}
if (needsSOW)
wrapper->SetNeedsSOW();
if (needsCOW)
wrapper->SetNeedsCOW();
@@ -635,17 +635,17 @@ FinishCreate(XPCWrappedNativeScope* Scop
XPCWrappedNative** resultWrapper)
{
AutoJSContext cx;
MOZ_ASSERT(inWrapper);
#if DEBUG_xpc_leaks
{
char* s = wrapper->ToString();
- NS_ASSERTION(wrapper->IsValid(), "eh?");
+ MOZ_ASSERT(wrapper->IsValid(), "eh?");
printf("Created wrapped native %s, flat JSObject is %p\n",
s, (void*)wrapper->GetFlatJSObjectNoMark());
if (s)
JS_smprintf_free(s);
}
#endif
XPCLock* mapLock = Scope->GetRuntime()->GetMapLock();
@@ -661,20 +661,20 @@ FinishCreate(XPCWrappedNativeScope* Scop
XPCAutoLock lock(mapLock);
wrapper = map->Add(inWrapper);
if (!wrapper)
return NS_ERROR_FAILURE;
}
if (wrapper == inWrapper) {
JSObject *flat = wrapper->GetFlatJSObject();
- NS_ASSERTION(!cache || !cache->GetWrapperPreserveColor() ||
- flat == cache->GetWrapperPreserveColor(),
- "This object has a cached wrapper that's different from "
- "the JSObject held by its native wrapper?");
+ MOZ_ASSERT(!cache || !cache->GetWrapperPreserveColor() ||
+ flat == cache->GetWrapperPreserveColor(),
+ "This object has a cached wrapper that's different from "
+ "the JSObject held by its native wrapper?");
if (cache && !cache->GetWrapperPreserveColor())
cache->SetWrapper(flat);
// Our newly created wrapper is the one that we just added to the table.
// All is well. Call PostCreate as necessary.
XPCNativeScriptableInfo* si = wrapper->GetScriptableInfo();
if (si && si->GetFlags().WantPostCreate()) {
@@ -717,17 +717,17 @@ FinishCreate(XPCWrappedNativeScope* Scop
// static
nsresult
XPCWrappedNative::GetUsedOnly(nsISupports* Object,
XPCWrappedNativeScope* Scope,
XPCNativeInterface* Interface,
XPCWrappedNative** resultWrapper)
{
AutoJSContext cx;
- NS_ASSERTION(Object, "XPCWrappedNative::GetUsedOnly was called with a null Object");
+ MOZ_ASSERT(Object, "XPCWrappedNative::GetUsedOnly was called with a null Object");
nsRefPtr<XPCWrappedNative> wrapper;
nsWrapperCache* cache = nullptr;
CallQueryInterface(Object, &cache);
if (cache) {
RootedObject flat(cx, cache->GetWrapper());
if (!flat) {
*resultWrapper = nullptr;
@@ -751,17 +751,17 @@ XPCWrappedNative::GetUsedOnly(nsISupport
*resultWrapper = nullptr;
return NS_OK;
}
}
}
nsresult rv;
if (Interface && !wrapper->FindTearOff(Interface, false, &rv)) {
- NS_ASSERTION(NS_FAILED(rv), "returning NS_OK on failure");
+ MOZ_ASSERT(NS_FAILED(rv), "returning NS_OK on failure");
return rv;
}
wrapper.forget(resultWrapper);
return NS_OK;
}
// This ctor is used if this object will have a proto.
@@ -769,36 +769,36 @@ XPCWrappedNative::XPCWrappedNative(alrea
XPCWrappedNativeProto* aProto)
: mMaybeProto(aProto),
mSet(aProto->GetSet()),
mScriptableInfo(nullptr)
{
mIdentity = aIdentity.get();
mFlatJSObject.setFlags(FLAT_JS_OBJECT_VALID);
- NS_ASSERTION(mMaybeProto, "bad ctor param");
- NS_ASSERTION(mSet, "bad ctor param");
+ MOZ_ASSERT(mMaybeProto, "bad ctor param");
+ MOZ_ASSERT(mSet, "bad ctor param");
DEBUG_TrackNewWrapper(this);
}
// This ctor is used if this object will NOT have a proto.
XPCWrappedNative::XPCWrappedNative(already_AddRefed<nsISupports> aIdentity,
XPCWrappedNativeScope* aScope,
XPCNativeSet* aSet)
: mMaybeScope(TagScope(aScope)),
mSet(aSet),
mScriptableInfo(nullptr)
{
mIdentity = aIdentity.get();
mFlatJSObject.setFlags(FLAT_JS_OBJECT_VALID);
- NS_ASSERTION(aScope, "bad ctor param");
- NS_ASSERTION(aSet, "bad ctor param");
+ MOZ_ASSERT(aScope, "bad ctor param");
+ MOZ_ASSERT(aSet, "bad ctor param");
DEBUG_TrackNewWrapper(this);
}
XPCWrappedNative::~XPCWrappedNative()
{
DEBUG_TrackDeleteWrapper(this);
@@ -854,48 +854,48 @@ XPCWrappedNative::Destroy()
}
mMaybeScope = nullptr;
}
void
XPCWrappedNative::UpdateScriptableInfo(XPCNativeScriptableInfo *si)
{
- NS_ASSERTION(mScriptableInfo, "UpdateScriptableInfo expects an existing scriptable info");
+ MOZ_ASSERT(mScriptableInfo, "UpdateScriptableInfo expects an existing scriptable info");
// Write barrier for incremental GC.
JSRuntime* rt = GetRuntime()->Runtime();
if (IsIncrementalBarrierNeeded(rt))
mScriptableInfo->Mark();
mScriptableInfo = si;
}
void
XPCWrappedNative::SetProto(XPCWrappedNativeProto* p)
{
- NS_ASSERTION(!IsWrapperExpired(), "bad ptr!");
+ MOZ_ASSERT(!IsWrapperExpired(), "bad ptr!");
MOZ_ASSERT(HasProto());
// Write barrier for incremental GC.
JSRuntime* rt = GetRuntime()->Runtime();
GetProto()->WriteBarrierPre(rt);
mMaybeProto = p;
}
// This is factored out so that it can be called publicly
// static
void
XPCWrappedNative::GatherProtoScriptableCreateInfo(nsIClassInfo* classInfo,
XPCNativeScriptableCreateInfo& sciProto)
{
- NS_ASSERTION(classInfo, "bad param");
- NS_ASSERTION(!sciProto.GetCallback(), "bad param");
+ MOZ_ASSERT(classInfo, "bad param");
+ MOZ_ASSERT(!sciProto.GetCallback(), "bad param");
nsXPCClassInfo *classInfoHelper = nullptr;
CallQueryInterface(classInfo, &classInfoHelper);
if (classInfoHelper) {
nsCOMPtr<nsIXPCScriptable> helper =
dont_AddRef(static_cast<nsIXPCScriptable*>(classInfoHelper));
uint32_t flags = classInfoHelper->GetScriptableFlags();
sciProto.SetCallback(helper.forget());
@@ -920,17 +920,17 @@ XPCWrappedNative::GatherProtoScriptableC
// static
const XPCNativeScriptableCreateInfo&
XPCWrappedNative::GatherScriptableCreateInfo(nsISupports* obj,
nsIClassInfo* classInfo,
XPCNativeScriptableCreateInfo& sciProto,
XPCNativeScriptableCreateInfo& sciWrapper)
{
- NS_ASSERTION(!sciWrapper.GetCallback(), "bad param");
+ MOZ_ASSERT(!sciWrapper.GetCallback(), "bad param");
// Get the class scriptable helper (if present)
if (classInfo) {
GatherProtoScriptableCreateInfo(classInfo, sciProto);
if (sciProto.GetFlags().DontAskInstanceForScriptable())
return sciProto;
}
@@ -940,55 +940,55 @@ XPCWrappedNative::GatherScriptableCreate
if (helper) {
uint32_t flags = helper->GetScriptableFlags();
sciWrapper.SetCallback(helper.forget());
sciWrapper.SetFlags(flags);
// A whole series of assertions to catch bad uses of scriptable flags on
// the siWrapper...
- NS_ASSERTION(!(sciWrapper.GetFlags().WantPreCreate() &&
- !sciProto.GetFlags().WantPreCreate()),
- "Can't set WANT_PRECREATE on an instance scriptable "
- "without also setting it on the class scriptable");
-
- NS_ASSERTION(!(sciWrapper.GetFlags().DontEnumStaticProps() &&
- !sciProto.GetFlags().DontEnumStaticProps() &&
- sciProto.GetCallback()),
- "Can't set DONT_ENUM_STATIC_PROPS on an instance scriptable "
- "without also setting it on the class scriptable (if present and shared)");
-
- NS_ASSERTION(!(sciWrapper.GetFlags().DontEnumQueryInterface() &&
- !sciProto.GetFlags().DontEnumQueryInterface() &&
- sciProto.GetCallback()),
- "Can't set DONT_ENUM_QUERY_INTERFACE on an instance scriptable "
- "without also setting it on the class scriptable (if present and shared)");
-
- NS_ASSERTION(!(sciWrapper.GetFlags().DontAskInstanceForScriptable() &&
- !sciProto.GetFlags().DontAskInstanceForScriptable()),
- "Can't set DONT_ASK_INSTANCE_FOR_SCRIPTABLE on an instance scriptable "
- "without also setting it on the class scriptable");
-
- NS_ASSERTION(!(sciWrapper.GetFlags().ClassInfoInterfacesOnly() &&
- !sciProto.GetFlags().ClassInfoInterfacesOnly() &&
- sciProto.GetCallback()),
- "Can't set CLASSINFO_INTERFACES_ONLY on an instance scriptable "
- "without also setting it on the class scriptable (if present and shared)");
-
- NS_ASSERTION(!(sciWrapper.GetFlags().AllowPropModsDuringResolve() &&
- !sciProto.GetFlags().AllowPropModsDuringResolve() &&
- sciProto.GetCallback()),
- "Can't set ALLOW_PROP_MODS_DURING_RESOLVE on an instance scriptable "
- "without also setting it on the class scriptable (if present and shared)");
-
- NS_ASSERTION(!(sciWrapper.GetFlags().AllowPropModsToPrototype() &&
- !sciProto.GetFlags().AllowPropModsToPrototype() &&
- sciProto.GetCallback()),
- "Can't set ALLOW_PROP_MODS_TO_PROTOTYPE on an instance scriptable "
- "without also setting it on the class scriptable (if present and shared)");
+ MOZ_ASSERT(!(sciWrapper.GetFlags().WantPreCreate() &&
+ !sciProto.GetFlags().WantPreCreate()),
+ "Can't set WANT_PRECREATE on an instance scriptable "
+ "without also setting it on the class scriptable");
+
+ MOZ_ASSERT(!(sciWrapper.GetFlags().DontEnumStaticProps() &&
+ !sciProto.GetFlags().DontEnumStaticProps() &&
+ sciProto.GetCallback()),
+ "Can't set DONT_ENUM_STATIC_PROPS on an instance scriptable "
+ "without also setting it on the class scriptable (if present and shared)");
+
+ MOZ_ASSERT(!(sciWrapper.GetFlags().DontEnumQueryInterface() &&
+ !sciProto.GetFlags().DontEnumQueryInterface() &&
+ sciProto.GetCallback()),
+ "Can't set DONT_ENUM_QUERY_INTERFACE on an instance scriptable "
+ "without also setting it on the class scriptable (if present and shared)");
+
+ MOZ_ASSERT(!(sciWrapper.GetFlags().DontAskInstanceForScriptable() &&
+ !sciProto.GetFlags().DontAskInstanceForScriptable()),
+ "Can't set DONT_ASK_INSTANCE_FOR_SCRIPTABLE on an instance scriptable "
+ "without also setting it on the class scriptable");
+
+ MOZ_ASSERT(!(sciWrapper.GetFlags().ClassInfoInterfacesOnly() &&
+ !sciProto.GetFlags().ClassInfoInterfacesOnly() &&
+ sciProto.GetCallback()),
+ "Can't set CLASSINFO_INTERFACES_ONLY on an instance scriptable "
+ "without also setting it on the class scriptable (if present and shared)");
+
+ MOZ_ASSERT(!(sciWrapper.GetFlags().AllowPropModsDuringResolve() &&
+ !sciProto.GetFlags().AllowPropModsDuringResolve() &&
+ sciProto.GetCallback()),
+ "Can't set ALLOW_PROP_MODS_DURING_RESOLVE on an instance scriptable "
+ "without also setting it on the class scriptable (if present and shared)");
+
+ MOZ_ASSERT(!(sciWrapper.GetFlags().AllowPropModsToPrototype() &&
+ !sciProto.GetFlags().AllowPropModsToPrototype() &&
+ sciProto.GetCallback()),
+ "Can't set ALLOW_PROP_MODS_TO_PROTOTYPE on an instance scriptable "
+ "without also setting it on the class scriptable (if present and shared)");
return sciWrapper;
}
return sciProto;
}
bool
@@ -1016,27 +1016,27 @@ XPCWrappedNative::Init(HandleObject pare
// create our flatJSObject
JSClass* jsclazz = si ? si->GetJSClass() : Jsvalify(&XPC_WN_NoHelper_JSClass.base);
// We should have the global jsclass flag if and only if we're a global.
MOZ_ASSERT_IF(si, !!si->GetFlags().IsGlobalObject() == !!(jsclazz->flags & JSCLASS_IS_GLOBAL));
- NS_ASSERTION(jsclazz &&
- jsclazz->name &&
- jsclazz->flags &&
- jsclazz->addProperty &&
- jsclazz->delProperty &&
- jsclazz->getProperty &&
- jsclazz->setProperty &&
- jsclazz->enumerate &&
- jsclazz->resolve &&
- jsclazz->convert &&
- jsclazz->finalize, "bad class");
+ MOZ_ASSERT(jsclazz &&
+ jsclazz->name &&
+ jsclazz->flags &&
+ jsclazz->addProperty &&
+ jsclazz->delProperty &&
+ jsclazz->getProperty &&
+ jsclazz->setProperty &&
+ jsclazz->enumerate &&
+ jsclazz->resolve &&
+ jsclazz->convert &&
+ jsclazz->finalize, "bad class");
JSObject* protoJSObject = HasProto() ?
GetProto()->GetJSProtoObject() :
JS_GetObjectPrototype(cx, parent);
if (!protoJSObject) {
return false;
}
@@ -1059,17 +1059,17 @@ XPCWrappedNative::FinishInit()
// For all WNs, we want to make sure that the expando chain slot starts out
// as null.
JS_SetReservedSlot(mFlatJSObject, WN_XRAYEXPANDOCHAIN_SLOT, JSVAL_NULL);
// This reference will be released when mFlatJSObject is finalized.
// Since this reference will push the refcount to 2 it will also root
// mFlatJSObject;
- NS_ASSERTION(1 == mRefCnt, "unexpected refcount value");
+ MOZ_ASSERT(1 == mRefCnt, "unexpected refcount value");
NS_ADDREF(this);
if (mScriptableInfo && mScriptableInfo->GetFlags().WantCreate() &&
NS_FAILED(mScriptableInfo->GetCallback()->Create(this, cx,
mFlatJSObject))) {
return false;
}
@@ -1164,18 +1164,18 @@ XPCWrappedNative::FlatJSObjectFinalized(
to->JSObjectFinalized();
}
// We also need to release any native pointers held...
nsISupports* obj = to->GetNative();
if (obj) {
#ifdef XP_WIN
// Try to detect free'd pointer
- NS_ASSERTION(*(int*)obj != 0xdddddddd, "bad pointer!");
- NS_ASSERTION(*(int*)obj != 0, "bad pointer!");
+ MOZ_ASSERT(*(int*)obj != 0xdddddddd, "bad pointer!");
+ MOZ_ASSERT(*(int*)obj != 0, "bad pointer!");
#endif
XPCJSRuntime* rt = GetRuntime();
if (rt) {
nsContentUtils::DeferredFinalize(obj);
} else {
obj->Release();
}
to->SetNative(nullptr);
@@ -1188,21 +1188,21 @@ XPCWrappedNative::FlatJSObjectFinalized(
nsWrapperCache *cache = nullptr;
CallQueryInterface(mIdentity, &cache);
if (cache)
cache->ClearWrapper();
mFlatJSObject = nullptr;
mFlatJSObject.unsetFlags(FLAT_JS_OBJECT_VALID);
- NS_ASSERTION(mIdentity, "bad pointer!");
+ MOZ_ASSERT(mIdentity, "bad pointer!");
#ifdef XP_WIN
// Try to detect free'd pointer
- NS_ASSERTION(*(int*)mIdentity != 0xdddddddd, "bad pointer!");
- NS_ASSERTION(*(int*)mIdentity != 0, "bad pointer!");
+ MOZ_ASSERT(*(int*)mIdentity != 0xdddddddd, "bad pointer!");
+ MOZ_ASSERT(*(int*)mIdentity != 0, "bad pointer!");
#endif
if (IsWrapperExpired()) {
Destroy();
}
// Note that it's not safe to touch mNativeWrapper here since it's
// likely that it has already been finalized.
@@ -1316,17 +1316,17 @@ XPCWrappedNative::ReparentWrapperIfFound
nsRefPtr<XPCWrappedNative> wrapper;
RootedObject flat(cx);
nsWrapperCache* cache = nullptr;
CallQueryInterface(aCOMObj, &cache);
if (cache) {
flat = cache->GetWrapper();
if (flat) {
wrapper = XPCWrappedNative::Get(flat);
- NS_ASSERTION(wrapper->GetScope() == aOldScope,
+ MOZ_ASSERT(wrapper->GetScope() == aOldScope,
"Incorrect scope passed");
}
} else {
rv = XPCWrappedNative::GetUsedOnly(aCOMObj, aOldScope, iface,
getter_AddRefs(wrapper));
if (NS_FAILED(rv))
return rv;
@@ -1350,17 +1350,17 @@ XPCWrappedNative::ReparentWrapperIfFound
if (aOldScope != aNewScope) {
// Oh, so now we need to move the wrapper to a different scope.
AutoMarkingWrappedNativeProtoPtr oldProto(cx);
AutoMarkingWrappedNativeProtoPtr newProto(cx);
// Cross-scope means cross-compartment.
MOZ_ASSERT(js::GetObjectCompartment(aOldScope->GetGlobalJSObject()) !=
js::GetObjectCompartment(aNewScope->GetGlobalJSObject()));
- NS_ASSERTION(aNewParent, "won't be able to find the new parent");
+ MOZ_ASSERT(aNewParent, "won't be able to find the new parent");
if (wrapper->HasProto()) {
oldProto = wrapper->GetProto();
XPCNativeScriptableInfo *info = oldProto->GetScriptableInfo();
XPCNativeScriptableCreateInfo ci(*info);
newProto =
XPCWrappedNativeProto::GetNewOrUsed(aNewScope,
oldProto->GetClassInfo(),
@@ -1441,20 +1441,20 @@ XPCWrappedNative::ReparentWrapperIfFound
if (wrapper->mScriptableInfo &&
wrapper->mScriptableInfo == oldProto->GetScriptableInfo()) {
// The new proto had better have the same JSClass stuff as
// the old one! We maintain a runtime wide unique map of
// this stuff. So, if these don't match then the caller is
// doing something bad here.
- NS_ASSERTION(oldProto->GetScriptableInfo()->GetScriptableShared() ==
- newProto->GetScriptableInfo()->GetScriptableShared(),
- "Changing proto is also changing JSObject Classname or "
- "helper's nsIXPScriptable flags. This is not allowed!");
+ MOZ_ASSERT(oldProto->GetScriptableInfo()->GetScriptableShared() ==
+ newProto->GetScriptableInfo()->GetScriptableShared(),
+ "Changing proto is also changing JSObject Classname or "
+ "helper's nsIXPScriptable flags. This is not allowed!");
wrapper->UpdateScriptableInfo(newProto->GetScriptableInfo());
}
// Crash if the wrapper is already in the new scope.
if (newMap->Find(wrapper->GetIdentityObject()))
MOZ_CRASH();
@@ -1822,28 +1822,28 @@ XPCWrappedNative::InitTearOff(XPCWrapped
// this is only going to run for the few people in the
// DEBUG_xpc_hacker list.
if (HasProto()) {
JSObject* proto = nullptr;
JSObject* our_proto = GetProto()->GetJSProtoObject();
proto = jso->getProto();
- NS_ASSERTION(proto && proto != our_proto,
- "!!! xpconnect/xbl check - wrapper has no special proto");
+ MOZ_ASSERT(proto && proto != our_proto,
+ "!!! xpconnect/xbl check - wrapper has no special proto");
bool found_our_proto = false;
while (proto && !found_our_proto) {
proto = proto->getProto();
found_our_proto = proto == our_proto;
}
- NS_ASSERTION(found_our_proto,
- "!!! xpconnect/xbl check - wrapper has extra proto");
+ MOZ_ASSERT(found_our_proto,
+ "!!! xpconnect/xbl check - wrapper has extra proto");
} else {
NS_WARNING("!!! xpconnect/xbl check - wrapper has no proto");
}
}
#endif
NS_RELEASE(obj);
aTearOff->SetInterface(nullptr);
return NS_OK;
@@ -2066,18 +2066,18 @@ public:
};
// static
bool
XPCWrappedNative::CallMethod(XPCCallContext& ccx,
CallMode mode /*= CALL_METHOD */)
{
- NS_ASSERTION(ccx.GetXPCContext()->CallerTypeIsJavaScript(),
- "Native caller for XPCWrappedNative::CallMethod?");
+ MOZ_ASSERT(ccx.GetXPCContext()->CallerTypeIsJavaScript(),
+ "Native caller for XPCWrappedNative::CallMethod?");
nsresult rv = ccx.CanCallNow();
if (NS_FAILED(rv)) {
return Throw(rv, ccx);
}
DEBUG_TrackWrapperCall(ccx.GetWrapper(), mode);
@@ -2261,18 +2261,18 @@ CallMethodHelper::GetInterfaceTypeFromPa
bool
CallMethodHelper::GetOutParamSource(uint8_t paramIndex, MutableHandleValue srcp) const
{
const nsXPTParamInfo& paramInfo = mMethodInfo->GetParam(paramIndex);
if ((paramInfo.IsOut() || paramInfo.IsDipper()) &&
!paramInfo.IsRetval()) {
- NS_ASSERTION(paramIndex < mArgc || paramInfo.IsOptional(),
- "Expected either enough arguments or an optional argument");
+ MOZ_ASSERT(paramIndex < mArgc || paramInfo.IsOptional(),
+ "Expected either enough arguments or an optional argument");
jsval arg = paramIndex < mArgc ? mArgv[paramIndex] : JSVAL_NULL;
if (paramIndex < mArgc &&
(JSVAL_IS_PRIMITIVE(arg) ||
!JS_GetPropertyById(mCallContext,
JSVAL_TO_OBJECT(arg),
mIdxValueId,
srcp))) {
// Explicitly passed in unusable value for out param. Note
@@ -2351,37 +2351,37 @@ CallMethodHelper::GatherAndConvertResult
return false;
}
}
if (paramInfo.IsRetval()) {
mCallContext.SetRetVal(v);
} else if (i < mArgc) {
// we actually assured this before doing the invoke
- NS_ASSERTION(mArgv[i].isObject(), "out var is not object");
+ MOZ_ASSERT(mArgv[i].isObject(), "out var is not object");
if (!JS_SetPropertyById(mCallContext,
&mArgv[i].toObject(),
mIdxValueId, v)) {
ThrowBadParam(NS_ERROR_XPC_CANT_SET_OUT_VAL, i, mCallContext);
return false;
}
} else {
- NS_ASSERTION(paramInfo.IsOptional(),
- "Expected either enough arguments or an optional argument");
+ MOZ_ASSERT(paramInfo.IsOptional(),
+ "Expected either enough arguments or an optional argument");
}
}
return true;
}
bool
CallMethodHelper::QueryInterfaceFastPath() const
{
- NS_ASSERTION(mVTableIndex == 0,
- "Using the QI fast-path for a method other than QueryInterface");
+ MOZ_ASSERT(mVTableIndex == 0,
+ "Using the QI fast-path for a method other than QueryInterface");
if (mArgc < 1) {
Throw(NS_ERROR_XPC_NOT_ENOUGH_ARGS, mCallContext);
return false;
}
if (!mArgv[0].isObject()) {
ThrowBadParam(NS_ERROR_XPC_BAD_CONVERT_JS, 0, mCallContext);
@@ -2506,17 +2506,17 @@ CallMethodHelper::ConvertIndependentPara
bool
CallMethodHelper::ConvertIndependentParam(uint8_t i)
{
const nsXPTParamInfo& paramInfo = mMethodInfo->GetParam(i);
const nsXPTType& type = paramInfo.GetType();
uint8_t type_tag = type.TagPart();
nsXPTCVariant* dp = GetDispatchParam(i);
dp->type = type;
- NS_ABORT_IF_FALSE(!paramInfo.IsShared(), "[shared] implies [noscript]!");
+ MOZ_ASSERT(!paramInfo.IsShared(), "[shared] implies [noscript]!");
// Handle dipper types separately.
if (paramInfo.IsDipper())
return HandleDipperParam(dp, paramInfo);
// Specify the correct storage/calling semantics.
if (paramInfo.IsIndirect())
dp->SetIndirect();
@@ -2549,18 +2549,18 @@ CallMethodHelper::ConvertIndependentPara
return true;
// We're definitely some variety of 'in' now, so there's something to
// convert. The source value for conversion depends on whether we're
// dealing with an 'in' or an 'inout' parameter. 'inout' was handled above,
// so all that's left is 'in'.
if (!paramInfo.IsOut()) {
// Handle the 'in' case.
- NS_ASSERTION(i < mArgc || paramInfo.IsOptional(),
- "Expected either enough arguments or an optional argument");
+ MOZ_ASSERT(i < mArgc || paramInfo.IsOptional(),
+ "Expected either enough arguments or an optional argument");
if (i < mArgc)
src = mArgv[i];
else if (type_tag == nsXPTType::T_JSVAL)
src = JSVAL_VOID;
else
src = JSVAL_NULL;
}
@@ -2615,19 +2615,18 @@ CallMethodHelper::ConvertDependentParam(
dp->type = type;
if (isArray) {
if (NS_FAILED(mIFaceInfo->GetTypeForParam(mVTableIndex, ¶mInfo, 1,
&datum_type))) {
Throw(NS_ERROR_XPC_CANT_GET_ARRAY_INFO, mCallContext);
return false;
}
- NS_ABORT_IF_FALSE(datum_type.TagPart() != nsXPTType::T_JSVAL,
- "Arrays of JSVals not currently supported - "
- "see bug 693337.");
+ MOZ_ASSERT(datum_type.TagPart() != nsXPTType::T_JSVAL,
+ "Arrays of JSVals not currently supported - see bug 693337.");
} else {
datum_type = type;
}
// Specify the correct storage/calling semantics.
if (paramInfo.IsIndirect())
dp->SetIndirect();
@@ -2654,17 +2653,17 @@ CallMethodHelper::ConvertDependentParam(
return true;
// We're definitely some variety of 'in' now, so there's something to
// convert. The source value for conversion depends on whether we're
// dealing with an 'in' or an 'inout' parameter. 'inout' was handled above,
// so all that's left is 'in'.
if (!paramInfo.IsOut()) {
// Handle the 'in' case.
- NS_ASSERTION(i < mArgc || paramInfo.IsOptional(),
+ MOZ_ASSERT(i < mArgc || paramInfo.IsOptional(),
"Expected either enough arguments or an optional argument");
src = i < mArgc ? mArgv[i] : JSVAL_NULL;
}
nsID param_iid;
if (datum_type.IsInterfacePointer() &&
!GetInterfaceTypeFromParam(i, datum_type, ¶m_iid))
return false;
@@ -2707,17 +2706,17 @@ CallMethodHelper::ConvertDependentParam(
// Performs all necessary teardown on a parameter after method invocation.
//
// This method should only be called if the value in question was flagged
// for cleanup (ie, if dp->DoesValNeedCleanup()).
void
CallMethodHelper::CleanupParam(nsXPTCMiniVariant& param, nsXPTType& type)
{
// We handle array elements, but not the arrays themselves.
- NS_ABORT_IF_FALSE(type.TagPart() != nsXPTType::T_ARRAY, "Can't handle arrays.");
+ MOZ_ASSERT(type.TagPart() != nsXPTType::T_ARRAY, "Can't handle arrays.");
// Pointers may sometimes be null even if cleanup was requested. Combine
// the null checking for all the different types into one check here.
if (type.TagPart() != nsXPTType::T_JSVAL && param.val.p == nullptr)
return;
switch (type.TagPart()) {
case nsXPTType::T_JSVAL:
@@ -2731,18 +2730,17 @@ CallMethodHelper::CleanupParam(nsXPTCMin
case nsXPTType::T_DOMSTRING:
nsXPConnect::GetRuntimeInstance()->DeleteString((nsAString*)param.val.p);
break;
case nsXPTType::T_UTF8STRING:
case nsXPTType::T_CSTRING:
delete (nsCString*) param.val.p;
break;
default:
- NS_ABORT_IF_FALSE(!type.IsArithmetic(),
- "Cleanup requested on unexpected type.");
+ MOZ_ASSERT(!type.IsArithmetic(), "Cleanup requested on unexpected type.");
nsMemory::Free(param.val.p);
break;
}
}
// Handle parameters with dipper types.
//
// Dipper types are one of the more inscrutable aspects of xpidl. In a
@@ -2767,25 +2765,25 @@ CallMethodHelper::CleanupParam(nsXPTCMin
bool
CallMethodHelper::HandleDipperParam(nsXPTCVariant* dp,
const nsXPTParamInfo& paramInfo)
{
// Get something we can make comparisons with.
uint8_t type_tag = paramInfo.GetType().TagPart();
// Dippers always have the 'in' and 'dipper' flags set. Never 'out'.
- NS_ABORT_IF_FALSE(!paramInfo.IsOut(), "Dipper has unexpected flags.");
+ MOZ_ASSERT(!paramInfo.IsOut(), "Dipper has unexpected flags.");
// xpidl.h specifies that dipper types will be used in exactly four
// cases, all strings. Verify that here.
- NS_ABORT_IF_FALSE(type_tag == nsXPTType::T_ASTRING ||
- type_tag == nsXPTType::T_DOMSTRING ||
- type_tag == nsXPTType::T_UTF8STRING ||
- type_tag == nsXPTType::T_CSTRING,
- "Unexpected dipper type!");
+ MOZ_ASSERT(type_tag == nsXPTType::T_ASTRING ||
+ type_tag == nsXPTType::T_DOMSTRING ||
+ type_tag == nsXPTType::T_UTF8STRING ||
+ type_tag == nsXPTType::T_CSTRING,
+ "Unexpected dipper type!");
// ASTRING and DOMSTRING are very similar, and both use nsAutoString.
// UTF8_STRING and CSTRING are also quite similar, and both use nsCString.
if (type_tag == nsXPTType::T_ASTRING || type_tag == nsXPTType::T_DOMSTRING)
dp->val.p = new nsAutoString();
else
dp->val.p = new nsCString();
@@ -2848,17 +2846,17 @@ XPCWrappedNative::GetObjectPrincipal() c
// just check same-origin here.
nsCOMPtr<nsIScriptObjectPrincipal> objPrin(do_QueryInterface(mIdentity));
if (objPrin) {
bool equal;
if (!principal)
equal = !objPrin->GetPrincipal();
else
principal->Equals(objPrin->GetPrincipal(), &equal);
- NS_ASSERTION(equal, "Principal mismatch. Expect bad things to happen");
+ MOZ_ASSERT(equal, "Principal mismatch. Expect bad things to happen");
}
#endif
return principal;
}
/* XPCNativeInterface FindInterfaceWithMember (in JSHandleId name); */
NS_IMETHODIMP XPCWrappedNative::FindInterfaceWithMember(HandleId name,
nsIInterfaceInfo * *_retval)
@@ -3180,17 +3178,17 @@ static void ShowDuplicateInterface(jsval
}
static bool InterfacesAreRelated(XPCNativeInterface* iface1,
XPCNativeInterface* iface2)
{
nsIInterfaceInfo* info1 = iface1->GetInterfaceInfo();
nsIInterfaceInfo* info2 = iface2->GetInterfaceInfo();
- NS_ASSERTION(info1 != info2, "should not have different iface!");
+ MOZ_ASSERT(info1 != info2, "should not have different iface!");
bool match;
return
(NS_SUCCEEDED(info1->HasAncestor(iface2->GetIID(), &match)) && match) ||
(NS_SUCCEEDED(info2->HasAncestor(iface1->GetIID(), &match)) && match);
}
@@ -3244,17 +3242,17 @@ void DEBUG_ReportShadowedMembers(XPCNati
XPCWrappedNative* wrapper,
XPCWrappedNativeProto* proto)
{
// NOTE: Either wrapper or proto could be null...
if (!(proto || wrapper) || !set || set->GetInterfaceCount() < 2)
return;
- NS_ASSERTION(proto || wrapper, "bad param!");
+ MOZ_ASSERT(proto || wrapper, "bad param!");
XPCJSRuntime* rt = proto ? proto->GetRuntime() : wrapper->GetRuntime();
// a quicky hack to avoid reporting info for the same set too often
static int nextSeenSet = 0;
static const int MAX_SEEN_SETS = 128;
static XPCNativeSet* SeenSets[MAX_SEEN_SETS];
for (int seen = 0; seen < MAX_SEEN_SETS; seen++)
if (set == SeenSets[seen])
--- a/js/xpconnect/src/XPCWrappedNativeInfo.cpp
+++ b/js/xpconnect/src/XPCWrappedNativeInfo.cpp
@@ -35,18 +35,17 @@ XPCNativeMember::GetCallInfo(JSObject* f
return true;
}
bool
XPCNativeMember::NewFunctionObject(XPCCallContext& ccx,
XPCNativeInterface* iface, HandleObject parent,
jsval* pval)
{
- NS_ASSERTION(!IsConstant(),
- "Only call this if you're sure this is not a constant!");
+ MOZ_ASSERT(!IsConstant(), "Only call this if you're sure this is not a constant!");
return Resolve(ccx, iface, parent, pval);
}
bool
XPCNativeMember::Resolve(XPCCallContext& ccx, XPCNativeInterface* iface,
HandleObject parent, jsval *vp)
{
@@ -296,27 +295,27 @@ XPCNativeInterface::NewInstance(nsIInter
if (!str) {
NS_ERROR("bad method name");
failed = true;
break;
}
jsid name = INTERNED_STRING_TO_JSID(cx, str);
if (info->IsSetter()) {
- NS_ASSERTION(realTotalCount,"bad setter");
+ MOZ_ASSERT(realTotalCount,"bad setter");
// Note: ASSUMES Getter/Setter pairs are next to each other
// This is a rule of the typelib spec.
cur = &members[realTotalCount-1];
- NS_ASSERTION(cur->GetName() == name,"bad setter");
- NS_ASSERTION(cur->IsReadOnlyAttribute(),"bad setter");
- NS_ASSERTION(cur->GetIndex() == i-1,"bad setter");
+ MOZ_ASSERT(cur->GetName() == name,"bad setter");
+ MOZ_ASSERT(cur->IsReadOnlyAttribute(),"bad setter");
+ MOZ_ASSERT(cur->GetIndex() == i-1,"bad setter");
cur->SetWritableAttribute();
} else {
// XXX need better way to find dups
- // NS_ASSERTION(!LookupMemberByID(name),"duplicate method name");
+ // MOZ_ASSERT(!LookupMemberByID(name),"duplicate method name");
cur = &members[realTotalCount++];
cur->SetName(name);
if (info->IsGetter())
cur->SetReadOnlyAttribute(i);
else
cur->SetMethod(i);
}
}
@@ -333,17 +332,17 @@ XPCNativeInterface::NewInstance(nsIInter
if (!str) {
NS_ERROR("bad constant name");
failed = true;
break;
}
jsid name = INTERNED_STRING_TO_JSID(cx, str);
// XXX need better way to find dups
- //NS_ASSERTION(!LookupMemberByID(name),"duplicate method/constant name");
+ //MOZ_ASSERT(!LookupMemberByID(name),"duplicate method/constant name");
cur = &members[realTotalCount++];
cur->SetName(name);
cur->SetConstant(i);
}
}
if (!failed) {
@@ -489,17 +488,17 @@ XPCNativeSet::GetNewOrUsed(nsIClassInfo*
// nsIClassInfo to classes implemented in script without requiring this
// method to be implemented.
// Make sure these are set correctly...
iidArray = nullptr;
iidCount = 0;
}
- NS_ASSERTION((iidCount && iidArray) || !(iidCount || iidArray), "GetInterfaces returned bad array");
+ MOZ_ASSERT((iidCount && iidArray) || !(iidCount || iidArray), "GetInterfaces returned bad array");
// !!! from here on we only exit through the 'out' label !!!
if (iidCount) {
AutoMarkingNativeInterfacePtrArrayPtr
arr(cx, new XPCNativeInterface*[iidCount], iidCount, true);
if (!arr)
goto out;
@@ -561,18 +560,18 @@ XPCNativeSet::GetNewOrUsed(nsIClassInfo*
if (set)
{ // scoped lock
XPCAutoLock lock(rt->GetMapLock());
#ifdef DEBUG
XPCNativeSet* set2 =
#endif
map->Add(classInfo, set);
- NS_ASSERTION(set2, "failed to add our set!");
- NS_ASSERTION(set2 == set, "hashtables inconsistent!");
+ MOZ_ASSERT(set2, "failed to add our set!");
+ MOZ_ASSERT(set2 == set, "hashtables inconsistent!");
}
out:
if (iidArray)
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(iidCount, iidArray);
if (interfaceArray)
delete [] interfaceArray.get();
--- a/js/xpconnect/src/XPCWrappedNativeJSOps.cpp
+++ b/js/xpconnect/src/XPCWrappedNativeJSOps.cpp
@@ -139,17 +139,17 @@ XPC_WN_DoubleWrappedGetter(JSContext *cx
RootedObject obj(cx, JS_THIS_OBJECT(cx, vp));
if (!obj)
return false;
XPCCallContext ccx(JS_CALLER, cx, obj);
XPCWrappedNative* wrapper = ccx.GetWrapper();
THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
- NS_ASSERTION(JS_TypeOfValue(cx, JS_CALLEE(cx, vp)) == JSTYPE_FUNCTION, "bad function");
+ MOZ_ASSERT(JS_TypeOfValue(cx, JS_CALLEE(cx, vp)) == JSTYPE_FUNCTION, "bad function");
RootedObject realObject(cx, GetDoubleWrappedJSObject(ccx, wrapper));
if (!realObject) {
// This is pretty unexpected at this point. The object originally
// responded to this get property call and now gives no object.
// XXX Should this throw something at the caller?
*vp = JSVAL_NULL;
return true;
@@ -399,17 +399,17 @@ DefinePropertyIfFound(XPCCallContext& cc
if (resolved)
*resolved = true;
return JS_DefinePropertyById(ccx, obj, id, funval, nullptr, nullptr,
propFlags);
}
// else...
- NS_ASSERTION(member->IsAttribute(), "way broken!");
+ MOZ_ASSERT(member->IsAttribute(), "way broken!");
propFlags |= JSPROP_GETTER | JSPROP_SHARED;
JSObject* funobj = JSVAL_TO_OBJECT(funval);
JSPropertyOp getter = JS_DATA_TO_FUNC_PTR(JSPropertyOp, funobj);
JSStrictPropertyOp setter;
if (member->IsWritableAttribute()) {
propFlags |= JSPROP_SETTER;
propFlags &= ~JSPROP_READONLY;
@@ -939,17 +939,17 @@ XPC_WN_Helper_NewResolve(JSContext *cx,
rv = si->GetCallback()->NewResolve(wrapper, cx, obj, id, flags,
obj2FromScriptable.address(), &retval);
if (allowPropMods)
(void)ccx.SetResolvingWrapper(oldResolvingWrapper);
}
old = ccx.SetResolveName(old);
- NS_ASSERTION(old == id, "bad nest");
+ MOZ_ASSERT(old == id, "bad nest");
if (NS_FAILED(rv)) {
return Throw(rv, cx);
}
if (obj2FromScriptable) {
objp.set(obj2FromScriptable);
} else if (wrapper->HasMutatedSet()) {
@@ -1117,18 +1117,18 @@ XPC_WN_JSOp_ThisObject(JSContext *cx, Ha
}
/***************************************************************************/
// static
XPCNativeScriptableInfo*
XPCNativeScriptableInfo::Construct(const XPCNativeScriptableCreateInfo* sci)
{
- NS_ASSERTION(sci, "bad param");
- NS_ASSERTION(sci->GetCallback(), "bad param");
+ MOZ_ASSERT(sci, "bad param");
+ MOZ_ASSERT(sci->GetCallback(), "bad param");
XPCNativeScriptableInfo* newObj =
new XPCNativeScriptableInfo(sci->GetCallback());
if (!newObj)
return nullptr;
char* name = nullptr;
if (NS_FAILED(sci->GetCallback()->GetClassName(&name)) || !name) {
@@ -1152,17 +1152,17 @@ XPCNativeScriptableInfo::Construct(const
}
return newObj;
}
void
XPCNativeScriptableShared::PopulateJSClass()
{
- NS_ASSERTION(mJSClass.base.name, "bad state!");
+ MOZ_ASSERT(mJSClass.base.name, "bad state!");
mJSClass.base.flags = WRAPPER_SLOTS |
JSCLASS_PRIVATE_IS_NSISUPPORTS |
JSCLASS_NEW_RESOLVE;
if (mFlags.IsGlobalObject())
mJSClass.base.flags |= XPCONNECT_GLOBAL_FLAGS;
@@ -1288,17 +1288,17 @@ FixUpThisIfBroken(JSObject *obj, JSObjec
}
}
return obj;
}
bool
XPC_WN_CallMethod(JSContext *cx, unsigned argc, jsval *vp)
{
- NS_ASSERTION(JS_TypeOfValue(cx, JS_CALLEE(cx, vp)) == JSTYPE_FUNCTION, "bad function");
+ MOZ_ASSERT(JS_TypeOfValue(cx, JS_CALLEE(cx, vp)) == JSTYPE_FUNCTION, "bad function");
RootedObject funobj(cx, JSVAL_TO_OBJECT(JS_CALLEE(cx, vp)));
RootedObject obj(cx, JS_THIS_OBJECT(cx, vp));
if (!obj)
return false;
obj = FixUpThisIfBroken(obj, funobj);
XPCCallContext ccx(JS_CALLER, cx, obj, funobj, JSID_VOIDHANDLE, argc,
@@ -1313,17 +1313,17 @@ XPC_WN_CallMethod(JSContext *cx, unsigne
return Throw(NS_ERROR_XPC_CANT_GET_METHOD_INFO, cx);
ccx.SetCallInfo(iface, member, false);
return XPCWrappedNative::CallMethod(ccx);
}
bool
XPC_WN_GetterSetter(JSContext *cx, unsigned argc, jsval *vp)
{
- NS_ASSERTION(JS_TypeOfValue(cx, JS_CALLEE(cx, vp)) == JSTYPE_FUNCTION, "bad function");
+ MOZ_ASSERT(JS_TypeOfValue(cx, JS_CALLEE(cx, vp)) == JSTYPE_FUNCTION, "bad function");
RootedObject funobj(cx, JSVAL_TO_OBJECT(JS_CALLEE(cx, vp)));
RootedObject obj(cx, JS_THIS_OBJECT(cx, vp));
if (!obj)
return false;
obj = FixUpThisIfBroken(obj, funobj);
XPCCallContext ccx(JS_CALLER, cx, obj, funobj, JSID_VOIDHANDLE, argc,
@@ -1350,21 +1350,21 @@ XPC_WN_GetterSetter(JSContext *cx, unsig
return XPCWrappedNative::GetAttribute(ccx);
}
/***************************************************************************/
static bool
XPC_WN_Shared_Proto_Enumerate(JSContext *cx, HandleObject obj)
{
- NS_ASSERTION(js::GetObjectClass(obj) == &XPC_WN_ModsAllowed_WithCall_Proto_JSClass ||
- js::GetObjectClass(obj) == &XPC_WN_ModsAllowed_NoCall_Proto_JSClass ||
- js::GetObjectClass(obj) == &XPC_WN_NoMods_WithCall_Proto_JSClass ||
- js::GetObjectClass(obj) == &XPC_WN_NoMods_NoCall_Proto_JSClass,
- "bad proto");
+ MOZ_ASSERT(js::GetObjectClass(obj) == &XPC_WN_ModsAllowed_WithCall_Proto_JSClass ||
+ js::GetObjectClass(obj) == &XPC_WN_ModsAllowed_NoCall_Proto_JSClass ||
+ js::GetObjectClass(obj) == &XPC_WN_NoMods_WithCall_Proto_JSClass ||
+ js::GetObjectClass(obj) == &XPC_WN_NoMods_NoCall_Proto_JSClass,
+ "bad proto");
XPCWrappedNativeProto* self =
(XPCWrappedNativeProto*) xpc_GetJSPrivate(obj);
if (!self)
return false;
if (self->GetScriptableInfo() &&
self->GetScriptableInfo()->GetFlags().DontEnumStaticProps())
return true;
@@ -1411,19 +1411,19 @@ XPC_WN_Shared_Proto_Trace(JSTracer *trc,
p->TraceInside(trc);
}
/*****************************************************/
static bool
XPC_WN_ModsAllowed_Proto_Resolve(JSContext *cx, HandleObject obj, HandleId id)
{
- NS_ASSERTION(js::GetObjectClass(obj) == &XPC_WN_ModsAllowed_WithCall_Proto_JSClass ||
- js::GetObjectClass(obj) == &XPC_WN_ModsAllowed_NoCall_Proto_JSClass,
- "bad proto");
+ MOZ_ASSERT(js::GetObjectClass(obj) == &XPC_WN_ModsAllowed_WithCall_Proto_JSClass ||
+ js::GetObjectClass(obj) == &XPC_WN_ModsAllowed_NoCall_Proto_JSClass,
+ "bad proto");
XPCWrappedNativeProto* self =
(XPCWrappedNativeProto*) xpc_GetJSPrivate(obj);
if (!self)
return false;
XPCCallContext ccx(JS_CALLER, cx);
if (!ccx.IsValid())
@@ -1491,19 +1491,19 @@ js::Class XPC_WN_ModsAllowed_NoCall_Prot
};
/***************************************************************************/
static bool
XPC_WN_OnlyIWrite_Proto_AddPropertyStub(JSContext *cx, HandleObject obj, HandleId id,
MutableHandleValue vp)
{
- NS_ASSERTION(js::GetObjectClass(obj) == &XPC_WN_NoMods_WithCall_Proto_JSClass ||
- js::GetObjectClass(obj) == &XPC_WN_NoMods_NoCall_Proto_JSClass,
- "bad proto");
+ MOZ_ASSERT(js::GetObjectClass(obj) == &XPC_WN_NoMods_WithCall_Proto_JSClass ||
+ js::GetObjectClass(obj) == &XPC_WN_NoMods_NoCall_Proto_JSClass,
+ "bad proto");
XPCWrappedNativeProto* self =
(XPCWrappedNativeProto*) xpc_GetJSPrivate(obj);
if (!self)
return false;
XPCCallContext ccx(JS_CALLER, cx);
if (!ccx.IsValid())
@@ -1521,19 +1521,19 @@ XPC_WN_OnlyIWrite_Proto_SetPropertyStub(
MutableHandleValue vp)
{
return XPC_WN_OnlyIWrite_Proto_AddPropertyStub(cx, obj, id, vp);
}
static bool
XPC_WN_NoMods_Proto_Resolve(JSContext *cx, HandleObject obj, HandleId id)
{
- NS_ASSERTION(js::GetObjectClass(obj) == &XPC_WN_NoMods_WithCall_Proto_JSClass ||
- js::GetObjectClass(obj) == &XPC_WN_NoMods_NoCall_Proto_JSClass,
- "bad proto");
+ MOZ_ASSERT(js::GetObjectClass(obj) == &XPC_WN_NoMods_WithCall_Proto_JSClass ||
+ js::GetObjectClass(obj) == &XPC_WN_NoMods_NoCall_Proto_JSClass,
+ "bad proto");
XPCWrappedNativeProto* self =
(XPCWrappedNativeProto*) xpc_GetJSPrivate(obj);
if (!self)
return false;
XPCCallContext ccx(JS_CALLER, cx);
if (!ccx.IsValid())
--- a/js/xpconnect/src/XPCWrappedNativeProto.cpp
+++ b/js/xpconnect/src/XPCWrappedNativeProto.cpp
@@ -36,17 +36,17 @@ XPCWrappedNativeProto::XPCWrappedNativeP
#ifdef DEBUG
PR_ATOMIC_INCREMENT(&gDEBUG_LiveProtoCount);
#endif
}
XPCWrappedNativeProto::~XPCWrappedNativeProto()
{
- NS_ASSERTION(!mJSProtoObject, "JSProtoObject still alive");
+ MOZ_ASSERT(!mJSProtoObject, "JSProtoObject still alive");
MOZ_COUNT_DTOR(XPCWrappedNativeProto);
#ifdef DEBUG
PR_ATOMIC_DECREMENT(&gDEBUG_LiveProtoCount);
#endif
// Note that our weak ref to mScope is not to be trusted at this point.
@@ -128,17 +128,17 @@ XPCWrappedNativeProto::CallPostCreatePro
}
return true;
}
void
XPCWrappedNativeProto::JSProtoObjectFinalized(js::FreeOp *fop, JSObject *obj)
{
- NS_ASSERTION(obj == mJSProtoObject, "huh?");
+ MOZ_ASSERT(obj == mJSProtoObject, "huh?");
// Map locking is not necessary since we are running gc.
// Only remove this proto from the map if it is the one in the map.
ClassInfo2WrappedNativeProtoMap* map =
GetScope()->GetWrappedNativeProtoMap(ClassIsMainThreadOnly());
if (map->Find(mClassInfo) == this)
map->Remove(mClassInfo);
@@ -174,18 +174,18 @@ XPCWrappedNativeProto::SystemIsBeingShut
// static
XPCWrappedNativeProto*
XPCWrappedNativeProto::GetNewOrUsed(XPCWrappedNativeScope* scope,
nsIClassInfo* classInfo,
const XPCNativeScriptableCreateInfo* scriptableCreateInfo,
bool callPostCreatePrototype)
{
AutoJSContext cx;
- NS_ASSERTION(scope, "bad param");
- NS_ASSERTION(classInfo, "bad param");
+ MOZ_ASSERT(scope, "bad param");
+ MOZ_ASSERT(classInfo, "bad param");
AutoMarkingWrappedNativeProtoPtr proto(cx);
ClassInfo2WrappedNativeProtoMap* map = nullptr;
XPCLock* lock = nullptr;
uint32_t ciFlags;
if (NS_FAILED(classInfo->GetFlags(&ciFlags)))
ciFlags = 0;
--- a/js/xpconnect/src/XPCWrappedNativeScope.cpp
+++ b/js/xpconnect/src/XPCWrappedNativeScope.cpp
@@ -289,27 +289,27 @@ bool AllowXBLScope(JSCompartment *c)
XPCWrappedNativeScope::~XPCWrappedNativeScope()
{
MOZ_COUNT_DTOR(XPCWrappedNativeScope);
DEBUG_TrackDeleteScope(this);
// We can do additional cleanup assertions here...
if (mWrappedNativeMap) {
- NS_ASSERTION(0 == mWrappedNativeMap->Count(), "scope has non-empty map");
+ MOZ_ASSERT(0 == mWrappedNativeMap->Count(), "scope has non-empty map");
delete mWrappedNativeMap;
}
if (mWrappedNativeProtoMap) {
- NS_ASSERTION(0 == mWrappedNativeProtoMap->Count(), "scope has non-empty map");
+ MOZ_ASSERT(0 == mWrappedNativeProtoMap->Count(), "scope has non-empty map");
delete mWrappedNativeProtoMap;
}
if (mMainThreadWrappedNativeProtoMap) {
- NS_ASSERTION(0 == mMainThreadWrappedNativeProtoMap->Count(), "scope has non-empty map");
+ MOZ_ASSERT(0 == mMainThreadWrappedNativeProtoMap->Count(), "scope has non-empty map");
delete mMainThreadWrappedNativeProtoMap;
}
if (mContext)
mContext->RemoveScope(this);
// This should not be necessary, since the Components object should die
// with the scope but just in case.
@@ -400,18 +400,17 @@ XPCWrappedNativeScope::StartFinalization
{
// FIXME The lock may not be necessary since we are inside JSGC_MARK_END
// callback and GX serializes access to JS runtime. See bug 380139.
XPCAutoLock lock(rt->GetMapLock());
// We are in JSGC_MARK_END and JSGC_FINALIZE_END must always follow it
// calling FinishedFinalizationPhaseOfGC and clearing gDyingScopes in
// KillDyingScopes.
- NS_ASSERTION(gDyingScopes == nullptr,
- "JSGC_MARK_END without JSGC_FINALIZE_END");
+ MOZ_ASSERT(!gDyingScopes, "JSGC_MARK_END without JSGC_FINALIZE_END");
XPCWrappedNativeScope* prev = nullptr;
XPCWrappedNativeScope* cur = gScopes;
while (cur) {
// Sweep waivers.
if (cur->mWaiverWrapperMap)
cur->mWaiverWrapperMap->Sweep();
--- a/js/xpconnect/src/nsXPConnect.cpp
+++ b/js/xpconnect/src/nsXPConnect.cpp
@@ -359,18 +359,18 @@ inline nsresult UnexpectedFailure(nsresu
NS_ERROR("This is not supposed to fail!");
return rv;
}
/* void initClasses (in JSContextPtr aJSContext, in JSObjectPtr aGlobalJSObj); */
NS_IMETHODIMP
nsXPConnect::InitClasses(JSContext * aJSContext, JSObject * aGlobalJSObj)
{
- NS_ASSERTION(aJSContext, "bad param");
- NS_ASSERTION(aGlobalJSObj, "bad param");
+ MOZ_ASSERT(aJSContext, "bad param");
+ MOZ_ASSERT(aGlobalJSObj, "bad param");
RootedObject globalJSObj(aJSContext, aGlobalJSObj);
JSAutoCompartment ac(aJSContext, globalJSObj);
XPCWrappedNativeScope* scope =
XPCWrappedNativeScope::GetNewOrUsed(aJSContext, globalJSObj);
if (!scope)
@@ -460,17 +460,17 @@ namespace xpc {
JSObject*
CreateGlobalObject(JSContext *cx, JSClass *clasp, nsIPrincipal *principal,
JS::CompartmentOptions& aOptions)
{
// Make sure that Type Inference is enabled for everything non-chrome.
// Sandboxes and compilation scopes are exceptions. See bug 744034.
CheckTypeInference(cx, clasp, principal);
- NS_ABORT_IF_FALSE(NS_IsMainThread(), "using a principal off the main thread?");
+ MOZ_ASSERT(NS_IsMainThread(), "using a principal off the main thread?");
MOZ_ASSERT(principal);
RootedObject global(cx,
JS_NewGlobalObject(cx, clasp, nsJSPrincipals::get(principal),
JS::DontFireOnNewGlobalHook, aOptions));
if (!global)
return nullptr;
JSAutoCompartment ac(cx, global);
@@ -483,17 +483,17 @@ CreateGlobalObject(JSContext *cx, JSClas
// work right for wrapped globals, since the tracing situation there is
// more complicated. Manual inspection shows that they do the right thing.
if (!((js::Class*)clasp)->ext.isWrappedNative)
{
VerifyTraceXPCGlobalCalledTracer trc;
JS_TracerInit(&trc.base, JS_GetRuntime(cx), VerifyTraceXPCGlobalCalled);
trc.ok = false;
JS_TraceChildren(&trc.base, global, JSTRACE_OBJECT);
- NS_ABORT_IF_FALSE(trc.ok, "Trace hook on global needs to call TraceXPCGlobal for XPConnect compartments.");
+ MOZ_ASSERT(trc.ok, "Trace hook on global needs to call TraceXPCGlobal for XPConnect compartments.");
}
#endif
if (clasp->flags & JSCLASS_DOM_GLOBAL) {
AllocateProtoAndIfaceCache(global);
}
return global;
@@ -504,19 +504,19 @@ CreateGlobalObject(JSContext *cx, JSClas
NS_IMETHODIMP
nsXPConnect::InitClassesWithNewWrappedGlobal(JSContext * aJSContext,
nsISupports *aCOMObj,
nsIPrincipal * aPrincipal,
uint32_t aFlags,
JS::CompartmentOptions& aOptions,
nsIXPConnectJSObjectHolder **_retval)
{
- NS_ASSERTION(aJSContext, "bad param");
- NS_ASSERTION(aCOMObj, "bad param");
- NS_ASSERTION(_retval, "bad param");
+ MOZ_ASSERT(aJSContext, "bad param");
+ MOZ_ASSERT(aCOMObj, "bad param");
+ MOZ_ASSERT(_retval, "bad param");
// We pass null for the 'extra' pointer during global object creation, so
// we need to have a principal.
MOZ_ASSERT(aPrincipal);
// Call into XPCWrappedNative to make a new global object, scope, and global
// prototype.
xpcObjectHelper helper(aCOMObj);
@@ -577,37 +577,34 @@ NativeInterface2JSObject(HandleObject aS
JSAutoCompartment ac(cx, aScope);
nsresult rv;
xpcObjectHelper helper(aCOMObj, aCache);
if (!XPCConvert::NativeInterface2JSObject(aVal, aHolder, helper, aIID,
nullptr, aAllowWrapping, &rv))
return rv;
-#ifdef DEBUG
- NS_ASSERTION(aAllowWrapping ||
- !xpc::WrapperFactory::IsXrayWrapper(JSVAL_TO_OBJECT(*aVal)),
- "Shouldn't be returning a xray wrapper here");
-#endif
+ MOZ_ASSERT(aAllowWrapping || !xpc::WrapperFactory::IsXrayWrapper(JSVAL_TO_OBJECT(*aVal)),
+ "Shouldn't be returning a xray wrapper here");
return NS_OK;
}
/* nsIXPConnectJSObjectHolder wrapNative (in JSContextPtr aJSContext, in JSObjectPtr aScope, in nsISupports aCOMObj, in nsIIDRef aIID); */
NS_IMETHODIMP
nsXPConnect::WrapNative(JSContext * aJSContext,
JSObject * aScopeArg,
nsISupports *aCOMObj,
const nsIID & aIID,
nsIXPConnectJSObjectHolder **aHolder)
{
- NS_ASSERTION(aHolder, "bad param");
- NS_ASSERTION(aJSContext, "bad param");
- NS_ASSERTION(aScopeArg, "bad param");
- NS_ASSERTION(aCOMObj, "bad param");
+ MOZ_ASSERT(aHolder, "bad param");
+ MOZ_ASSERT(aJSContext, "bad param");
+ MOZ_ASSERT(aScopeArg, "bad param");
+ MOZ_ASSERT(aCOMObj, "bad param");
RootedObject aScope(aJSContext, aScopeArg);
RootedValue v(aJSContext);
return NativeInterface2JSObject(aScope, aCOMObj, nullptr, &aIID,
false, v.address(), aHolder);
}
/* void wrapNativeToJSVal (in JSContextPtr aJSContext, in JSObjectPtr aScope, in nsISupports aCOMObj, in nsIIDPtr aIID, out jsval aVal, out nsIXPConnectJSObjectHolder aHolder); */
@@ -616,19 +613,19 @@ nsXPConnect::WrapNativeToJSVal(JSContext
JSObject * aScopeArg,
nsISupports *aCOMObj,
nsWrapperCache *aCache,
const nsIID * aIID,
bool aAllowWrapping,
jsval *aVal,
nsIXPConnectJSObjectHolder **aHolder)
{
- NS_ASSERTION(aJSContext, "bad param");
- NS_ASSERTION(aScopeArg, "bad param");
- NS_ASSERTION(aCOMObj, "bad param");
+ MOZ_ASSERT(aJSContext, "bad param");
+ MOZ_ASSERT(aScopeArg, "bad param");
+ MOZ_ASSERT(aCOMObj, "bad param");
if (aHolder)
*aHolder = nullptr;
RootedObject aScope(aJSContext, aScopeArg);
return NativeInterface2JSObject(aScope, aCOMObj, aCache, aIID,
aAllowWrapping, aVal, aHolder);
@@ -636,19 +633,19 @@ nsXPConnect::WrapNativeToJSVal(JSContext
/* void wrapJS (in JSContextPtr aJSContext, in JSObjectPtr aJSObj, in nsIIDRef aIID, [iid_is (aIID), retval] out nsQIResult result); */
NS_IMETHODIMP
nsXPConnect::WrapJS(JSContext * aJSContext,
JSObject * aJSObjArg,
const nsIID & aIID,
void * *result)
{
- NS_ASSERTION(aJSContext, "bad param");
- NS_ASSERTION(aJSObjArg, "bad param");
- NS_ASSERTION(result, "bad param");
+ MOZ_ASSERT(aJSContext, "bad param");
+ MOZ_ASSERT(aJSObjArg, "bad param");
+ MOZ_ASSERT(result, "bad param");
*result = nullptr;
RootedObject aJSObj(aJSContext, aJSObjArg);
JSAutoCompartment ac(aJSContext, aJSObj);
nsresult rv = NS_ERROR_UNEXPECTED;
if (!XPCConvert::JSObject2NativeInterface(result, aJSObj,
@@ -674,20 +671,20 @@ nsXPConnect::JSValToVariant(JSContext *c
/* void wrapJSAggregatedToNative (in nsISupports aOuter, in JSContextPtr aJSContext, in JSObjectPtr aJSObj, in nsIIDRef aIID, [iid_is (aIID), retval] out nsQIResult result); */
NS_IMETHODIMP
nsXPConnect::WrapJSAggregatedToNative(nsISupports *aOuter,
JSContext * aJSContext,
JSObject * aJSObjArg,
const nsIID & aIID,
void * *result)
{
- NS_ASSERTION(aOuter, "bad param");
- NS_ASSERTION(aJSContext, "bad param");
- NS_ASSERTION(aJSObjArg, "bad param");
- NS_ASSERTION(result, "bad param");
+ MOZ_ASSERT(aOuter, "bad param");
+ MOZ_ASSERT(aJSContext, "bad param");
+ MOZ_ASSERT(aJSObjArg, "bad param");
+ MOZ_ASSERT(result, "bad param");
*result = nullptr;
RootedObject aJSObj(aJSContext, aJSObjArg);
nsresult rv;
if (!XPCConvert::JSObject2NativeInterface(result, aJSObj,
&aIID, aOuter, &rv))
return rv;
@@ -695,19 +692,19 @@ nsXPConnect::WrapJSAggregatedToNative(ns
}
/* nsIXPConnectWrappedNative getWrappedNativeOfJSObject (in JSContextPtr aJSContext, in JSObjectPtr aJSObj); */
NS_IMETHODIMP
nsXPConnect::GetWrappedNativeOfJSObject(JSContext * aJSContext,
JSObject * aJSObjArg,
nsIXPConnectWrappedNative **_retval)
{
- NS_ASSERTION(aJSContext, "bad param");
- NS_ASSERTION(aJSObjArg, "bad param");
- NS_ASSERTION(_retval, "bad param");
+ MOZ_ASSERT(aJSContext, "bad param");
+ MOZ_ASSERT(aJSObjArg, "bad param");
+ MOZ_ASSERT(_retval, "bad param");
RootedObject aJSObj(aJSContext, aJSObjArg);
aJSObj = js::CheckedUnwrap(aJSObj, /* stopAtOuter = */ false);
if (aJSObj && IS_WN_REFLECTOR(aJSObj)) {
NS_IF_ADDREF(*_retval = XPCWrappedNative::Get(aJSObj));
return NS_OK;
}
@@ -716,18 +713,18 @@ nsXPConnect::GetWrappedNativeOfJSObject(
return NS_ERROR_FAILURE;
}
/* nsISupports getNativeOfWrapper(in JSContextPtr aJSContext, in JSObjectPtr aJSObj); */
NS_IMETHODIMP_(nsISupports*)
nsXPConnect::GetNativeOfWrapper(JSContext * aJSContext,
JSObject * aJSObj)
{
- NS_ASSERTION(aJSContext, "bad param");
- NS_ASSERTION(aJSObj, "bad param");
+ MOZ_ASSERT(aJSContext, "bad param");
+ MOZ_ASSERT(aJSObj, "bad param");
aJSObj = js::CheckedUnwrap(aJSObj, /* stopAtOuter = */ false);
if (!aJSObj) {
JS_ReportError(aJSContext, "Permission denied to get native of security wrapper");
return nullptr;
}
if (IS_WN_REFLECTOR(aJSObj)) {
if (XPCWrappedNative *wn = XPCWrappedNative::Get(aJSObj))
@@ -743,20 +740,20 @@ nsXPConnect::GetNativeOfWrapper(JSContex
/* nsIXPConnectWrappedNative getWrappedNativeOfNativeObject (in JSContextPtr aJSContext, in JSObjectPtr aScope, in nsISupports aCOMObj, in nsIIDRef aIID); */
NS_IMETHODIMP
nsXPConnect::GetWrappedNativeOfNativeObject(JSContext * aJSContext,
JSObject * aScopeArg,
nsISupports *aCOMObj,
const nsIID & aIID,
nsIXPConnectWrappedNative **_retval)
{
- NS_ASSERTION(aJSContext, "bad param");
- NS_ASSERTION(aScopeArg, "bad param");
- NS_ASSERTION(aCOMObj, "bad param");
- NS_ASSERTION(_retval, "bad param");
+ MOZ_ASSERT(aJSContext, "bad param");
+ MOZ_ASSERT(aScopeArg, "bad param");
+ MOZ_ASSERT(aCOMObj, "bad param");
+ MOZ_ASSERT(_retval, "bad param");
*_retval = nullptr;
RootedObject aScope(aJSContext, aScopeArg);
XPCWrappedNativeScope* scope = GetObjectScope(aScope);
if (!scope)
return UnexpectedFailure(NS_ERROR_FAILURE);
@@ -865,31 +862,31 @@ nsXPConnect::SetDefaultSecurityManager(n
NS_IMETHODIMP
nsXPConnect::CreateStackFrameLocation(uint32_t aLanguage,
const char *aFilename,
const char *aFunctionName,
int32_t aLineNumber,
nsIStackFrame *aCaller,
nsIStackFrame **_retval)
{
- NS_ASSERTION(_retval, "bad param");
+ MOZ_ASSERT(_retval, "bad param");
return XPCJSStack::CreateStackFrameLocation(aLanguage,
aFilename,
aFunctionName,
aLineNumber,
aCaller,
_retval);
}
/* readonly attribute nsIStackFrame CurrentJSStack; */
NS_IMETHODIMP
nsXPConnect::GetCurrentJSStack(nsIStackFrame * *aCurrentJSStack)
{
- NS_ASSERTION(aCurrentJSStack, "bad param");
+ MOZ_ASSERT(aCurrentJSStack, "bad param");
*aCurrentJSStack = nullptr;
// is there a current context available?
if (JSContext *cx = GetCurrentJSContext()) {
nsCOMPtr<nsIStackFrame> stack;
XPCJSStack::CreateStack(cx, getter_AddRefs(stack));
if (stack) {
// peel off native frames...
@@ -907,17 +904,17 @@ nsXPConnect::GetCurrentJSStack(nsIStackF
}
return NS_OK;
}
/* readonly attribute nsIXPCNativeCallContext CurrentNativeCallContext; */
NS_IMETHODIMP
nsXPConnect::GetCurrentNativeCallContext(nsAXPCNativeCallContext * *aCurrentNativeCallContext)
{
- NS_ASSERTION(aCurrentNativeCallContext, "bad param");
+ MOZ_ASSERT(aCurrentNativeCallContext, "bad param");
*aCurrentNativeCallContext = XPCJSRuntime::Get()->GetCallContext();
return NS_OK;
}
/* void setFunctionThisTranslator (in nsIIDRef aIID, in nsIXPCFunctionThisTranslator aTranslator); */
NS_IMETHODIMP
nsXPConnect::SetFunctionThisTranslator(const nsIID & aIID,
@@ -944,18 +941,18 @@ nsXPConnect::CreateSandbox(JSContext *cx
nsIXPConnectJSObjectHolder **_retval)
{
*_retval = nullptr;
RootedValue rval(cx, JSVAL_VOID);
SandboxOptions options(cx);
nsresult rv = xpc_CreateSandboxObject(cx, rval.address(), principal, options);
- NS_ASSERTION(NS_FAILED(rv) || !JSVAL_IS_PRIMITIVE(rval),
- "Bad return value from xpc_CreateSandboxObject()!");
+ MOZ_ASSERT(NS_FAILED(rv) || !JSVAL_IS_PRIMITIVE(rval),
+ "Bad return value from xpc_CreateSandboxObject()!");
if (NS_SUCCEEDED(rv) && !JSVAL_IS_PRIMITIVE(rval)) {
*_retval = XPCJSObjectHolder::newHolder(JSVAL_TO_OBJECT(rval));
NS_ENSURE_TRUE(*_retval, NS_ERROR_OUT_OF_MEMORY);
NS_ADDREF(*_retval);
}
@@ -1358,17 +1355,17 @@ IsJSContextOnStack(JSContext *aCx)
return XPCJSRuntime::Get()->GetJSContextStack()->HasJSContext(aCx);
}
} // namespace xpc
nsIPrincipal*
nsXPConnect::GetPrincipal(JSObject* obj, bool allowShortCircuit) const
{
- NS_ASSERTION(IS_WN_REFLECTOR(obj), "What kind of wrapper is this?");
+ MOZ_ASSERT(IS_WN_REFLECTOR(obj), "What kind of wrapper is this?");
XPCWrappedNative *xpcWrapper = XPCWrappedNative::Get(obj);
if (xpcWrapper) {
if (allowShortCircuit) {
nsIPrincipal *result = xpcWrapper->GetObjectPrincipal();
if (result) {
return result;
}
--- a/js/xpconnect/src/qsgen.py
+++ b/js/xpconnect/src/qsgen.py
@@ -958,19 +958,19 @@ def writeQuickStub(f, customMethodCalls,
if canFail or debugGetter:
f.write("%s = " % nsresultname)
f.write("%s->%s(%s);\n" % (selfname, comName, args))
if debugGetter:
checkSuccess = "NS_SUCCEEDED(debug_rv)"
if canFail:
checkSuccess += " == NS_SUCCEEDED(rv)"
- f.write(" NS_ASSERTION(%s && "
+ f.write(" MOZ_ASSERT(%s && "
"xpc_qsSameResult(debug_result, result),\n"
- " \"Got the wrong answer from the custom "
+ " \"Got the wrong answer from the custom "
"method call!\");\n" % checkSuccess)
f.write("#endif\n")
if canFail:
# Check for errors.
f.write(" if (NS_FAILED(rv))\n")
if isMethod:
f.write(" return xpc_qsThrowMethodFailed("
--- a/js/xpconnect/src/xpcObjectHelper.h
+++ b/js/xpconnect/src/xpcObjectHelper.h
@@ -48,17 +48,17 @@ public:
mCanonicalStrong = do_QueryInterface(mObject);
mCanonical = mCanonicalStrong;
}
return mCanonical;
}
already_AddRefed<nsISupports> forgetCanonical()
{
- NS_ASSERTION(mCanonical, "Huh, no canonical to forget?");
+ MOZ_ASSERT(mCanonical, "Huh, no canonical to forget?");
if (!mCanonicalStrong)
mCanonicalStrong = mCanonical;
mCanonical = NULL;
return mCanonicalStrong.forget();
}
nsIClassInfo *GetClassInfo()
--- a/js/xpconnect/src/xpcprivate.h
+++ b/js/xpconnect/src/xpcprivate.h
@@ -306,23 +306,23 @@ inline JSObject* GetWNExpandoChain(JSObj
#ifdef _MSC_VER
#pragma warning(disable : 4355) // OK to pass "this" in member initializer
#endif
typedef mozilla::ReentrantMonitor XPCLock;
static inline void xpc_Wait(XPCLock* lock)
{
- NS_ASSERTION(lock, "xpc_Wait called with null lock!");
+ MOZ_ASSERT(lock, "xpc_Wait called with null lock!");
lock->Wait();
}
static inline void xpc_NotifyAll(XPCLock* lock)
{
- NS_ASSERTION(lock, "xpc_NotifyAll called with null lock!");
+ MOZ_ASSERT(lock, "xpc_NotifyAll called with null lock!");
lock->NotifyAll();
}
// This is a cloned subset of nsAutoMonitor. We want the use of a monitor -
// mostly because we need reenterability - but we also want to support passing
// a null monitor in without things blowing up. This is used for wrappers that
// are guaranteed to be used only on one thread. We avoid lock overhead by
// using a null monitor. By changing this class we can avoid having multiplte
@@ -545,18 +545,18 @@ public:
#ifdef DEBUG
mNext = nullptr;
mSelfp = nullptr;
#endif
}
~XPCRootSetElem()
{
- NS_ASSERTION(!mNext, "Must be unlinked");
- NS_ASSERTION(!mSelfp, "Must be unlinked");
+ MOZ_ASSERT(!mNext, "Must be unlinked");
+ MOZ_ASSERT(!mSelfp, "Must be unlinked");
}
inline XPCRootSetElem* GetNextRoot() { return mNext; }
void AddToRootSet(XPCLock *lock, XPCRootSetElem **listHead);
void RemoveFromRootSet(XPCLock *lock);
private:
XPCRootSetElem *mNext;
@@ -581,17 +581,17 @@ public:
bool init(JSContext* aContext, JSString* str)
{
size_t length;
const jschar* chars = JS_GetStringCharsZAndLength(aContext, str, &length);
if (!chars)
return false;
- NS_ASSERTION(IsEmpty(), "init() on initialized string");
+ MOZ_ASSERT(IsEmpty(), "init() on initialized string");
new(static_cast<nsDependentString *>(this)) nsDependentString(chars, length);
return true;
}
};
// In the current xpconnect system there can only be one XPCJSRuntime.
// So, xpconnect can only be used on one JSRuntime within the process.
@@ -706,27 +706,27 @@ public:
IDX_PROTO ,
IDX_ITERATOR ,
IDX_EXPOSEDPROPS ,
IDX_TOTAL_COUNT // just a count of the above
};
jsid GetStringID(unsigned index) const
{
- NS_ASSERTION(index < IDX_TOTAL_COUNT, "index out of range");
+ MOZ_ASSERT(index < IDX_TOTAL_COUNT, "index out of range");
return mStrIDs[index];
}
jsval GetStringJSVal(unsigned index) const
{
- NS_ASSERTION(index < IDX_TOTAL_COUNT, "index out of range");
+ MOZ_ASSERT(index < IDX_TOTAL_COUNT, "index out of range");
return mStrJSVals[index];
}
const char* GetStringName(unsigned index) const
{
- NS_ASSERTION(index < IDX_TOTAL_COUNT, "index out of range");
+ MOZ_ASSERT(index < IDX_TOTAL_COUNT, "index out of range");
return mStrings[index];
}
void TraceNativeBlackRoots(JSTracer* trc) MOZ_OVERRIDE;
void TraceAdditionalNativeGrayRoots(JSTracer* aTracer) MOZ_OVERRIDE;
void TraverseAdditionalNativeRoots(nsCycleCollectionNoteRootCallback& cb) MOZ_OVERRIDE;
void UnmarkSkippableJSHolders();
void PrepareForForgetSkippable() MOZ_OVERRIDE;
@@ -913,17 +913,17 @@ private:
// no virtuals
class XPCContext
{
friend class XPCJSRuntime;
public:
static XPCContext* GetXPCContext(JSContext* aJSContext)
{
- NS_ASSERTION(JS_GetSecondContextPrivate(aJSContext), "should already have XPCContext");
+ MOZ_ASSERT(JS_GetSecondContextPrivate(aJSContext), "should already have XPCContext");
return static_cast<XPCContext *>(JS_GetSecondContextPrivate(aJSContext));
}
XPCJSRuntime* GetRuntime() const {return mRuntime;}
JSContext* GetJSContext() const {return mJSContext;}
enum LangType {LANG_UNKNOWN, LANG_JS, LANG_NATIVE};
@@ -1118,17 +1118,17 @@ private:
HAVE_OBJECT,
HAVE_NAME,
HAVE_ARGS,
READY_TO_CALL,
CALL_DONE
};
#ifdef DEBUG
-inline void CHECK_STATE(int s) const {NS_ASSERTION(mState >= s, "bad state");}
+inline void CHECK_STATE(int s) const {MOZ_ASSERT(mState >= s, "bad state");}
#else
#define CHECK_STATE(s) ((void)0)
#endif
private:
mozilla::AutoPushJSContext mPusher;
State mState;
@@ -1497,18 +1497,18 @@ public:
XPCNativeMember** pMember);
jsid GetName() const {return mName;}
uint16_t GetIndex() const {return mIndex;}
bool GetConstantValue(XPCCallContext& ccx, XPCNativeInterface* iface,
jsval* pval)
- {NS_ASSERTION(IsConstant(),
- "Only call this if you're sure this is a constant!");
+ {MOZ_ASSERT(IsConstant(),
+ "Only call this if you're sure this is a constant!");
return Resolve(ccx, iface, JS::NullPtr(), pval);}
bool NewFunctionObject(XPCCallContext& ccx, XPCNativeInterface* iface,
JS::HandleObject parent, jsval* pval);
bool IsMethod() const
{return 0 != (mFlags & METHOD);}
@@ -1532,17 +1532,17 @@ public:
void SetConstant(uint16_t index)
{mFlags = CONSTANT; mIndex = index;}
void SetReadOnlyAttribute(uint16_t index)
{mFlags = GETTER; mIndex = index;}
void SetWritableAttribute()
- {NS_ASSERTION(mFlags == GETTER,"bad"); mFlags = GETTER | SETTER_TOO;}
+ {MOZ_ASSERT(mFlags == GETTER,"bad"); mFlags = GETTER | SETTER_TOO;}
/* default ctor - leave random contents */
XPCNativeMember() {MOZ_COUNT_CTOR(XPCNativeMember);}
~XPCNativeMember() {MOZ_COUNT_DTOR(XPCNativeMember);}
private:
bool Resolve(XPCCallContext& ccx, XPCNativeInterface* iface,
JS::HandleObject parent, jsval *vp);
@@ -1583,17 +1583,17 @@ class XPCNativeInterface
inline XPCNativeMember* FindMember(jsid name) const;
inline bool HasAncestor(const nsIID* iid) const;
uint16_t GetMemberCount() const {
return mMemberCount;
}
XPCNativeMember* GetMemberAt(uint16_t i) {
- NS_ASSERTION(i < mMemberCount, "bad index");
+ MOZ_ASSERT(i < mMemberCount, "bad index");
return &mMembers[i];
}
void DebugDump(int16_t depth);
#define XPC_NATIVE_IFACE_MARK_FLAG ((uint16_t)JS_BIT(15)) // only high bit of 16 is set
void Mark() {
@@ -1743,17 +1743,17 @@ class XPCNativeSet
uint16_t GetInterfaceCount() const {
return mInterfaceCount;
}
XPCNativeInterface **GetInterfaceArray() {
return mInterfaces;
}
XPCNativeInterface* GetInterfaceAt(uint16_t i)
- {NS_ASSERTION(i < mInterfaceCount, "bad index"); return mInterfaces[i];}
+ {MOZ_ASSERT(i < mInterfaceCount, "bad index"); return mInterfaces[i];}
inline bool MatchesSetUpToInterface(const XPCNativeSet* other,
XPCNativeInterface* iface) const;
#define XPC_NATIVE_SET_MARK_FLAG ((uint16_t)JS_BIT(15)) // only high bit of 16 is set
inline void Mark();
@@ -2089,17 +2089,17 @@ public:
bool ClassIsPluginObject() GET_IT(PLUGIN_OBJECT)
#undef GET_IT
XPCLock* GetLock() const
{return ClassIsThreadSafe() ? GetRuntime()->GetMapLock() : nullptr;}
void SetScriptableInfo(XPCNativeScriptableInfo* si)
- {NS_ASSERTION(!mScriptableInfo, "leak here!"); mScriptableInfo = si;}
+ {MOZ_ASSERT(!mScriptableInfo, "leak here!"); mScriptableInfo = si;}
bool CallPostCreatePrototype();
void JSProtoObjectFinalized(js::FreeOp *fop, JSObject *obj);
void SystemIsBeingShutDown();
void DebugDump(int16_t depth);
@@ -2288,17 +2288,17 @@ public:
#define XPC_WRAPPER_EXPIRED (intptr_t(0x2))
static inline bool
IsTaggedScope(XPCWrappedNativeScope* s)
{return XPC_SCOPE_WORD(s) & XPC_SCOPE_TAG;}
static inline XPCWrappedNativeScope*
TagScope(XPCWrappedNativeScope* s)
- {NS_ASSERTION(!IsTaggedScope(s), "bad pointer!");
+ {MOZ_ASSERT(!IsTaggedScope(s), "bad pointer!");
return (XPCWrappedNativeScope*)(XPC_SCOPE_WORD(s) | XPC_SCOPE_TAG);}
static inline XPCWrappedNativeScope*
UnTagScope(XPCWrappedNativeScope* s)
{return (XPCWrappedNativeScope*)(XPC_SCOPE_WORD(s) & ~XPC_SCOPE_TAG);}
inline bool
IsWrapperExpired() const
@@ -3105,17 +3105,17 @@ public:
NS_DEFINE_STATIC_CID_ACCESSOR(NS_JS_ID_CID)
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIJSID
bool InitWithName(const nsID& id, const char *nameString);
bool SetName(const char* name);
void SetNameToNoString()
- {NS_ASSERTION(!mName, "name already set"); mName = gNoString;}
+ {MOZ_ASSERT(!mName, "name already set"); mName = gNoString;}
bool NameIsSet() const {return nullptr != mName;}
const nsID& ID() const {return mID;}
bool IsValid() const {return !mID.Equals(GetInvalidIID());}
static nsJSID* NewID(const char* str);
static nsJSID* NewID(const nsID& id);
nsJSID();
@@ -3413,17 +3413,17 @@ public:
MOZ_GUARD_OBJECT_NOTIFIER_INIT;
}
~AutoResolveName()
{
#ifdef DEBUG
jsid old =
#endif
XPCJSRuntime::Get()->SetResolveName(mOld);
- NS_ASSERTION(old == mCheck, "Bad Nesting!");
+ MOZ_ASSERT(old == mCheck, "Bad Nesting!");
}
private:
JS::RootedId mOld;
#ifdef DEBUG
JS::RootedId mCheck;
#endif
MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
--- a/js/xpconnect/wrappers/AccessCheck.cpp
+++ b/js/xpconnect/wrappers/AccessCheck.cpp
@@ -232,17 +232,17 @@ AccessCheck::isCrossOriginAccessPermitte
// operations but fail silently (see CrossOriginAccessiblePropertiesOnly::
// deny). We could just fall through here and rely on the fact that none
// of the whitelisted properties below will match JSID_VOID, but EIBTI.
if (id == JSID_VOID)
return false;
const char *name;
js::Class *clasp = js::GetObjectClass(obj);
- NS_ASSERTION(Jsvalify(clasp) != &XrayUtils::HolderClass, "shouldn't have a holder here");
+ MOZ_ASSERT(Jsvalify(clasp) != &XrayUtils::HolderClass, "shouldn't have a holder here");
if (clasp->ext.innerObject)
name = "Window";
else
name = clasp->name;
if (JSID_IS_STRING(id)) {
if (IsPermitted(name, JSID_TO_FLAT_STRING(id), act == Wrapper::SET))
return true;
--- a/js/xpconnect/wrappers/WrapperFactory.cpp
+++ b/js/xpconnect/wrappers/WrapperFactory.cpp
@@ -290,17 +290,17 @@ WrapperFactory::PrepareForWrapping(JSCon
RootedValue v(cx);
nsresult rv =
nsXPConnect::XPConnect()->WrapNativeToJSVal(cx, wrapScope, wn->Native(), nullptr,
&NS_GET_IID(nsISupports), false,
v.address(), getter_AddRefs(holder));
NS_ENSURE_SUCCESS(rv, nullptr);
obj = JSVAL_TO_OBJECT(v);
- NS_ASSERTION(IS_WN_REFLECTOR(obj), "bad object");
+ MOZ_ASSERT(IS_WN_REFLECTOR(obj), "bad object");
// Because the underlying native didn't have a PreCreate hook, we had
// to a new (or possibly pre-existing) XPCWN in our compartment.
// This could be a problem for chrome code that passes XPCOM objects
// across compartments, because the effects of QI would disappear across
// compartments.
//
// So whenever we pull an XPCWN across compartments in this manner, we
--- a/js/xpconnect/wrappers/XrayWrapper.cpp
+++ b/js/xpconnect/wrappers/XrayWrapper.cpp
@@ -1030,18 +1030,17 @@ bool
DOMXrayTraits::resolveNativeProperty(JSContext *cx, HandleObject wrapper,
HandleObject holder, HandleId id,
MutableHandle<JSPropertyDescriptor> desc, unsigned flags)
{
RootedObject obj(cx, getTargetObject(wrapper));
if (!XrayResolveNativeProperty(cx, wrapper, obj, id, desc))
return false;
- NS_ASSERTION(!desc.object() || desc.object() == wrapper,
- "What did we resolve this on?");
+ MOZ_ASSERT(!desc.object() || desc.object() == wrapper, "What did we resolve this on?");
return true;
}
bool
DOMXrayTraits::resolveOwnProperty(JSContext *cx, Wrapper &jsWrapper, HandleObject wrapper,
HandleObject holder, HandleId id,
MutableHandle<JSPropertyDescriptor> desc, unsigned flags)
@@ -1051,18 +1050,17 @@ DOMXrayTraits::resolveOwnProperty(JSCont
id, desc, flags);
if (!ok || desc.object())
return ok;
RootedObject obj(cx, getTargetObject(wrapper));
if (!XrayResolveOwnProperty(cx, wrapper, obj, id, desc, flags))
return false;
- NS_ASSERTION(!desc.object() || desc.object() == wrapper,
- "What did we resolve this on?");
+ MOZ_ASSERT(!desc.object() || desc.object() == wrapper, "What did we resolve this on?");
return true;
}
bool
DOMXrayTraits::defineProperty(JSContext *cx, HandleObject wrapper, HandleId id,
MutableHandle<JSPropertyDescriptor> desc,
Handle<JSPropertyDescriptor> existingDesc, bool *defined)
@@ -1165,21 +1163,21 @@ XrayWrapper<Base, Traits>::~XrayWrapper(
{
}
namespace XrayUtils {
JSObject *
GetNativePropertiesObject(JSContext *cx, JSObject *wrapper)
{
- NS_ASSERTION(js::IsWrapper(wrapper) && WrapperFactory::IsXrayWrapper(wrapper),
- "bad object passed in");
+ MOZ_ASSERT(js::IsWrapper(wrapper) && WrapperFactory::IsXrayWrapper(wrapper),
+ "bad object passed in");
JSObject *holder = GetHolder(wrapper);
- NS_ASSERTION(holder, "uninitialized wrapper being used?");
+ MOZ_ASSERT(holder, "uninitialized wrapper being used?");
return holder;
}
bool
IsXrayResolving(JSContext *cx, HandleObject wrapper, HandleId id)
{
if (!WrapperFactory::IsXrayWrapper(wrapper) ||
GetXrayType(wrapper) != XrayForWrappedNative)