--- a/dom/base/WebSocket.cpp
+++ b/dom/base/WebSocket.cpp
@@ -1986,17 +1986,17 @@ WebSocket::CreateAndDispatchMessageEvent
messageType = nsIWebSocketEventListener::TYPE_ARRAYBUFFER;
JS::Rooted<JSObject*> arrayBuf(cx);
nsresult rv = nsContentUtils::CreateArrayBuffer(cx, aData,
arrayBuf.address());
NS_ENSURE_SUCCESS(rv, rv);
jsData.setObject(*arrayBuf);
} else {
- NS_RUNTIMEABORT("Unknown binary type!");
+ MOZ_CRASH("Unknown binary type!");
return NS_ERROR_UNEXPECTED;
}
} else {
// JS string
NS_ConvertUTF8toUTF16 utf16Data(aData);
JSString* jsString;
jsString = JS_NewUCStringCopyN(cx, utf16Data.get(), utf16Data.Length());
NS_ENSURE_TRUE(jsString, NS_ERROR_FAILURE);
--- a/dom/base/nsDOMDataChannel.cpp
+++ b/dom/base/nsDOMDataChannel.cpp
@@ -403,17 +403,17 @@ nsDOMDataChannel::DoOnMessageAvailable(c
return NS_ERROR_FAILURE;
}
} else if (mBinaryType == DC_BINARY_TYPE_ARRAYBUFFER) {
JS::Rooted<JSObject*> arrayBuf(cx);
rv = nsContentUtils::CreateArrayBuffer(cx, aData, arrayBuf.address());
NS_ENSURE_SUCCESS(rv, rv);
jsData.setObject(*arrayBuf);
} else {
- NS_RUNTIMEABORT("Unknown binary type!");
+ MOZ_CRASH("Unknown binary type!");
return NS_ERROR_UNEXPECTED;
}
} else {
NS_ConvertUTF8toUTF16 utf16data(aData);
JSString* jsString = JS_NewUCStringCopyN(cx, utf16data.get(), utf16data.Length());
NS_ENSURE_TRUE(jsString, NS_ERROR_FAILURE);
jsData.setString(jsString);
--- a/dom/bindings/BindingUtils.cpp
+++ b/dom/bindings/BindingUtils.cpp
@@ -2426,17 +2426,17 @@ ReportLenientThisUnwrappingFailure(JSCon
bool
GetContentGlobalForJSImplementedObject(JSContext* cx, JS::Handle<JSObject*> obj,
nsIGlobalObject** globalObj)
{
// Be very careful to not get tricked here.
MOZ_ASSERT(NS_IsMainThread());
if (!xpc::AccessCheck::isChrome(js::GetObjectCompartment(obj))) {
- NS_RUNTIMEABORT("Should have a chrome object here");
+ MOZ_CRASH("Should have a chrome object here");
}
// Look up the content-side object.
JS::Rooted<JS::Value> domImplVal(cx);
if (!JS_GetProperty(cx, obj, "__DOM_IMPL__", &domImplVal)) {
return false;
}
--- a/dom/bindings/BindingUtils.h
+++ b/dom/bindings/BindingUtils.h
@@ -1098,17 +1098,17 @@ WrapNewBindingNonWrapperCachedObject(JSC
nsAutoPtr<T>& value,
JS::MutableHandle<JS::Value> rval,
JS::Handle<JSObject*> givenProto = nullptr)
{
static_assert(!IsRefcounted<T>::value, "Only pass owned classes in here.");
// We do a runtime check on value, because otherwise we might in
// fact end up wrapping a null and invoking methods on it later.
if (!value) {
- NS_RUNTIMEABORT("Don't try to wrap null objects");
+ MOZ_CRASH("Don't try to wrap null objects");
}
// We try to wrap in the compartment of the underlying object of "scope"
JS::Rooted<JSObject*> obj(cx);
{
// scope for the JSAutoCompartment so that we restore the compartment
// before we call JS_WrapValue.
Maybe<JSAutoCompartment> ac;
// Maybe<Handle> doesn't so much work, and in any case, adding
--- a/dom/canvas/WebGLContext.cpp
+++ b/dom/canvas/WebGLContext.cpp
@@ -1281,18 +1281,17 @@ WebGLContext::UpdateLastUseIndex()
{
static CheckedInt<uint64_t> sIndex = 0;
sIndex++;
// should never happen with 64-bit; trying to handle this would be riskier than
// not handling it as the handler code would never get exercised.
if (!sIndex.isValid())
- NS_RUNTIMEABORT("Can't believe it's been 2^64 transactions already!");
-
+ MOZ_CRASH("Can't believe it's been 2^64 transactions already!");
mLastUseIndex = sIndex.value();
}
static uint8_t gWebGLLayerUserData;
static uint8_t gWebGLMirrorLayerUserData;
class WebGLContextUserData : public LayerUserData
{
--- a/dom/canvas/WebGLTexelConversions.cpp
+++ b/dom/canvas/WebGLTexelConversions.cpp
@@ -417,15 +417,15 @@ ConvertImage(size_t width, size_t height
WebGLImageConverter converter(width, height, srcItr, dstItr, srcStride, dstItrStride);
converter.run(srcFormat, dstFormat, premultOp);
if (!converter.Success()) {
// the dst image may be left uninitialized, so we better not try to
// continue even in release builds. This should never happen anyway,
// and would be a bug in our code.
- NS_RUNTIMEABORT("programming mistake in WebGL texture conversions");
+ MOZ_CRASH("programming mistake in WebGL texture conversions");
}
return true;
}
} // end namespace mozilla
--- a/dom/devicestorage/DeviceStorageRequestChild.cpp
+++ b/dom/devicestorage/DeviceStorageRequestChild.cpp
@@ -134,17 +134,17 @@ DeviceStorageRequestChild::
}
request->Continue();
break;
}
default:
{
DS_LOG_ERROR("unknown %u", mRequest->GetId());
- NS_RUNTIMEABORT("not reached");
+ MOZ_CRASH("not reached");
break;
}
}
return IPC_OK();
}
} // namespace devicestorage
} // namespace dom
--- a/dom/devicestorage/DeviceStorageRequestParent.cpp
+++ b/dom/devicestorage/DeviceStorageRequestParent.cpp
@@ -175,17 +175,17 @@ DeviceStorageRequestParent::Dispatch()
RefPtr<DeviceStorageFile> dsf
= new DeviceStorageFile(p.type(), p.storageName(),
p.rootdir(), NS_LITERAL_STRING(""));
r = new EnumerateFileEvent(this, dsf.forget(), p.since());
break;
}
default:
{
- NS_RUNTIMEABORT("not reached");
+ MOZ_CRASH("not reached");
return;
}
}
if (r) {
nsCOMPtr<nsIEventTarget> target =
do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
MOZ_ASSERT(target);
--- a/dom/filesystem/FileSystemRequestParent.cpp
+++ b/dom/filesystem/FileSystemRequestParent.cpp
@@ -52,17 +52,17 @@ FileSystemRequestParent::Initialize(cons
FILESYSTEM_REQUEST_PARENT_DISPATCH_ENTRY(CreateDirectory)
FILESYSTEM_REQUEST_PARENT_DISPATCH_ENTRY(CreateFile)
FILESYSTEM_REQUEST_PARENT_DISPATCH_ENTRY(GetDirectoryListing)
FILESYSTEM_REQUEST_PARENT_DISPATCH_ENTRY(GetFileOrDirectory)
FILESYSTEM_REQUEST_PARENT_DISPATCH_ENTRY(GetFiles)
FILESYSTEM_REQUEST_PARENT_DISPATCH_ENTRY(Remove)
default: {
- NS_RUNTIMEABORT("not reached");
+ MOZ_CRASH("not reached");
break;
}
}
if (NS_WARN_IF(!mTask || !mFileSystem)) {
// Should never reach here.
return false;
}
--- a/dom/filesystem/GetFileOrDirectoryTask.cpp
+++ b/dom/filesystem/GetFileOrDirectoryTask.cpp
@@ -117,17 +117,17 @@ GetFileOrDirectoryTaskChild::SetSuccessR
if (NS_WARN_IF(aRv.Failed())) {
return;
}
mIsDirectory = true;
break;
}
default: {
- NS_RUNTIMEABORT("not reached");
+ MOZ_CRASH("not reached");
break;
}
}
}
void
GetFileOrDirectoryTaskChild::HandlerCallback()
{
--- a/dom/ipc/ContentChild.cpp
+++ b/dom/ipc/ContentChild.cpp
@@ -504,23 +504,32 @@ ContentChild::ContentChild()
, mIsAlive(true)
, mShuttingDown(false)
{
// This process is a content process, so it's clearly running in
// multiprocess mode!
nsDebugImpl::SetMultiprocessMode("Child");
}
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4722) /* Silence "destructor never returns" warning */
+#endif
+
ContentChild::~ContentChild()
{
#ifndef NS_FREE_PERMANENT_DATA
- NS_RUNTIMEABORT("Content Child shouldn't be destroyed.");
+ MOZ_CRASH("Content Child shouldn't be destroyed.");
#endif
}
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
NS_INTERFACE_MAP_BEGIN(ContentChild)
NS_INTERFACE_MAP_ENTRY(nsIContentChild)
NS_INTERFACE_MAP_ENTRY(nsIWindowProvider)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIContentChild)
NS_INTERFACE_MAP_END
bool
ContentChild::Init(MessageLoop* aIOLoop,
@@ -2087,30 +2096,30 @@ ContentChild::ProcessingError(Result aCo
case MsgNotAllowed:
case MsgPayloadError:
case MsgProcessingError:
case MsgRouteError:
case MsgValueError:
break;
default:
- NS_RUNTIMEABORT("not reached");
+ MOZ_CRASH("not reached");
}
#if defined(MOZ_CRASHREPORTER) && !defined(MOZ_B2G)
if (PCrashReporterChild* c = LoneManagedOrNullAsserts(ManagedPCrashReporterChild())) {
CrashReporterChild* crashReporter =
static_cast<CrashReporterChild*>(c);
nsDependentCString reason(aReason);
crashReporter->SendAnnotateCrashReport(
NS_LITERAL_CSTRING("ipc_channel_error"),
reason);
}
#endif
- NS_RUNTIMEABORT("Content child abort due to IPC error");
+ MOZ_CRASH("Content child abort due to IPC error");
}
nsresult
ContentChild::AddRemoteAlertObserver(const nsString& aData,
nsIObserver* aObserver)
{
NS_ASSERTION(aObserver, "Adding a null observer?");
mAlertObservers.AppendElement(new AlertObserver(aObserver, aData));
@@ -2601,17 +2610,17 @@ ContentChild::RecvUnregisterSheet(const
}
POfflineCacheUpdateChild*
ContentChild::AllocPOfflineCacheUpdateChild(const URIParams& manifestURI,
const URIParams& documentURI,
const PrincipalInfo& aLoadingPrincipalInfo,
const bool& stickDocument)
{
- NS_RUNTIMEABORT("unused");
+ MOZ_CRASH("unused");
return nullptr;
}
bool
ContentChild::DeallocPOfflineCacheUpdateChild(POfflineCacheUpdateChild* actor)
{
OfflineCacheUpdateChild* offlineCacheUpdate =
static_cast<OfflineCacheUpdateChild*>(actor);
@@ -2890,17 +2899,17 @@ ContentChild::RecvUpdateWindow(const uin
#endif
}
PContentPermissionRequestChild*
ContentChild::AllocPContentPermissionRequestChild(const InfallibleTArray<PermissionRequest>& aRequests,
const IPC::Principal& aPrincipal,
const TabId& aTabId)
{
- NS_RUNTIMEABORT("unused");
+ MOZ_CRASH("unused");
return nullptr;
}
bool
ContentChild::DeallocPContentPermissionRequestChild(PContentPermissionRequestChild* actor)
{
nsContentPermissionUtils::NotifyRemoveContentPermissionRequestChild(actor);
auto child = static_cast<RemotePermissionRequest*>(actor);
--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -3916,17 +3916,17 @@ ContentParent::RecvRemoveIdleObserver(co
}
return IPC_OK();
}
mozilla::ipc::IPCResult
ContentParent::RecvBackUpXResources(const FileDescriptor& aXSocketFd)
{
#ifndef MOZ_X11
- NS_RUNTIMEABORT("This message only makes sense on X11 platforms");
+ MOZ_CRASH("This message only makes sense on X11 platforms");
#else
MOZ_ASSERT(0 > mChildXSocketFdDup.get(),
"Already backed up X resources??");
if (aXSocketFd.IsValid()) {
auto rawFD = aXSocketFd.ClonePlatformHandle();
mChildXSocketFdDup.reset(rawFD.release());
}
#endif
--- a/dom/ipc/PermissionMessageUtils.cpp
+++ b/dom/ipc/PermissionMessageUtils.cpp
@@ -24,17 +24,17 @@ ParamTraits<Principal>::Write(Message* a
if (serializable) {
nsresult rv = NS_SerializeToString(serializable, principalString);
if (NS_SUCCEEDED(rv)) {
isSerialized = true;
}
}
if (!isSerialized) {
- NS_RUNTIMEABORT("Unable to serialize principal.");
+ MOZ_CRASH("Unable to serialize principal.");
return;
}
WriteParam(aMsg, principalString);
}
bool
ParamTraits<Principal>::Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -1957,47 +1957,47 @@ TabChild::RecvPDocumentRendererConstruct
return IPC_FAIL_NO_REASON(this);
}
return IPC_OK();
}
PColorPickerChild*
TabChild::AllocPColorPickerChild(const nsString&, const nsString&)
{
- NS_RUNTIMEABORT("unused");
+ MOZ_CRASH("unused");
return nullptr;
}
bool
TabChild::DeallocPColorPickerChild(PColorPickerChild* aColorPicker)
{
nsColorPickerProxy* picker = static_cast<nsColorPickerProxy*>(aColorPicker);
NS_RELEASE(picker);
return true;
}
PDatePickerChild*
TabChild::AllocPDatePickerChild(const nsString&, const nsString&)
{
- NS_RUNTIMEABORT("unused");
+ MOZ_CRASH("unused");
return nullptr;
}
bool
TabChild::DeallocPDatePickerChild(PDatePickerChild* aDatePicker)
{
nsDatePickerProxy* picker = static_cast<nsDatePickerProxy*>(aDatePicker);
NS_RELEASE(picker);
return true;
}
PFilePickerChild*
TabChild::AllocPFilePickerChild(const nsString&, const int16_t&)
{
- NS_RUNTIMEABORT("unused");
+ MOZ_CRASH("unused");
return nullptr;
}
bool
TabChild::DeallocPFilePickerChild(PFilePickerChild* actor)
{
nsFilePickerProxy* filePicker = static_cast<nsFilePickerProxy*>(actor);
NS_RELEASE(filePicker);
--- a/dom/media/webaudio/WebAudioUtils.h
+++ b/dom/media/webaudio/WebAudioUtils.h
@@ -182,17 +182,17 @@ namespace WebAudioUtils {
static_assert(mozilla::IsIntegral<IntType>::value == true,
"IntType must be an integral type");
static_assert(mozilla::IsFloatingPoint<FloatType>::value == true,
"FloatType must be a floating point type");
if (mozilla::IsNaN(f)) {
// It is the responsibility of the caller to deal with NaN values.
// If we ever get to this point, we have a serious bug to fix.
- NS_RUNTIMEABORT("We should never see a NaN here");
+ MOZ_CRASH("We should never see a NaN here");
}
if (f > FloatType(numeric_limits<IntType>::max())) {
// If the floating point value is outside of the range of maximum
// integral value for this type, just clamp to the maximum value.
return numeric_limits<IntType>::max();
}
--- a/dom/plugins/base/PluginPRLibrary.cpp
+++ b/dom/plugins/base/PluginPRLibrary.cpp
@@ -314,17 +314,17 @@ PluginPRLibrary::BeginUpdateBackground(N
NS_ERROR("Unexpected use of async APIs for in-process plugin.");
*aDrawTarget = nullptr;
return NS_OK;
}
nsresult
PluginPRLibrary::EndUpdateBackground(NPP instance, const nsIntRect&)
{
- NS_RUNTIMEABORT("This should never be called");
+ MOZ_CRASH("This should never be called");
return NS_ERROR_NOT_AVAILABLE;
}
#if defined(XP_WIN)
nsresult
PluginPRLibrary::GetScrollCaptureContainer(NPP aInstance, ImageContainer** aContainer)
{
return NS_ERROR_NOT_IMPLEMENTED;
--- a/dom/plugins/ipc/BrowserStreamChild.cpp
+++ b/dom/plugins/ipc/BrowserStreamChild.cpp
@@ -84,17 +84,17 @@ BrowserStreamChild::RecvWrite(const int3
const uint32_t& newlength,
const Buffer& data)
{
PLUGIN_LOG_DEBUG_FUNCTION;
AssertPluginThread();
if (ALIVE != mState)
- NS_RUNTIMEABORT("Unexpected state: received data after NPP_DestroyStream?");
+ MOZ_CRASH("Unexpected state: received data after NPP_DestroyStream?");
if (kStreamOpen != mStreamStatus)
return IPC_OK();
mStream.end = newlength;
NS_ASSERTION(data.Length() > 0, "Empty data");
@@ -111,17 +111,17 @@ BrowserStreamChild::RecvWrite(const int3
mozilla::ipc::IPCResult
BrowserStreamChild::RecvNPP_StreamAsFile(const nsCString& fname)
{
PLUGIN_LOG_DEBUG(("%s (fname=%s)", FULLFUNCTION, fname.get()));
AssertPluginThread();
if (ALIVE != mState)
- NS_RUNTIMEABORT("Unexpected state: received file after NPP_DestroyStream?");
+ MOZ_CRASH("Unexpected state: received file after NPP_DestroyStream?");
if (kStreamOpen != mStreamStatus)
return IPC_OK();
mStreamAsFilePending = true;
mStreamAsFileName = fname;
EnsureDeliveryPending();
@@ -129,34 +129,34 @@ BrowserStreamChild::RecvNPP_StreamAsFile
}
mozilla::ipc::IPCResult
BrowserStreamChild::RecvNPP_DestroyStream(const NPReason& reason)
{
PLUGIN_LOG_DEBUG_METHOD;
if (ALIVE != mState)
- NS_RUNTIMEABORT("Unexpected state: recevied NPP_DestroyStream twice?");
+ MOZ_CRASH("Unexpected state: recevied NPP_DestroyStream twice?");
mState = DYING;
mDestroyPending = DESTROY_PENDING;
if (NPRES_DONE != reason)
mStreamStatus = reason;
EnsureDeliveryPending();
return IPC_OK();
}
mozilla::ipc::IPCResult
BrowserStreamChild::Recv__delete__()
{
AssertPluginThread();
if (DELETING != mState)
- NS_RUNTIMEABORT("Bad state, not DELETING");
+ MOZ_CRASH("Bad state, not DELETING");
return IPC_OK();
}
NPError
BrowserStreamChild::NPN_RequestRead(NPByteRange* aRangeList)
{
PLUGIN_LOG_DEBUG_FUNCTION;
@@ -221,17 +221,17 @@ BrowserStreamChild::Deliver()
mInstance->mPluginIface->asfile(&mInstance->mData, &mStream,
mStreamAsFileName.get());
mStreamAsFilePending = false;
}
if (DESTROY_PENDING == mDestroyPending) {
mDestroyPending = DESTROYED;
if (mState != DYING)
- NS_RUNTIMEABORT("mDestroyPending but state not DYING");
+ MOZ_CRASH("mDestroyPending but state not DYING");
NS_ASSERTION(NPRES_DONE != mStreamStatus, "Success status set too early!");
if (kStreamOpen == mStreamStatus)
mStreamStatus = NPRES_DONE;
(void) mInstance->mPluginIface
->destroystream(&mInstance->mData, &mStream, mStreamStatus);
}
@@ -249,17 +249,17 @@ BrowserStreamChild::Deliver()
mState = DELETING;
}
}
bool
BrowserStreamChild::DeliverPendingData()
{
if (mState != ALIVE && mState != DYING)
- NS_RUNTIMEABORT("Unexpected state");
+ MOZ_CRASH("Unexpected state");
NS_ASSERTION(mPendingData.Length(), "Called from Deliver with empty pending");
while (mPendingData[0].curpos < static_cast<int32_t>(mPendingData[0].data.Length())) {
int32_t r = mInstance->mPluginIface->writeready(&mInstance->mData, &mStream);
if (kStreamOpen != mStreamStatus)
return false;
if (0 == r) // plugin wants to suspend delivery
--- a/dom/plugins/ipc/BrowserStreamChild.h
+++ b/dom/plugins/ipc/BrowserStreamChild.h
@@ -40,22 +40,22 @@ public:
const Buffer& data) override;
virtual mozilla::ipc::IPCResult RecvNPP_StreamAsFile(const nsCString& fname) override;
virtual mozilla::ipc::IPCResult RecvNPP_DestroyStream(const NPReason& reason) override;
virtual mozilla::ipc::IPCResult Recv__delete__() override;
void EnsureCorrectInstance(PluginInstanceChild* i)
{
if (i != mInstance)
- NS_RUNTIMEABORT("Incorrect stream instance");
+ MOZ_CRASH("Incorrect stream instance");
}
void EnsureCorrectStream(NPStream* s)
{
if (s != &mStream)
- NS_RUNTIMEABORT("Incorrect stream data");
+ MOZ_CRASH("Incorrect stream data");
}
NPError NPN_RequestRead(NPByteRange* aRangeList);
void NPN_DestroyStream(NPReason reason);
void NotifyPending() {
NS_ASSERTION(!mNotifyPending, "Pending twice?");
mNotifyPending = true;
--- a/dom/plugins/ipc/PluginInstanceChild.cpp
+++ b/dom/plugins/ipc/PluginInstanceChild.cpp
@@ -119,17 +119,17 @@ static RefPtr<DrawTarget>
CreateDrawTargetForSurface(gfxASurface *aSurface)
{
SurfaceFormat format = aSurface->GetSurfaceFormat();
RefPtr<DrawTarget> drawTarget =
Factory::CreateDrawTargetForCairoSurface(aSurface->CairoSurface(),
aSurface->GetSize(),
&format);
if (!drawTarget) {
- NS_RUNTIMEABORT("CreateDrawTargetForSurface failed in plugin");
+ MOZ_CRASH("CreateDrawTargetForSurface failed in plugin");
}
return drawTarget;
}
bool PluginInstanceChild::sIsIMEComposing = false;
PluginInstanceChild::PluginInstanceChild(const NPPluginFuncs* aPluginIface,
const nsCString& aMimeType,
@@ -1040,17 +1040,17 @@ PluginInstanceChild::AnswerNPP_HandleEve
#else
mozilla::ipc::IPCResult
PluginInstanceChild::AnswerNPP_HandleEvent_Shmem(const NPRemoteEvent& event,
Shmem&& mem,
int16_t* handled,
Shmem* rtnmem)
{
- NS_RUNTIMEABORT("not reached.");
+ MOZ_CRASH("not reached.");
*rtnmem = mem;
return IPC_OK();
}
#endif
#ifdef XP_MACOSX
void CallCGDraw(CGContextRef ref, void* aPluginInstance, nsIntRect aUpdateRect) {
@@ -2875,17 +2875,17 @@ PluginInstanceChild::DeallocPBrowserStre
return true;
}
PPluginStreamChild*
PluginInstanceChild::AllocPPluginStreamChild(const nsCString& mimeType,
const nsCString& target,
NPError* result)
{
- NS_RUNTIMEABORT("not callable");
+ MOZ_CRASH("not callable");
return nullptr;
}
bool
PluginInstanceChild::DeallocPPluginStreamChild(PPluginStreamChild* stream)
{
AssertPluginThread();
delete stream;
@@ -2896,17 +2896,17 @@ PStreamNotifyChild*
PluginInstanceChild::AllocPStreamNotifyChild(const nsCString& url,
const nsCString& target,
const bool& post,
const nsCString& buffer,
const bool& file,
NPError* result)
{
AssertPluginThread();
- NS_RUNTIMEABORT("not reached");
+ MOZ_CRASH("not reached");
return nullptr;
}
void
StreamNotifyChild::ActorDestroy(ActorDestroyReason why)
{
if (AncestorDeletion == why && mBrowserStream) {
NS_ERROR("Pending NPP_URLNotify not called when closing an instance.");
@@ -3438,17 +3438,17 @@ PluginInstanceChild::CreateOptSurface(vo
mWindow.width, mWindow.height,
willHaveTransparentPixels))
return false;
mCurrentSurface = s;
return true;
}
- NS_RUNTIMEABORT("Shared-memory drawing not expected on Windows.");
+ MOZ_CRASH("Shared-memory drawing not expected on Windows.");
#endif
// Make common shmem implementation working for any platform
mCurrentSurface =
gfxSharedImageSurface::CreateUnsafe(this, IntSize(mWindow.width, mWindow.height), format);
return !!mCurrentSurface;
}
@@ -3636,17 +3636,17 @@ PluginInstanceChild::UpdateWindowAttribu
}
}
#endif // MOZ_X11
#ifdef XP_WIN
HDC dc = nullptr;
if (curSurface) {
if (!SharedDIBSurface::IsSharedDIBSurface(curSurface))
- NS_RUNTIMEABORT("Expected SharedDIBSurface!");
+ MOZ_CRASH("Expected SharedDIBSurface!");
SharedDIBSurface* dibsurf = static_cast<SharedDIBSurface*>(curSurface.get());
dc = dibsurf->GetHDC();
}
if (mWindow.window != dc) {
mWindow.window = dc;
needWindowUpdate = true;
}
@@ -3759,17 +3759,17 @@ PluginInstanceChild::PaintRectToPlatform
uintptr_t(&rect)
};
::SetViewportOrgEx((HDC) mWindow.window, -mWindow.x, -mWindow.y, nullptr);
::SelectClipRgn((HDC) mWindow.window, nullptr);
::IntersectClipRect((HDC) mWindow.window, rect.left, rect.top, rect.right, rect.bottom);
mPluginIface->event(&mData, reinterpret_cast<void*>(&paintEvent));
#else
- NS_RUNTIMEABORT("Surface type not implemented.");
+ MOZ_CRASH("Surface type not implemented.");
#endif
}
void
PluginInstanceChild::PaintRectToSurface(const nsIntRect& aRect,
gfxASurface* aSurface,
const Color& aColor)
{
@@ -3875,17 +3875,17 @@ PluginInstanceChild::PaintRectWithAlphaE
return;
}
#ifdef XP_WIN
// On windows, we need an HDC and so can't paint directly to
// vanilla image surfaces. Bifurcate this painting code so that
// we don't accidentally attempt that.
if (!SharedDIBSurface::IsSharedDIBSurface(aSurface))
- NS_RUNTIMEABORT("Expected SharedDIBSurface!");
+ MOZ_CRASH("Expected SharedDIBSurface!");
// Paint the plugin directly onto the target, with a white
// background and copy the result
PaintRectToSurface(rect, aSurface, Color(1.f, 1.f, 1.f));
{
RefPtr<DrawTarget> dt = CreateDrawTargetForSurface(whiteImage);
RefPtr<SourceSurface> surface =
gfxPlatform::GetSourceSurfaceForSurface(dt, aSurface);
@@ -4148,17 +4148,17 @@ PluginInstanceChild::ShowPluginFrame()
}
currSurf = mCurrentSurfaceActor;
s->Flush();
} else
#endif
if (gfxSharedImageSurface::IsSharedImage(mCurrentSurface)) {
currSurf = static_cast<gfxSharedImageSurface*>(mCurrentSurface.get())->GetShmem();
} else {
- NS_RUNTIMEABORT("Surface type is not remotable");
+ MOZ_CRASH("Surface type is not remotable");
return false;
}
// Unused, except to possibly return a shmem to us
SurfaceDescriptor returnSurf;
if (!SendShow(r, currSurf, &returnSurf)) {
return false;
@@ -4310,17 +4310,17 @@ PluginInstanceChild::RecvUpdateBackgroun
break;
}
#endif
case SurfaceDescriptor::TShmem: {
mBackground = gfxSharedImageSurface::Open(aBackground.get_Shmem());
break;
}
default:
- NS_RUNTIMEABORT("Unexpected background surface descriptor");
+ MOZ_CRASH("Unexpected background surface descriptor");
}
if (!mBackground) {
return IPC_FAIL_NO_REASON(this);
}
IntSize bgSize = mBackground->GetSize();
mAccumulatedInvalidRect.UnionRect(mAccumulatedInvalidRect,
@@ -4570,17 +4570,17 @@ DeleteObjects(nsTHashtable<DeletingObjec
void
PluginInstanceChild::Destroy()
{
if (mDestroyed) {
return;
}
if (mStackDepth != 0) {
- NS_RUNTIMEABORT("Destroying plugin instance on the stack.");
+ MOZ_CRASH("Destroying plugin instance on the stack.");
}
mDestroyed = true;
#if defined(OS_WIN)
SetProp(mPluginWindowHWND, kPluginIgnoreSubclassProperty, (HANDLE)1);
#endif
InfallibleTArray<PBrowserStreamChild*> streams;
--- a/dom/plugins/ipc/PluginInstanceParent.cpp
+++ b/dom/plugins/ipc/PluginInstanceParent.cpp
@@ -229,17 +229,17 @@ PluginInstanceParent::IsUsingDirectDrawi
PBrowserStreamParent*
PluginInstanceParent::AllocPBrowserStreamParent(const nsCString& url,
const uint32_t& length,
const uint32_t& lastmodified,
PStreamNotifyParent* notifyData,
const nsCString& headers)
{
- NS_RUNTIMEABORT("Not reachable");
+ MOZ_CRASH("Not reachable");
return nullptr;
}
bool
PluginInstanceParent::DeallocPBrowserStreamParent(PBrowserStreamParent* stream)
{
delete stream;
return true;
@@ -1313,17 +1313,17 @@ PluginInstanceParent::GetImageContainer(
mImageContainer = LayerManager::CreateImageContainer();
}
return mImageContainer;
}
PPluginBackgroundDestroyerParent*
PluginInstanceParent::AllocPPluginBackgroundDestroyerParent()
{
- NS_RUNTIMEABORT("'Power-user' ctor is used exclusively");
+ MOZ_CRASH("'Power-user' ctor is used exclusively");
return nullptr;
}
bool
PluginInstanceParent::DeallocPPluginBackgroundDestroyerParent(
PPluginBackgroundDestroyerParent* aActor)
{
delete aActor;
@@ -1827,26 +1827,26 @@ PluginInstanceParent::NPP_DestroyStream(
// With async plugin init this could happen if async NPP_NewStream
// returns an error code.
return NPERR_NO_ERROR;
}
if (s->IsBrowserStream()) {
BrowserStreamParent* sp =
static_cast<BrowserStreamParent*>(s);
if (sp->mNPP != this)
- NS_RUNTIMEABORT("Mismatched plugin data");
+ MOZ_CRASH("Mismatched plugin data");
sp->NPP_DestroyStream(reason);
return NPERR_NO_ERROR;
}
else {
PluginStreamParent* sp =
static_cast<PluginStreamParent*>(s);
if (sp->mInstance != this)
- NS_RUNTIMEABORT("Mismatched plugin data");
+ MOZ_CRASH("Mismatched plugin data");
return PPluginStreamParent::Call__delete__(sp, reason, false) ?
NPERR_NO_ERROR : NPERR_GENERIC_ERROR;
}
}
void
PluginInstanceParent::NPP_Print(NPPrint* platformPrint)
@@ -2400,17 +2400,17 @@ PluginInstanceParent::Cast(NPP aInstance
// aInstance->pdata will be nullptr.
if (!resolver) {
return nullptr;
}
PluginInstanceParent* instancePtr = resolver->GetInstance();
if (instancePtr && aInstance != instancePtr->mNPP) {
- NS_RUNTIMEABORT("Corrupted plugin data.");
+ MOZ_CRASH("Corrupted plugin data.");
}
if (aSurrogate) {
*aSurrogate = resolver->GetAsyncSurrogate();
}
return instancePtr;
}
--- a/dom/plugins/ipc/PluginMessageUtils.h
+++ b/dom/plugins/ipc/PluginMessageUtils.h
@@ -580,20 +580,20 @@ struct ParamTraits<NSCursorInfo>
}
};
#else
template<>
struct ParamTraits<NSCursorInfo>
{
typedef NSCursorInfo paramType;
static void Write(Message* aMsg, const paramType& aParam) {
- NS_RUNTIMEABORT("NSCursorInfo isn't meaningful on this platform");
+ MOZ_CRASH("NSCursorInfo isn't meaningful on this platform");
}
static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult) {
- NS_RUNTIMEABORT("NSCursorInfo isn't meaningful on this platform");
+ MOZ_CRASH("NSCursorInfo isn't meaningful on this platform");
return false;
}
};
#endif // #ifdef XP_MACOSX
template <>
struct ParamTraits<mozilla::plugins::IPCByteRange>
{
--- a/dom/plugins/ipc/PluginModuleChild.cpp
+++ b/dom/plugins/ipc/PluginModuleChild.cpp
@@ -554,17 +554,17 @@ PluginModuleChild::RecvSetParentHangTime
#endif
return IPC_OK();
}
bool
PluginModuleChild::ShouldContinueFromReplyTimeout()
{
#ifdef XP_WIN
- NS_RUNTIMEABORT("terminating child process");
+ MOZ_CRASH("terminating child process");
#endif
return true;
}
bool
PluginModuleChild::InitGraphics()
{
#if defined(MOZ_WIDGET_GTK)
@@ -2395,17 +2395,17 @@ void
PluginModuleChild::NPN_GetStringIdentifiers(const NPUTF8** aNames,
int32_t aNameCount,
NPIdentifier* aIdentifiers)
{
PLUGIN_LOG_DEBUG_FUNCTION;
AssertPluginThread();
if (!(aNames && aNameCount > 0 && aIdentifiers)) {
- NS_RUNTIMEABORT("Bad input! Headed for a crash!");
+ MOZ_CRASH("Bad input! Headed for a crash!");
}
for (int32_t index = 0; index < aNameCount; ++index) {
if (!aNames[index]) {
aIdentifiers[index] = 0;
continue;
}
nsDependentCString name(aNames[index]);
--- a/dom/plugins/ipc/PluginModuleParent.cpp
+++ b/dom/plugins/ipc/PluginModuleParent.cpp
@@ -692,17 +692,17 @@ PluginModuleParent::PluginModuleParent(b
NS_LITERAL_CSTRING("1") :
NS_LITERAL_CSTRING("0"));
#endif
}
PluginModuleParent::~PluginModuleParent()
{
if (!OkToCleanup()) {
- NS_RUNTIMEABORT("unsafe destruction");
+ MOZ_CRASH("unsafe destruction");
}
if (!mShutdown) {
NS_WARNING("Plugin host deleted the module without shutting down.");
NPError err;
NP_Shutdown(&err);
}
}
@@ -759,17 +759,17 @@ PluginModuleChromeParent::PluginModuleCh
#endif
mozilla::HangMonitor::RegisterAnnotator(*this);
}
PluginModuleChromeParent::~PluginModuleChromeParent()
{
if (!OkToCleanup()) {
- NS_RUNTIMEABORT("unsafe destruction");
+ MOZ_CRASH("unsafe destruction");
}
#ifdef MOZ_ENABLE_PROFILER_SPS
ShutdownPluginProfiling();
#endif
#ifdef XP_WIN
// If we registered for audio notifications, stop.
@@ -1598,17 +1598,17 @@ PluginModuleParent::ActorDestroy(ActorDe
&PluginModuleParent::NotifyPluginCrashed));
break;
}
case NormalShutdown:
mShutdown = true;
break;
default:
- NS_RUNTIMEABORT("Unexpected shutdown reason for toplevel actor.");
+ MOZ_CRASH("Unexpected shutdown reason for toplevel actor.");
}
}
nsresult
PluginModuleParent::GetRunID(uint32_t* aRunID)
{
if (NS_WARN_IF(!aRunID)) {
return NS_ERROR_INVALID_POINTER;
@@ -1891,17 +1891,17 @@ PluginModuleChromeParent::AnswerNPN_SetV
return IPC_OK();
#endif
}
mozilla::ipc::IPCResult
PluginModuleParent::RecvBackUpXResources(const FileDescriptor& aXSocketFd)
{
#ifndef MOZ_X11
- NS_RUNTIMEABORT("This message only makes sense on X11 platforms");
+ MOZ_CRASH("This message only makes sense on X11 platforms");
#else
MOZ_ASSERT(0 > mPluginXSocketFdDup.get(),
"Already backed up X resources??");
if (aXSocketFd.IsValid()) {
auto rawFD = aXSocketFd.ClonePlatformHandle();
mPluginXSocketFdDup.reset(rawFD.release());
}
#endif
@@ -1926,17 +1926,17 @@ PluginModuleParent::StreamCast(NPP insta
PluginInstanceParent* ip = PluginInstanceParent::Cast(instance, aSurrogate);
if (!ip || (aSurrogate && *aSurrogate && ip->UseSurrogate())) {
return nullptr;
}
BrowserStreamParent* sp =
static_cast<BrowserStreamParent*>(static_cast<AStream*>(s->pdata));
if (sp && (sp->mNPP != ip || s != sp->mStream)) {
- NS_RUNTIMEABORT("Corrupted plugin stream data.");
+ MOZ_CRASH("Corrupted plugin stream data.");
}
return sp;
}
bool
PluginModuleParent::HasRequiredFunctions()
{
return true;
--- a/dom/plugins/ipc/PluginScriptableObjectChild.cpp
+++ b/dom/plugins/ipc/PluginScriptableObjectChild.cpp
@@ -128,30 +128,30 @@ FromNPIdentifier(NPIdentifier aIdentifie
// static
NPObject*
PluginScriptableObjectChild::ScriptableAllocate(NPP aInstance,
NPClass* aClass)
{
AssertPluginThread();
if (aClass != GetClass()) {
- NS_RUNTIMEABORT("Huh?! Wrong class!");
+ MOZ_CRASH("Huh?! Wrong class!");
}
return new ChildNPObject();
}
// static
void
PluginScriptableObjectChild::ScriptableInvalidate(NPObject* aObject)
{
AssertPluginThread();
if (aObject->_class != GetClass()) {
- NS_RUNTIMEABORT("Don't know what kind of object this is!");
+ MOZ_CRASH("Don't know what kind of object this is!");
}
ChildNPObject* object = reinterpret_cast<ChildNPObject*>(aObject);
if (object->invalidated) {
// This can happen more than once, and is just fine.
return;
}
@@ -160,17 +160,17 @@ PluginScriptableObjectChild::ScriptableI
// static
void
PluginScriptableObjectChild::ScriptableDeallocate(NPObject* aObject)
{
AssertPluginThread();
if (aObject->_class != GetClass()) {
- NS_RUNTIMEABORT("Don't know what kind of object this is!");
+ MOZ_CRASH("Don't know what kind of object this is!");
}
ChildNPObject* object = reinterpret_cast<ChildNPObject*>(aObject);
PluginScriptableObjectChild* actor = object->parent;
if (actor) {
NS_ASSERTION(actor->Type() == Proxy, "Bad type!");
actor->DropNPObject();
}
@@ -181,17 +181,17 @@ PluginScriptableObjectChild::ScriptableD
// static
bool
PluginScriptableObjectChild::ScriptableHasMethod(NPObject* aObject,
NPIdentifier aName)
{
AssertPluginThread();
if (aObject->_class != GetClass()) {
- NS_RUNTIMEABORT("Don't know what kind of object this is!");
+ MOZ_CRASH("Don't know what kind of object this is!");
}
ChildNPObject* object = reinterpret_cast<ChildNPObject*>(aObject);
if (object->invalidated) {
NS_WARNING("Calling method on an invalidated object!");
return false;
}
@@ -211,17 +211,17 @@ PluginScriptableObjectChild::ScriptableI
NPIdentifier aName,
const NPVariant* aArgs,
uint32_t aArgCount,
NPVariant* aResult)
{
AssertPluginThread();
if (aObject->_class != GetClass()) {
- NS_RUNTIMEABORT("Don't know what kind of object this is!");
+ MOZ_CRASH("Don't know what kind of object this is!");
}
ChildNPObject* object = reinterpret_cast<ChildNPObject*>(aObject);
if (object->invalidated) {
NS_WARNING("Calling method on an invalidated object!");
return false;
}
@@ -253,17 +253,17 @@ bool
PluginScriptableObjectChild::ScriptableInvokeDefault(NPObject* aObject,
const NPVariant* aArgs,
uint32_t aArgCount,
NPVariant* aResult)
{
AssertPluginThread();
if (aObject->_class != GetClass()) {
- NS_RUNTIMEABORT("Don't know what kind of object this is!");
+ MOZ_CRASH("Don't know what kind of object this is!");
}
ChildNPObject* object = reinterpret_cast<ChildNPObject*>(aObject);
if (object->invalidated) {
NS_WARNING("Calling method on an invalidated object!");
return false;
}
@@ -292,17 +292,17 @@ PluginScriptableObjectChild::ScriptableI
// static
bool
PluginScriptableObjectChild::ScriptableHasProperty(NPObject* aObject,
NPIdentifier aName)
{
AssertPluginThread();
if (aObject->_class != GetClass()) {
- NS_RUNTIMEABORT("Don't know what kind of object this is!");
+ MOZ_CRASH("Don't know what kind of object this is!");
}
ChildNPObject* object = reinterpret_cast<ChildNPObject*>(aObject);
if (object->invalidated) {
NS_WARNING("Calling method on an invalidated object!");
return false;
}
@@ -320,17 +320,17 @@ PluginScriptableObjectChild::ScriptableH
bool
PluginScriptableObjectChild::ScriptableGetProperty(NPObject* aObject,
NPIdentifier aName,
NPVariant* aResult)
{
AssertPluginThread();
if (aObject->_class != GetClass()) {
- NS_RUNTIMEABORT("Don't know what kind of object this is!");
+ MOZ_CRASH("Don't know what kind of object this is!");
}
ChildNPObject* object = reinterpret_cast<ChildNPObject*>(aObject);
if (object->invalidated) {
NS_WARNING("Calling method on an invalidated object!");
return false;
}
@@ -357,17 +357,17 @@ PluginScriptableObjectChild::ScriptableG
bool
PluginScriptableObjectChild::ScriptableSetProperty(NPObject* aObject,
NPIdentifier aName,
const NPVariant* aValue)
{
AssertPluginThread();
if (aObject->_class != GetClass()) {
- NS_RUNTIMEABORT("Don't know what kind of object this is!");
+ MOZ_CRASH("Don't know what kind of object this is!");
}
ChildNPObject* object = reinterpret_cast<ChildNPObject*>(aObject);
if (object->invalidated) {
NS_WARNING("Calling method on an invalidated object!");
return false;
}
@@ -391,17 +391,17 @@ PluginScriptableObjectChild::ScriptableS
// static
bool
PluginScriptableObjectChild::ScriptableRemoveProperty(NPObject* aObject,
NPIdentifier aName)
{
AssertPluginThread();
if (aObject->_class != GetClass()) {
- NS_RUNTIMEABORT("Don't know what kind of object this is!");
+ MOZ_CRASH("Don't know what kind of object this is!");
}
ChildNPObject* object = reinterpret_cast<ChildNPObject*>(aObject);
if (object->invalidated) {
NS_WARNING("Calling method on an invalidated object!");
return false;
}
@@ -420,17 +420,17 @@ PluginScriptableObjectChild::ScriptableR
bool
PluginScriptableObjectChild::ScriptableEnumerate(NPObject* aObject,
NPIdentifier** aIdentifiers,
uint32_t* aCount)
{
AssertPluginThread();
if (aObject->_class != GetClass()) {
- NS_RUNTIMEABORT("Don't know what kind of object this is!");
+ MOZ_CRASH("Don't know what kind of object this is!");
}
ChildNPObject* object = reinterpret_cast<ChildNPObject*>(aObject);
if (object->invalidated) {
NS_WARNING("Calling method on an invalidated object!");
return false;
}
@@ -473,17 +473,17 @@ bool
PluginScriptableObjectChild::ScriptableConstruct(NPObject* aObject,
const NPVariant* aArgs,
uint32_t aArgCount,
NPVariant* aResult)
{
AssertPluginThread();
if (aObject->_class != GetClass()) {
- NS_RUNTIMEABORT("Don't know what kind of object this is!");
+ MOZ_CRASH("Don't know what kind of object this is!");
}
ChildNPObject* object = reinterpret_cast<ChildNPObject*>(aObject);
if (object->invalidated) {
NS_WARNING("Calling method on an invalidated object!");
return false;
}
--- a/dom/plugins/ipc/PluginStreamChild.h
+++ b/dom/plugins/ipc/PluginStreamChild.h
@@ -28,22 +28,22 @@ public:
const bool& artificial) override;
int32_t NPN_Write(int32_t length, void* buffer);
void NPP_DestroyStream(NPError reason);
void EnsureCorrectInstance(PluginInstanceChild* i)
{
if (i != Instance())
- NS_RUNTIMEABORT("Incorrect stream instance");
+ MOZ_CRASH("Incorrect stream instance");
}
void EnsureCorrectStream(NPStream* s)
{
if (s != &mStream)
- NS_RUNTIMEABORT("Incorrect stream data");
+ MOZ_CRASH("Incorrect stream data");
}
private:
PluginInstanceChild* Instance();
NPStream mStream;
bool mClosed;
};
--- a/dom/workers/ServiceWorkerPrivate.cpp
+++ b/dom/workers/ServiceWorkerPrivate.cpp
@@ -703,17 +703,17 @@ public:
if (mDone) {
return;
}
mDone = true;
mCallback->SetResult(aResult);
nsresult rv = mWorkerPrivate->DispatchToMainThread(mCallback);
if (NS_WARN_IF(NS_FAILED(rv))) {
- NS_RUNTIMEABORT("Failed to dispatch life cycle event handler.");
+ MOZ_CRASH("Failed to dispatch life cycle event handler.");
}
ReleaseWorker();
}
void
FinishedWithResult(ExtendableEventResult aResult) override
{
--- a/dom/xhr/XMLHttpRequestWorker.cpp
+++ b/dom/xhr/XMLHttpRequestWorker.cpp
@@ -901,28 +901,28 @@ Proxy::Teardown(bool aSendUnpin)
rv.SuppressException();
}
if (mOutstandingSendCount) {
if (aSendUnpin) {
RefPtr<XHRUnpinRunnable> runnable =
new XHRUnpinRunnable(mWorkerPrivate, mXMLHttpRequestPrivate);
if (!runnable->Dispatch()) {
- NS_RUNTIMEABORT("We're going to hang at shutdown anyways.");
+ MOZ_CRASH("We're going to hang at shutdown anyways.");
}
}
if (mSyncLoopTarget) {
// We have an unclosed sync loop. Fix that now.
RefPtr<MainThreadStopSyncLoopRunnable> runnable =
new MainThreadStopSyncLoopRunnable(mWorkerPrivate,
mSyncLoopTarget.forget(),
false);
if (!runnable->Dispatch()) {
- NS_RUNTIMEABORT("We're going to hang at shutdown anyways.");
+ MOZ_CRASH("We're going to hang at shutdown anyways.");
}
}
mOutstandingSendCount = 0;
}
mWorkerPrivate = nullptr;
mXHRUpload = nullptr;
--- a/dom/xslt/xslt/txMozillaXSLTProcessor.cpp
+++ b/dom/xslt/xslt/txMozillaXSLTProcessor.cpp
@@ -120,17 +120,17 @@ txToDocHandlerFactory::createHandlerWith
if (NS_SUCCEEDED(rv)) {
*aHandler = handler.forget();
}
return rv;
}
}
- NS_RUNTIMEABORT("Unknown output method");
+ MOZ_CRASH("Unknown output method");
return NS_ERROR_FAILURE;
}
nsresult
txToDocHandlerFactory::createHandlerWith(txOutputFormat* aFormat,
const nsSubstring& aName,
int32_t aNsID,
@@ -170,17 +170,17 @@ txToDocHandlerFactory::createHandlerWith
if (NS_SUCCEEDED(rv)) {
*aHandler = handler.forget();
}
return rv;
}
}
- NS_RUNTIMEABORT("Unknown output method");
+ MOZ_CRASH("Unknown output method");
return NS_ERROR_FAILURE;
}
nsresult
txToFragmentHandlerFactory::createHandlerWith(txOutputFormat* aFormat,
txAXMLEventHandler** aHandler)
{
--- a/dom/xslt/xslt/txStylesheetCompiler.cpp
+++ b/dom/xslt/xslt/txStylesheetCompiler.cpp
@@ -671,29 +671,29 @@ txStylesheetCompilerState::pushPtr(void*
return mOtherStack.push(aPtr);
}
void*
txStylesheetCompilerState::popPtr(enumStackType aType)
{
uint32_t stacklen = mTypeStack.Length();
if (stacklen == 0) {
- NS_RUNTIMEABORT("Attempt to pop when type stack is empty");
+ MOZ_CRASH("Attempt to pop when type stack is empty");
}
enumStackType type = mTypeStack.ElementAt(stacklen - 1);
mTypeStack.RemoveElementAt(stacklen - 1);
void* value = mOtherStack.pop();
#ifdef TX_DEBUG_STACK
MOZ_LOG(txLog::xslt, LogLevel::Debug, ("popPtr: 0x%x type %u requested %u\n", value, type, aType));
#endif
if (type != aType) {
- NS_RUNTIMEABORT("Expected type does not match top element type");
+ MOZ_CRASH("Expected type does not match top element type");
}
return value;
}
nsresult
txStylesheetCompilerState::addToplevelItem(txToplevelItem* aItem)
{
--- a/extensions/cookie/nsPermissionManager.cpp
+++ b/extensions/cookie/nsPermissionManager.cpp
@@ -58,17 +58,17 @@ IsChildProcess()
* process, nullptr.
*/
static ContentChild*
ChildProcess()
{
if (IsChildProcess()) {
ContentChild* cpc = ContentChild::GetSingleton();
if (!cpc)
- NS_RUNTIMEABORT("Content Process is nullptr!");
+ MOZ_CRASH("Content Process is nullptr!");
return cpc;
}
return nullptr;
}
static void
LogToConsole(const nsAString& aMsg)
--- a/gfx/gl/GLContext.cpp
+++ b/gfx/gl/GLContext.cpp
@@ -2145,23 +2145,23 @@ GLContext::AssembleOffscreenFBs(const GL
}
#endif
isComplete = false;
}
if (drawFB_out) {
*drawFB_out = drawFB;
} else if (drawFB) {
- NS_RUNTIMEABORT("drawFB created when not requested!");
+ MOZ_CRASH("drawFB created when not requested!");
}
if (readFB_out) {
*readFB_out = readFB;
} else if (readFB) {
- NS_RUNTIMEABORT("readFB created when not requested!");
+ MOZ_CRASH("readFB created when not requested!");
}
return isComplete;
}
void
GLContext::ClearSafely()
--- a/gfx/layers/basic/BasicCompositor.cpp
+++ b/gfx/layers/basic/BasicCompositor.cpp
@@ -679,17 +679,17 @@ BasicCompositor::DrawQuad(const gfx::Rec
}
} else {
gfxDevCrash(LogReason::IncompatibleBasicTexturedEffect) << "Bad for basic with " << texturedEffect->mTexture->Name() << " and " << gfx::hexa(sourceMask);
}
break;
}
case EffectTypes::YCBCR: {
- NS_RUNTIMEABORT("Can't (easily) support component alpha with BasicCompositor!");
+ MOZ_CRASH("Can't (easily) support component alpha with BasicCompositor!");
break;
}
case EffectTypes::RENDER_TARGET: {
EffectRenderTarget* effectRenderTarget =
static_cast<EffectRenderTarget*>(aEffectChain.mPrimaryEffect.get());
RefPtr<BasicCompositingRenderTarget> surface
= static_cast<BasicCompositingRenderTarget*>(effectRenderTarget->mRenderTarget.get());
RefPtr<SourceSurface> sourceSurf = surface->mDrawTarget->Snapshot();
@@ -698,21 +698,21 @@ BasicCompositor::DrawQuad(const gfx::Rec
sourceSurf,
effectRenderTarget->mTextureCoords,
effectRenderTarget->mSamplingFilter,
DrawOptions(aOpacity, blendMode),
sourceMask, &maskTransform);
break;
}
case EffectTypes::COMPONENT_ALPHA: {
- NS_RUNTIMEABORT("Can't (easily) support component alpha with BasicCompositor!");
+ MOZ_CRASH("Can't (easily) support component alpha with BasicCompositor!");
break;
}
default: {
- NS_RUNTIMEABORT("Invalid effect type!");
+ MOZ_CRASH("Invalid effect type!");
break;
}
}
if (!aTransform.Is2D()) {
dest->Flush();
RefPtr<SourceSurface> destSnapshot = dest->Snapshot();
--- a/gfx/layers/client/ClientLayerManager.cpp
+++ b/gfx/layers/client/ClientLayerManager.cpp
@@ -681,17 +681,17 @@ ClientLayerManager::ForwardTransaction(b
static_cast<ContentClientRemote*>(compositable.get());
MOZ_ASSERT(contentClient);
contentClient->SwapBuffers(obs.frontUpdatedRegion());
break;
}
default:
- NS_RUNTIMEABORT("not reached");
+ MOZ_CRASH("not reached");
}
}
if (sent) {
mNeedsComposite = false;
}
} else if (HasShadowManager()) {
NS_WARNING("failed to forward Layers transaction");
@@ -813,17 +813,17 @@ ClientLayerManager::GetBackendName(nsASt
if (DeviceManagerDx::Get()->IsWARP()) {
aName.AssignLiteral("Direct3D 11 WARP");
} else {
aName.AssignLiteral("Direct3D 11");
}
#endif
return;
}
- default: NS_RUNTIMEABORT("Invalid backend");
+ default: MOZ_CRASH("Invalid backend");
}
}
bool
ClientLayerManager::AsyncPanZoomEnabled() const
{
return mWidget && mWidget->AsyncPanZoomEnabled();
}
--- a/gfx/layers/composite/CanvasLayerComposite.h
+++ b/gfx/layers/composite/CanvasLayerComposite.h
@@ -31,17 +31,17 @@ public:
protected:
virtual ~CanvasLayerComposite();
public:
// CanvasLayer impl
virtual void Initialize(const Data& aData) override
{
- NS_RUNTIMEABORT("Incompatibe surface type");
+ MOZ_CRASH("Incompatibe surface type");
}
virtual LayerRenderState GetRenderState() override;
virtual bool SetCompositableHost(CompositableHost* aHost) override;
virtual void Disconnect() override
{
--- a/gfx/layers/composite/LayerManagerComposite.cpp
+++ b/gfx/layers/composite/LayerManagerComposite.cpp
@@ -486,17 +486,17 @@ LayerManagerComposite::UpdateAndRender()
// Update cached layer tree information.
mClonedLayerTreeProperties = LayerProperties::CloneFrom(GetRoot());
}
already_AddRefed<DrawTarget>
LayerManagerComposite::CreateOptimalMaskDrawTarget(const IntSize &aSize)
{
- NS_RUNTIMEABORT("Should only be called on the drawing side");
+ MOZ_CRASH("Should only be called on the drawing side");
return nullptr;
}
already_AddRefed<PaintedLayer>
LayerManagerComposite::CreatePaintedLayer()
{
MOZ_ASSERT(gIsGtest, "Unless you're testing the compositor using GTest,"
"this should only be called on the drawing side");
@@ -511,33 +511,33 @@ LayerManagerComposite::CreateContainerLa
"this should only be called on the drawing side");
RefPtr<ContainerLayer> layer = new ContainerLayerComposite(this);
return layer.forget();
}
already_AddRefed<ImageLayer>
LayerManagerComposite::CreateImageLayer()
{
- NS_RUNTIMEABORT("Should only be called on the drawing side");
+ MOZ_CRASH("Should only be called on the drawing side");
return nullptr;
}
already_AddRefed<ColorLayer>
LayerManagerComposite::CreateColorLayer()
{
MOZ_ASSERT(gIsGtest, "Unless you're testing the compositor using GTest,"
"this should only be called on the drawing side");
RefPtr<ColorLayer> layer = new ColorLayerComposite(this);
return layer.forget();
}
already_AddRefed<CanvasLayer>
LayerManagerComposite::CreateCanvasLayer()
{
- NS_RUNTIMEABORT("Should only be called on the drawing side");
+ MOZ_CRASH("Should only be called on the drawing side");
return nullptr;
}
LayerComposite*
LayerManagerComposite::RootLayer() const
{
if (mDestroyed) {
NS_WARNING("Call on destroyed layer manager");
--- a/gfx/layers/composite/PaintedLayerComposite.h
+++ b/gfx/layers/composite/PaintedLayerComposite.h
@@ -58,17 +58,17 @@ public:
virtual void GenEffectChain(EffectChain& aEffect) override;
virtual bool SetCompositableHost(CompositableHost* aHost) override;
virtual LayerComposite* AsLayerComposite() override { return this; }
virtual void InvalidateRegion(const nsIntRegion& aRegion) override
{
- NS_RUNTIMEABORT("PaintedLayerComposites can't fill invalidated regions");
+ MOZ_CRASH("PaintedLayerComposites can't fill invalidated regions");
}
void SetValidRegion(const nsIntRegion& aRegion)
{
MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) ValidRegion", this));
mValidRegion = aRegion;
Mutated();
}
--- a/gfx/layers/d3d11/CompositorD3D11.h
+++ b/gfx/layers/d3d11/CompositorD3D11.h
@@ -80,17 +80,17 @@ public:
/**
* Declare an offset to use when rendering layers. This will be ignored when
* rendering to a target instead of the screen.
*/
virtual void SetScreenRenderOffset(const ScreenPoint& aOffset) override
{
if (aOffset.x || aOffset.y) {
- NS_RUNTIMEABORT("SetScreenRenderOffset not supported by CompositorD3D11.");
+ MOZ_CRASH("SetScreenRenderOffset not supported by CompositorD3D11.");
}
// If the offset is 0, 0 that's okay.
}
virtual void ClearRect(const gfx::Rect& aRect) override;
virtual void DrawQuad(const gfx::Rect &aRect,
const gfx::IntRect &aClipRect,
--- a/gfx/layers/d3d9/CompositorD3D9.h
+++ b/gfx/layers/d3d9/CompositorD3D9.h
@@ -108,17 +108,17 @@ public:
/**
* Declare an offset to use when rendering layers. This will be ignored when
* rendering to a target instead of the screen.
*/
virtual void SetScreenRenderOffset(const ScreenPoint& aOffset) override
{
if (aOffset.x || aOffset.y) {
- NS_RUNTIMEABORT("SetScreenRenderOffset not supported by CompositorD3D9.");
+ MOZ_CRASH("SetScreenRenderOffset not supported by CompositorD3D9.");
}
// If the offset is 0, 0 that's okay.
}
virtual already_AddRefed<DataTextureSource>
CreateDataTextureSource(TextureFlags aFlags = TextureFlags::NO_FLAGS) override;
private:
// ensure mSize is up to date with respect to mWidget
--- a/gfx/layers/ipc/ImageBridgeChild.cpp
+++ b/gfx/layers/ipc/ImageBridgeChild.cpp
@@ -638,17 +638,17 @@ ImageBridgeChild::EndTransaction()
// If we don't require a swap we can call SendUpdateNoSwap which
// assumes that aReplies is empty (DEBUG assertion)
if (!SendUpdateNoSwap(cset, mTxn->mDestroyedActors, GetFwdTransactionId())) {
NS_WARNING("could not send async texture transaction (no swap)");
return;
}
}
for (nsTArray<EditReply>::size_type i = 0; i < replies.Length(); ++i) {
- NS_RUNTIMEABORT("not reached");
+ MOZ_CRASH("not reached");
}
}
void
ImageBridgeChild::SendImageBridgeThreadId()
{
}
@@ -1092,17 +1092,17 @@ ImageBridgeChild::DeallocPMediaSystemRes
delete static_cast<mozilla::media::MediaSystemResourceManagerChild*>(aActor);
return true;
}
PImageContainerChild*
ImageBridgeChild::AllocPImageContainerChild()
{
// we always use the "power-user" ctor
- NS_RUNTIMEABORT("not reached");
+ MOZ_CRASH("not reached");
return nullptr;
}
bool
ImageBridgeChild::DeallocPImageContainerChild(PImageContainerChild* actor)
{
static_cast<ImageContainerChild*>(actor)->UnregisterFromIPDL();
return true;
--- a/gfx/layers/ipc/ImageBridgeChild.h
+++ b/gfx/layers/ipc/ImageBridgeChild.h
@@ -298,23 +298,23 @@ public:
virtual bool DestroyInTransaction(PCompositableChild* aCompositable, bool synchronously) override;
virtual void RemoveTextureFromCompositable(CompositableClient* aCompositable,
TextureClient* aTexture) override;
virtual void UseTiledLayerBuffer(CompositableClient* aCompositable,
const SurfaceDescriptorTiles& aTileLayerDescriptor) override
{
- NS_RUNTIMEABORT("should not be called");
+ MOZ_CRASH("should not be called");
}
virtual void UpdateTextureRegion(CompositableClient* aCompositable,
const ThebesBufferData& aThebesBufferData,
const nsIntRegion& aUpdatedRegion) override {
- NS_RUNTIMEABORT("should not be called");
+ MOZ_CRASH("should not be called");
}
// ISurfaceAllocator
/**
* See ISurfaceAllocator.h
* Can be used from any thread.
* If used outside the ImageBridgeChild thread, it will proxy a synchronous
--- a/gfx/layers/ipc/LayerTransactionChild.cpp
+++ b/gfx/layers/ipc/LayerTransactionChild.cpp
@@ -38,17 +38,17 @@ LayerTransactionChild::Destroy()
SendShutdown();
}
PLayerChild*
LayerTransactionChild::AllocPLayerChild()
{
// we always use the "power-user" ctor
- NS_RUNTIMEABORT("not reached");
+ MOZ_CRASH("not reached");
return nullptr;
}
bool
LayerTransactionChild::DeallocPLayerChild(PLayerChild* actor)
{
delete actor;
return true;
--- a/gfx/layers/ipc/LayerTransactionParent.cpp
+++ b/gfx/layers/ipc/LayerTransactionParent.cpp
@@ -489,17 +489,17 @@ LayerTransactionParent::RecvUpdate(Infal
return IPC_FAIL_NO_REASON(this);
}
const ImageLayerAttributes& attrs = specific.get_ImageLayerAttributes();
imageLayer->SetSamplingFilter(attrs.samplingFilter());
imageLayer->SetScaleToSize(attrs.scaleToSize(), attrs.scaleMode());
break;
}
default:
- NS_RUNTIMEABORT("not reached");
+ MOZ_CRASH("not reached");
}
updateHitTestingTree = true;
break;
}
case Edit::TOpSetDiagnosticTypes: {
mLayerManager->GetCompositor()->SetDiagnosticTypes(
edit.get_OpSetDiagnosticTypes().diagnostics());
@@ -652,17 +652,17 @@ LayerTransactionParent::RecvUpdate(Infal
CompositableHost* host = CompositableHost::FromIPDLActor(compositableParent);
if (!Attach(cast(op.layerParent()), host, true)) {
return IPC_FAIL_NO_REASON(this);
}
host->SetCompositorID(mLayerManager->GetCompositor()->GetCompositorID());
break;
}
default:
- NS_RUNTIMEABORT("not reached");
+ MOZ_CRASH("not reached");
}
}
mCompositorBridge->ShadowLayersUpdated(this, aTransactionId, targetConfig,
aPlugins, isFirstPaint, scheduleComposite,
paintSequenceNumber, isRepeatTransaction,
aPaintSyncId, updateHitTestingTree);
--- a/gfx/layers/ipc/ShadowLayerParent.cpp
+++ b/gfx/layers/ipc/ShadowLayerParent.cpp
@@ -104,17 +104,17 @@ ShadowLayerParent::AsPaintedLayerComposi
: nullptr;
}
void
ShadowLayerParent::ActorDestroy(ActorDestroyReason why)
{
switch (why) {
case AncestorDeletion:
- NS_RUNTIMEABORT("shadow layer deleted out of order!");
+ MOZ_CRASH("shadow layer deleted out of order!");
return; // unreached
case Deletion:
// See comment near Destroy() above.
Disconnect();
break;
case AbnormalShutdown:
@@ -122,17 +122,17 @@ ShadowLayerParent::ActorDestroy(ActorDes
break;
case NormalShutdown:
// let IPDL-generated code automatically clean up Shmems and so
// forth; our channel is disconnected anyway
break;
case FailedConstructor:
- NS_RUNTIMEABORT("FailedConstructor isn't possible in PLayerTransaction");
+ MOZ_CRASH("FailedConstructor isn't possible in PLayerTransaction");
return; // unreached
}
mLayer = nullptr;
}
} // namespace layers
} // namespace mozilla
--- a/gfx/layers/opengl/CompositorOGL.cpp
+++ b/gfx/layers/opengl/CompositorOGL.cpp
@@ -230,17 +230,17 @@ CompositorOGL::Initialize(nsCString* con
// Do not allow double initialization
MOZ_ASSERT(mGLContext == nullptr, "Don't reinitialize CompositorOGL");
mGLContext = CreateContext();
#ifdef MOZ_WIDGET_ANDROID
if (!mGLContext){
*out_failureReason = "FEATURE_FAILURE_OPENGL_NO_ANDROID_CONTEXT";
- NS_RUNTIMEABORT("We need a context on Android");
+ MOZ_CRASH("We need a context on Android");
}
#endif
if (!mGLContext){
*out_failureReason = "FEATURE_FAILURE_OPENGL_CREATE_CONTEXT";
return false;
}
--- a/gfx/tests/gtest/TestLayers.cpp
+++ b/gfx/tests/gtest/TestLayers.cpp
@@ -62,17 +62,17 @@ public:
virtual already_AddRefed<ContainerLayer> CreateContainerLayer() {
RefPtr<ContainerLayer> layer = new TestContainerLayer(this);
return layer.forget();
}
virtual void GetBackendName(nsAString& aName) {}
virtual LayersBackend GetBackendType() { return LayersBackend::LAYERS_BASIC; }
virtual bool BeginTransaction() { return true; }
virtual already_AddRefed<ImageLayer> CreateImageLayer() {
- NS_RUNTIMEABORT("Not implemented.");
+ MOZ_CRASH("Not implemented.");
return nullptr;
}
virtual already_AddRefed<PaintedLayer> CreatePaintedLayer() {
RefPtr<PaintedLayer> layer = new TestPaintedLayer(this);
return layer.forget();
}
virtual already_AddRefed<ColorLayer> CreateColorLayer() {
NS_RUNTIMEABORT("Not implemented.");
--- a/gfx/thebes/gfxFT2FontList.cpp
+++ b/gfx/thebes/gfxFT2FontList.cpp
@@ -1226,17 +1226,17 @@ gfxFT2FontList::FindFonts()
root = NS_LITERAL_CSTRING("/system");
}
root.AppendLiteral("/fonts");
FindFontsInDir(root, mFontNameCache.get(), FT2FontFamily::kVisible);
if (mFontFamilies.Count() == 0) {
// if we can't find/read the font directory, we are doomed!
- NS_RUNTIMEABORT("Could not read the system fonts directory");
+ MOZ_CRASH("Could not read the system fonts directory");
}
// Look for fonts stored in omnijar, unless we're on a low-memory
// device where we don't want to spend the RAM to decompress them.
// (Prefs may disable this, or force-enable it even with low memory.)
bool lowmem;
nsCOMPtr<nsIMemory> mem = nsMemory::GetGlobalMemoryService();
if ((NS_SUCCEEDED(mem->IsLowMemoryPlatform(&lowmem)) && !lowmem &&
--- a/gfx/thebes/gfxPlatform.cpp
+++ b/gfx/thebes/gfxPlatform.cpp
@@ -598,17 +598,17 @@ static uint32_t GetSkiaGlyphCacheSize()
void
gfxPlatform::Init()
{
MOZ_RELEASE_ASSERT(!XRE_IsGPUProcess(), "GFX: Not allowed in GPU process.");
MOZ_RELEASE_ASSERT(NS_IsMainThread(), "GFX: Not in main thread.");
if (gEverInitialized) {
- NS_RUNTIMEABORT("Already started???");
+ MOZ_CRASH("Already started???");
}
gEverInitialized = true;
// Initialize the preferences by creating the singleton.
gfxPrefs::GetSingleton();
MediaPrefs::GetSingleton();
gfxVars::Initialize();
@@ -714,38 +714,38 @@ gfxPlatform::Init()
bool usePlatformFontList = true;
#if defined(MOZ_WIDGET_GTK)
usePlatformFontList = gfxPlatformGtk::UseFcFontList();
#endif
if (usePlatformFontList) {
rv = gfxPlatformFontList::Init();
if (NS_FAILED(rv)) {
- NS_RUNTIMEABORT("Could not initialize gfxPlatformFontList");
+ MOZ_CRASH("Could not initialize gfxPlatformFontList");
}
}
gPlatform->mScreenReferenceSurface =
gPlatform->CreateOffscreenSurface(IntSize(1, 1),
SurfaceFormat::A8R8G8B8_UINT32);
if (!gPlatform->mScreenReferenceSurface) {
- NS_RUNTIMEABORT("Could not initialize mScreenReferenceSurface");
+ MOZ_CRASH("Could not initialize mScreenReferenceSurface");
}
gPlatform->mScreenReferenceDrawTarget =
gPlatform->CreateOffscreenContentDrawTarget(IntSize(1, 1),
SurfaceFormat::B8G8R8A8);
if (!gPlatform->mScreenReferenceDrawTarget ||
!gPlatform->mScreenReferenceDrawTarget->IsValid()) {
- NS_RUNTIMEABORT("Could not initialize mScreenReferenceDrawTarget");
+ MOZ_CRASH("Could not initialize mScreenReferenceDrawTarget");
}
rv = gfxFontCache::Init();
if (NS_FAILED(rv)) {
- NS_RUNTIMEABORT("Could not initialize gfxFontCache");
+ MOZ_CRASH("Could not initialize gfxFontCache");
}
/* Create and register our CMS Override observer. */
gPlatform->mSRGBOverrideObserver = new SRGBOverrideObserver();
Preferences::AddWeakObserver(gPlatform->mSRGBOverrideObserver, GFX_PREF_CMS_FORCE_SRGB);
gPlatform->mFontPrefsObserver = new FontPrefsObserver();
Preferences::AddStrongObservers(gPlatform->mFontPrefsObserver, kObservedPrefs);
@@ -766,17 +766,17 @@ gfxPlatform::Init()
if (obs) {
gPlatform->mMemoryPressureObserver = new MemoryPressureObserver();
obs->AddObserver(gPlatform->mMemoryPressureObserver, "memory-pressure", false);
}
// Request the imgITools service, implicitly initializing ImageLib.
nsCOMPtr<imgITools> imgTools = do_GetService("@mozilla.org/image/tools;1");
if (!imgTools) {
- NS_RUNTIMEABORT("Could not initialize ImageLib");
+ MOZ_CRASH("Could not initialize ImageLib");
}
RegisterStrongMemoryReporter(new GfxMemoryImageReporter());
if (XRE_IsParentProcess()) {
if (gfxPlatform::ForceSoftwareVsync()) {
gPlatform->mVsyncSource = (gPlatform)->gfxPlatform::CreateHardwareVsyncSource();
} else {
@@ -2453,18 +2453,18 @@ gfxPlatform::GetAcceleratedCompositorBac
}
else {
static int tell_me_once = 0;
if (!tell_me_once) {
NS_WARNING("OpenGL-accelerated layers are not supported on this system");
tell_me_once = 1;
}
#ifdef MOZ_WIDGET_ANDROID
- NS_RUNTIMEABORT("OpenGL-accelerated layers are a hard requirement on this platform. "
- "Cannot continue without support for them");
+ MOZ_CRASH("OpenGL-accelerated layers are a hard requirement on this platform. "
+ "Cannot continue without support for them");
#endif
}
}
void
gfxPlatform::GetCompositorBackends(bool useAcceleration, nsTArray<mozilla::layers::LayersBackend>& aBackends)
{
if (useAcceleration) {
--- a/hal/sandbox/SandboxHal.cpp
+++ b/hal/sandbox/SandboxHal.cpp
@@ -241,29 +241,29 @@ void
DisableSystemTimezoneChangeNotifications()
{
Hal()->SendDisableSystemTimezoneChangeNotifications();
}
void
Reboot()
{
- NS_RUNTIMEABORT("Reboot() can't be called from sandboxed contexts.");
+ MOZ_CRASH("Reboot() can't be called from sandboxed contexts.");
}
void
PowerOff()
{
- NS_RUNTIMEABORT("PowerOff() can't be called from sandboxed contexts.");
+ MOZ_CRASH("PowerOff() can't be called from sandboxed contexts.");
}
void
StartForceQuitWatchdog(ShutdownMode aMode, int32_t aTimeoutSecs)
{
- NS_RUNTIMEABORT("StartForceQuitWatchdog() can't be called from sandboxed contexts.");
+ MOZ_CRASH("StartForceQuitWatchdog() can't be called from sandboxed contexts.");
}
void
EnableSensorNotifications(SensorType aSensor) {
Hal()->SendEnableSensorNotifications(aSensor);
}
void
@@ -376,45 +376,45 @@ FactoryReset(FactoryResetReason& aReason
} else if (aReason == FactoryResetReason::Root) {
Hal()->SendFactoryReset(NS_LITERAL_STRING("root"));
}
}
void
StartDiskSpaceWatcher()
{
- NS_RUNTIMEABORT("StartDiskSpaceWatcher() can't be called from sandboxed contexts.");
+ MOZ_CRASH("StartDiskSpaceWatcher() can't be called from sandboxed contexts.");
}
void
StopDiskSpaceWatcher()
{
- NS_RUNTIMEABORT("StopDiskSpaceWatcher() can't be called from sandboxed contexts.");
+ MOZ_CRASH("StopDiskSpaceWatcher() can't be called from sandboxed contexts.");
}
bool IsHeadphoneEventFromInputDev()
{
- NS_RUNTIMEABORT("IsHeadphoneEventFromInputDev() cannot be called from sandboxed contexts.");
+ MOZ_CRASH("IsHeadphoneEventFromInputDev() cannot be called from sandboxed contexts.");
return false;
}
nsresult StartSystemService(const char* aSvcName, const char* aArgs)
{
- NS_RUNTIMEABORT("System services cannot be controlled from sandboxed contexts.");
+ MOZ_CRASH("System services cannot be controlled from sandboxed contexts.");
return NS_ERROR_NOT_IMPLEMENTED;
}
void StopSystemService(const char* aSvcName)
{
- NS_RUNTIMEABORT("System services cannot be controlled from sandboxed contexts.");
+ MOZ_CRASH("System services cannot be controlled from sandboxed contexts.");
}
bool SystemServiceIsRunning(const char* aSvcName)
{
- NS_RUNTIMEABORT("System services cannot be controlled from sandboxed contexts.");
+ MOZ_CRASH("System services cannot be controlled from sandboxed contexts.");
return false;
}
class HalParent : public PHalParent
, public BatteryObserver
, public NetworkObserver
, public ISensorObserver
, public WakeLockObserver
--- a/ipc/glue/CrossProcessMutex_unimplemented.cpp
+++ b/ipc/glue/CrossProcessMutex_unimplemented.cpp
@@ -7,41 +7,41 @@
#include "CrossProcessMutex.h"
#include "nsDebug.h"
namespace mozilla {
CrossProcessMutex::CrossProcessMutex(const char*)
{
- NS_RUNTIMEABORT("Cross-process mutices not allowed on this platform.");
+ MOZ_CRASH("Cross-process mutices not allowed on this platform.");
}
CrossProcessMutex::CrossProcessMutex(CrossProcessMutexHandle)
{
- NS_RUNTIMEABORT("Cross-process mutices not allowed on this platform.");
+ MOZ_CRASH("Cross-process mutices not allowed on this platform.");
}
CrossProcessMutex::~CrossProcessMutex()
{
- NS_RUNTIMEABORT("Cross-process mutices not allowed on this platform - woah! We should've aborted by now!");
+ MOZ_CRASH("Cross-process mutices not allowed on this platform - woah! We should've aborted by now!");
}
void
CrossProcessMutex::Lock()
{
- NS_RUNTIMEABORT("Cross-process mutices not allowed on this platform - woah! We should've aborted by now!");
+ MOZ_CRASH("Cross-process mutices not allowed on this platform - woah! We should've aborted by now!");
}
void
CrossProcessMutex::Unlock()
{
- NS_RUNTIMEABORT("Cross-process mutices not allowed on this platform - woah! We should've aborted by now!");
+ MOZ_CRASH("Cross-process mutices not allowed on this platform - woah! We should've aborted by now!");
}
CrossProcessMutexHandle
CrossProcessMutex::ShareToProcess(base::ProcessId aTargetPid)
{
- NS_RUNTIMEABORT("Cross-process mutices not allowed on this platform - woah! We should've aborted by now!");
+ MOZ_CRASH("Cross-process mutices not allowed on this platform - woah! We should've aborted by now!");
return 0;
}
}
--- a/ipc/glue/CrossProcessMutex_windows.cpp
+++ b/ipc/glue/CrossProcessMutex_windows.cpp
@@ -19,26 +19,26 @@ namespace mozilla {
CrossProcessMutex::CrossProcessMutex(const char*)
{
// We explicitly share this using DuplicateHandle, we do -not- want this to
// be inherited by child processes by default! So no security attributes are
// given.
mMutex = ::CreateMutexA(nullptr, FALSE, nullptr);
if (!mMutex) {
- NS_RUNTIMEABORT("This shouldn't happen - failed to create mutex!");
+ MOZ_CRASH("This shouldn't happen - failed to create mutex!");
}
MOZ_COUNT_CTOR(CrossProcessMutex);
}
CrossProcessMutex::CrossProcessMutex(CrossProcessMutexHandle aHandle)
{
DWORD flags;
if (!::GetHandleInformation(aHandle, &flags)) {
- NS_RUNTIMEABORT("Attempt to construct a mutex from an invalid handle!");
+ MOZ_CRASH("Attempt to construct a mutex from an invalid handle!");
}
mMutex = aHandle;
MOZ_COUNT_CTOR(CrossProcessMutex);
}
CrossProcessMutex::~CrossProcessMutex()
{
NS_ASSERTION(mMutex, "Improper construction of mutex or double free.");
--- a/ipc/glue/GeckoChildProcessHost.cpp
+++ b/ipc/glue/GeckoChildProcessHost.cpp
@@ -1190,17 +1190,17 @@ GeckoChildProcessHost::PerformAsyncLaunc
&& !::DuplicateHandle(::GetCurrentProcess(), process,
::GetCurrentProcess(), &mChildProcessHandle,
PROCESS_DUP_HANDLE | PROCESS_TERMINATE |
PROCESS_QUERY_INFORMATION | PROCESS_VM_READ |
SYNCHRONIZE,
FALSE, 0)
#endif
) {
- NS_RUNTIMEABORT("cannot open handle to child process");
+ MOZ_CRASH("cannot open handle to child process");
}
MonitorAutoLock lock(mMonitor);
mProcessState = PROCESS_CREATED;
lock.Notify();
return true;
}
@@ -1214,17 +1214,17 @@ GeckoChildProcessHost::OpenPrivilegedHan
return base::OpenPrivilegedProcessHandle(aPid, &mChildProcessHandle);
}
void
GeckoChildProcessHost::OnChannelConnected(int32_t peer_pid)
{
if (!OpenPrivilegedHandle(peer_pid)) {
- NS_RUNTIMEABORT("can't open handle to child process");
+ MOZ_CRASH("can't open handle to child process");
}
MonitorAutoLock lock(mMonitor);
mProcessState = PROCESS_CONNECTED;
lock.Notify();
}
void
GeckoChildProcessHost::OnMessageReceived(IPC::Message&& aMsg)
--- a/ipc/glue/IPCMessageUtils.h
+++ b/ipc/glue/IPCMessageUtils.h
@@ -264,20 +264,20 @@ struct ParamTraits<uint8_t>
#if !defined(OS_POSIX)
// See above re: keeping definitions in sync
template<>
struct ParamTraits<base::FileDescriptor>
{
typedef base::FileDescriptor paramType;
static void Write(Message* aMsg, const paramType& aParam) {
- NS_RUNTIMEABORT("FileDescriptor isn't meaningful on this platform");
+ MOZ_CRASH("FileDescriptor isn't meaningful on this platform");
}
static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult) {
- NS_RUNTIMEABORT("FileDescriptor isn't meaningful on this platform");
+ MOZ_CRASH("FileDescriptor isn't meaningful on this platform");
return false;
}
};
#endif // !defined(OS_POSIX)
template <>
struct ParamTraits<nsACString>
{
--- a/ipc/glue/MessageChannel.cpp
+++ b/ipc/glue/MessageChannel.cpp
@@ -1727,17 +1727,17 @@ MessageChannel::DispatchSyncMessage(cons
void
MessageChannel::DispatchAsyncMessage(const Message& aMsg)
{
AssertWorkerThread();
MOZ_RELEASE_ASSERT(!aMsg.is_interrupt() && !aMsg.is_sync());
if (aMsg.routing_id() == MSG_ROUTING_NONE) {
- NS_RUNTIMEABORT("unhandled special message!");
+ MOZ_CRASH("unhandled special message!");
}
Result rv;
{
int nestedLevel = aMsg.nested_level();
AutoSetValue<bool> async(mDispatchingAsyncMessage, true);
AutoSetValue<int> nestedLevelSet(mDispatchingAsyncMessageNestedLevel, nestedLevel);
rv = mListener->OnMessageReceived(aMsg);
@@ -1771,20 +1771,20 @@ MessageChannel::DispatchInterruptMessage
winner = "child";
defer = (mSide == ChildSide);
break;
case RIPParentWins:
winner = "parent";
defer = (mSide != ChildSide);
break;
case RIPError:
- NS_RUNTIMEABORT("NYI: 'Error' Interrupt race policy");
+ MOZ_CRASH("NYI: 'Error' Interrupt race policy");
return;
default:
- NS_RUNTIMEABORT("not reached");
+ MOZ_CRASH("not reached");
return;
}
if (LoggingEnabled()) {
printf_stderr(" (%s: %s won, so we're%sdeferring)\n",
(mSide == ChildSide) ? "child" : "parent",
winner,
defer ? " " : " not ");
@@ -2055,17 +2055,17 @@ MessageChannel::ReportConnectionError(co
case ChannelClosing:
errorMsg = "Channel closing: too late to send/recv, messages will be lost";
break;
case ChannelError:
errorMsg = "Channel error: cannot send/recv";
break;
default:
- NS_RUNTIMEABORT("unreached");
+ MOZ_CRASH("unreached");
}
if (aMsg) {
char reason[512];
SprintfLiteral(reason,"(msgtype=0x%X,name=%s) %s",
aMsg->type(), aMsg->name(), errorMsg);
PrintErrorMessage(mSide, aChannelName, reason);
@@ -2100,17 +2100,17 @@ MessageChannel::MaybeHandleError(Result
case MsgRouteError:
errorMsg = "Route error: message sent to unknown actor ID";
break;
case MsgValueError:
errorMsg = "Value error: message was deserialized, but contained an illegal value";
break;
default:
- NS_RUNTIMEABORT("unknown Result code");
+ MOZ_CRASH("unknown Result code");
return false;
}
char reason[512];
const char* msgname = StringFromIPCMessageType(aMsg.type());
if (msgname[0] == '?') {
SprintfLiteral(reason,"(msgtype=0x%X) %s", aMsg.type(), errorMsg);
} else {
@@ -2140,17 +2140,17 @@ MessageChannel::OnChannelErrorFromLink()
if (InterruptStackDepth() > 0)
NotifyWorkerThread();
if (AwaitingSyncReply() || AwaitingIncomingMessage())
NotifyWorkerThread();
if (ChannelClosing != mChannelState) {
if (mAbortOnError) {
- NS_RUNTIMEABORT("Aborting on channel error.");
+ MOZ_CRASH("Aborting on channel error.");
}
mChannelState = ChannelError;
mMonitor->Notify();
}
PostErrorNotifyTask();
}
@@ -2311,17 +2311,17 @@ MessageChannel::Close()
mChannelState = ChannelError;
NotifyMaybeChannelError();
return;
}
if (ChannelClosed == mChannelState) {
// XXX be strict about this until there's a compelling reason
// to relax
- NS_RUNTIMEABORT("Close() called on closed channel!");
+ MOZ_CRASH("Close() called on closed channel!");
}
// Notify the other side that we're about to close our socket. If we've
// already received a Goodbye from the other side (and our state is
// ChannelClosing), there's no reason to send one.
if (ChannelConnected == mChannelState) {
mLink->SendMessage(new GoodbyeMessage());
}
@@ -2332,17 +2332,17 @@ MessageChannel::Close()
}
void
MessageChannel::NotifyChannelClosed()
{
mMonitor->AssertNotCurrentThreadOwns();
if (ChannelClosed != mChannelState)
- NS_RUNTIMEABORT("channel should have been closed!");
+ MOZ_CRASH("channel should have been closed!");
Clear();
// IPDL assumes these notifications do not fire twice, so we do not let
// that happen.
if (mNotifiedChannelDone) {
return;
}
--- a/ipc/glue/SharedMemory.h
+++ b/ipc/glue/SharedMemory.h
@@ -63,27 +63,27 @@ public:
virtual bool ShareHandle(base::ProcessId aProcessId, IPC::Message* aMessage) = 0;
virtual bool ReadHandle(const IPC::Message* aMessage, PickleIterator* aIter) = 0;
void
Protect(char* aAddr, size_t aSize, int aRights)
{
char* memStart = reinterpret_cast<char*>(memory());
if (!memStart)
- NS_RUNTIMEABORT("SharedMemory region points at NULL!");
+ MOZ_CRASH("SharedMemory region points at NULL!");
char* memEnd = memStart + Size();
char* protStart = aAddr;
if (!protStart)
- NS_RUNTIMEABORT("trying to Protect() a NULL region!");
+ MOZ_CRASH("trying to Protect() a NULL region!");
char* protEnd = protStart + aSize;
if (!(memStart <= protStart
&& protEnd <= memEnd))
- NS_RUNTIMEABORT("attempt to Protect() a region outside this SharedMemory");
+ MOZ_CRASH("attempt to Protect() a region outside this SharedMemory");
// checks alignment etc.
SystemProtect(aAddr, aSize, aRights);
}
// bug 1168843, compositor thread may create shared memory instances that are destroyed by main thread on shutdown, so this must use thread-safe RC to avoid hitting assertion
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SharedMemory)
--- a/ipc/glue/SharedMemory_posix.cpp
+++ b/ipc/glue/SharedMemory_posix.cpp
@@ -19,17 +19,17 @@ SharedMemory::SystemProtect(char* aAddr,
if (aRights & RightsRead)
flags |= PROT_READ;
if (aRights & RightsWrite)
flags |= PROT_WRITE;
if (RightsNone == aRights)
flags = PROT_NONE;
if (0 < mprotect(aAddr, aSize, flags))
- NS_RUNTIMEABORT("can't mprotect()");
+ MOZ_CRASH("can't mprotect()");
}
size_t
SharedMemory::SystemPageSize()
{
return sysconf(_SC_PAGESIZE);
}
--- a/ipc/glue/SharedMemory_windows.cpp
+++ b/ipc/glue/SharedMemory_windows.cpp
@@ -19,17 +19,17 @@ SharedMemory::SystemProtect(char* aAddr,
flags = PAGE_READWRITE;
else if (aRights & RightsRead)
flags = PAGE_READONLY;
else
flags = PAGE_NOACCESS;
DWORD oldflags;
if (!VirtualProtect(aAddr, aSize, flags, &oldflags))
- NS_RUNTIMEABORT("can't VirtualProtect()");
+ MOZ_CRASH("can't VirtualProtect()");
}
size_t
SharedMemory::SystemPageSize()
{
SYSTEM_INFO si;
GetSystemInfo(&si);
return si.dwPageSize;
--- a/ipc/glue/Shmem.h
+++ b/ipc/glue/Shmem.h
@@ -231,17 +231,17 @@ public:
Dealloc(IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead,
SharedMemory* aSegment);
private:
template<typename T>
void AssertAligned() const
{
if (0 != (mSize % sizeof(T)))
- NS_RUNTIMEABORT("shmem is not T-aligned");
+ MOZ_CRASH("shmem is not T-aligned");
}
#if !defined(DEBUG)
void AssertInvariants() const
{ }
static uint32_t*
PtrToSize(SharedMemory* aSegment)
--- a/ipc/glue/WindowsMessageLoop.cpp
+++ b/ipc/glue/WindowsMessageLoop.cpp
@@ -801,17 +801,17 @@ MessageChannel::ProcessNativeEventsInInt
// enabled for a particular Interrupt frame by the client calling
// MessageChannel::ProcessNativeEventsInInterrupt().
// This call can be nested for multiple Interrupt frames in a single plugin or
// multiple unrelated plugins.
void
MessageChannel::SpinInternalEventLoop()
{
if (mozilla::PaintTracker::IsPainting()) {
- NS_RUNTIMEABORT("Don't spin an event loop while painting.");
+ MOZ_CRASH("Don't spin an event loop while painting.");
}
NS_ASSERTION(mTopFrame && mTopFrame->mSpinNestedEvents,
"Spinning incorrectly");
// Nested windows event loop we trigger when the child enters into modal
// event loops.
@@ -1183,17 +1183,17 @@ MessageChannel::WaitForInterruptNotify()
// Re-use sync notification wait code if this channel does not require
// Windows message deferral behavior.
if (!(mFlags & REQUIRE_DEFERRED_MESSAGE_PROTECTION)) {
return WaitForSyncNotify(true);
}
if (!InterruptStackDepth() && !AwaitingIncomingMessage()) {
// There is currently no way to recover from this condition.
- NS_RUNTIMEABORT("StackDepth() is 0 in call to MessageChannel::WaitForNotify!");
+ MOZ_CRASH("StackDepth() is 0 in call to MessageChannel::WaitForNotify!");
}
NS_ASSERTION(mFlags & REQUIRE_DEFERRED_MESSAGE_PROTECTION,
"Shouldn't be here for channels that don't use message deferral!");
NS_ASSERTION(mTopFrame && mTopFrame->mInterrupt,
"Top frame is not a sync frame!");
MonitorAutoUnlock unlock(*mMonitor);
--- a/ipc/ipdl/test/cxx/IPDLUnitTests.h
+++ b/ipc/ipdl/test/cxx/IPDLUnitTests.h
@@ -42,17 +42,17 @@ inline void fail(const char* fmt, ...)
fprintf(stderr, MOZ_IPDL_TESTFAIL_LABEL " | %s | ", IPDLUnitTestName());
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
fputc('\n', stderr);
- NS_RUNTIMEABORT("failed test");
+ MOZ_CRASH("failed test");
}
inline void passed(const char* fmt, ...)
{
va_list ap;
printf(MOZ_IPDL_TESTPASS_LABEL " | %s | ", IPDLUnitTestName());
--- a/ipc/ipdl/test/cxx/IPDLUnitTests.template.cpp
+++ b/ipc/ipdl/test/cxx/IPDLUnitTests.template.cpp
@@ -133,17 +133,17 @@ IPDLUnitTestMain(void* aData)
return;
}
IPDLUnitTestType test = IPDLUnitTestFromString(testString);
if (!test) {
// use this instead of |fail()| because we don't know what the test is
fprintf(stderr, MOZ_IPDL_TESTFAIL_LABEL "| %s | unknown unit test %s\n",
"<--->", testString);
- NS_RUNTIMEABORT("can't continue");
+ MOZ_CRASH("can't continue");
}
gIPDLUnitTestName = testString;
// Check whether this test is enabled for processes:
switch (test) {
//-----------------------------------------------------------------------------
//===== TEMPLATED =====
${PARENT_ENABLED_CASES_PROC}
@@ -184,17 +184,17 @@ IPDLUnitTestMain(void* aData)
void
IPDLUnitTestThreadMain(char *testString)
{
IPDLUnitTestType test = IPDLUnitTestFromString(testString);
if (!test) {
// use this instead of |fail()| because we don't know what the test is
fprintf(stderr, MOZ_IPDL_TESTFAIL_LABEL "| %s | unknown unit test %s\n",
"<--->", testString);
- NS_RUNTIMEABORT("can't continue");
+ MOZ_CRASH("can't continue");
}
gIPDLUnitTestName = testString;
// Check whether this test is enabled for threads:
switch (test) {
//-----------------------------------------------------------------------------
//===== TEMPLATED =====
${PARENT_ENABLED_CASES_THREAD}
--- a/ipc/ipdl/test/cxx/TestLatency.cpp
+++ b/ipc/ipdl/test/cxx/TestLatency.cpp
@@ -38,17 +38,17 @@ TestLatencyParent::Main()
Close();
return;
}
printf(" timing resolution: %g seconds\n",
resolution.ToSecondsSigDigits());
if (mozilla::ipc::LoggingEnabled())
- NS_RUNTIMEABORT("you really don't want to log all IPC messages during this test, trust me");
+ MOZ_CRASH("you really don't want to log all IPC messages during this test, trust me");
PingPongTrial();
}
void
TestLatencyParent::PingPongTrial()
{
mStart = TimeStamp::Now();
--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -9021,17 +9021,17 @@ nsCSSFrameConstructor::CreateContinuingF
newFrame->Init(content, aParentFrame, aFrame);
} else if (nsGkAtoms::rubyTextContainerFrame == frameType) {
newFrame = NS_NewRubyTextContainerFrame(shell, styleContext);
newFrame->Init(content, aParentFrame, aFrame);
} else if (nsGkAtoms::detailsFrame == frameType) {
newFrame = NS_NewDetailsFrame(shell, styleContext);
newFrame->Init(content, aParentFrame, aFrame);
} else {
- NS_RUNTIMEABORT("unexpected frame type");
+ MOZ_CRASH("unexpected frame type");
}
// Init() set newFrame to be a fluid continuation of aFrame.
// If we want a non-fluid continuation, we need to call SetPrevContinuation()
// to reset NS_FRAME_IS_FLUID_CONTINUATION.
if (!aIsFluid) {
newFrame->SetPrevContinuation(aFrame);
}
--- a/layout/build/nsLayoutModule.cpp
+++ b/layout/build/nsLayoutModule.cpp
@@ -346,17 +346,17 @@ static bool gInitialized = false;
// Perform our one-time intialization for this module
// static
nsresult
Initialize()
{
if (gInitialized) {
- NS_RUNTIMEABORT("Recursive layout module initialization");
+ MOZ_CRASH("Recursive layout module initialization");
return NS_ERROR_FAILURE;
}
if (XRE_GetProcessType() == GeckoProcessType_GPU) {
// We mark the layout module as being available in the GPU process so that
// XPCOM's component manager initializes the power manager service, which
// is needed for nsAppShell. However, we don't actually need anything in
// the layout module itself.
return NS_OK;
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -423,17 +423,17 @@ nsFrame::~nsFrame()
NS_IMPL_FRAMEARENA_HELPERS(nsFrame)
// Dummy operator delete. Will never be called, but must be defined
// to satisfy some C++ ABIs.
void
nsFrame::operator delete(void *, size_t)
{
- NS_RUNTIMEABORT("nsFrame::operator delete should never be called");
+ MOZ_CRASH("nsFrame::operator delete should never be called");
}
NS_QUERYFRAME_HEAD(nsFrame)
NS_QUERYFRAME_ENTRY(nsIFrame)
NS_QUERYFRAME_TAIL_INHERITANCE_ROOT
/////////////////////////////////////////////////////////////////////////////
// nsIFrame
@@ -5820,18 +5820,18 @@ nsIFrame::GetOffsetToCrossDoc(const nsIF
"Must have frame for destination coordinate system!");
NS_ASSERTION(PresContext()->GetRootPresContext() ==
aOther->PresContext()->GetRootPresContext(),
"trying to get the offset between frames in different document "
"hierarchies?");
if (PresContext()->GetRootPresContext() !=
aOther->PresContext()->GetRootPresContext()) {
// crash right away, we are almost certainly going to crash anyway.
- NS_RUNTIMEABORT("trying to get the offset between frames in different "
- "document hierarchies?");
+ MOZ_CRASH("trying to get the offset between frames in different "
+ "document hierarchies?");
}
const nsIFrame* root = nullptr;
// offset will hold the final offset
// docOffset holds the currently accumulated offset at the current APD, it
// will be converted and added to offset when the current APD changes.
nsPoint offset(0, 0), docOffset(0, 0);
const nsIFrame* f = this;
--- a/layout/generic/nsImageFrame.cpp
+++ b/layout/generic/nsImageFrame.cpp
@@ -259,17 +259,17 @@ nsImageFrame::Init(nsIContent* aCo
nsIFrame* aPrevInFlow)
{
nsAtomicContainerFrame::Init(aContent, aParent, aPrevInFlow);
mListener = new nsImageListener(this);
nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(aContent);
if (!imageLoader) {
- NS_RUNTIMEABORT("Why do we have an nsImageFrame here at all?");
+ MOZ_CRASH("Why do we have an nsImageFrame here at all?");
}
imageLoader->AddObserver(mListener);
nsPresContext *aPresContext = PresContext();
if (!gIconLoad)
LoadIcons(aPresContext);
--- a/layout/svg/nsSVGImageFrame.cpp
+++ b/layout/svg/nsSVGImageFrame.cpp
@@ -160,17 +160,17 @@ nsSVGImageFrame::Init(nsIContent*
// Non-display frames are likely to be patterns, masks or the like.
// Treat them as always visible.
IncApproximateVisibleCount();
}
mListener = new nsSVGImageListener(this);
nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mContent);
if (!imageLoader) {
- NS_RUNTIMEABORT("Why is this not an image loading content?");
+ MOZ_CRASH("Why is this not an image loading content?");
}
// We should have a PresContext now, so let's notify our image loader that
// we need to register any image animations with the refresh driver.
imageLoader->FrameCreated(this);
imageLoader->AddObserver(mListener);
}
--- a/layout/tables/nsTableFrame.cpp
+++ b/layout/tables/nsTableFrame.cpp
@@ -3822,17 +3822,17 @@ nsTableFrame*
nsTableFrame::GetTableFrame(nsIFrame* aFrame)
{
for (nsIFrame* ancestor = aFrame->GetParent(); ancestor;
ancestor = ancestor->GetParent()) {
if (nsGkAtoms::tableFrame == ancestor->GetType()) {
return static_cast<nsTableFrame*>(ancestor);
}
}
- NS_RUNTIMEABORT("unable to find table parent");
+ MOZ_CRASH("unable to find table parent");
return nullptr;
}
nsTableFrame*
nsTableFrame::GetTableFramePassingThrough(nsIFrame* aMustPassThrough,
nsIFrame* aFrame,
bool* aDidPassThrough)
{
--- a/modules/libpref/nsPrefBranch.cpp
+++ b/modules/libpref/nsPrefBranch.cpp
@@ -50,17 +50,17 @@
using mozilla::dom::ContentChild;
static ContentChild*
GetContentChild()
{
if (XRE_IsContentProcess()) {
ContentChild* cpc = ContentChild::GetSingleton();
if (!cpc) {
- NS_RUNTIMEABORT("Content Protocol is NULL! We're going to crash!");
+ MOZ_CRASH("Content Protocol is NULL! We're going to crash!");
}
return cpc;
}
return nullptr;
}
/*
* Constructor/Destructor
@@ -340,17 +340,17 @@ NS_IMETHODIMP nsPrefBranch::GetComplexVa
do_GetService("@mozilla.org/toolkit/crash-reporter;1");
if (cr) {
cr->AnnotateCrashReport(NS_LITERAL_CSTRING("bug836263-size"),
nsPrintfCString("%x", utf8String.Length()));
cr->RegisterAppMemory(uint64_t(utf8String.BeginReading()),
std::min(0x1000U, utf8String.Length()));
}
#endif
- NS_RUNTIMEABORT("bug836263");
+ MOZ_CRASH("bug836263");
}
theString->SetData(wdata);
theString.forget(reinterpret_cast<nsISupportsString**>(_retval));
}
return rv;
}
NS_WARNING("nsPrefBranch::GetComplexValue - Unsupported interface type");
--- a/netwerk/cache/nsCacheService.cpp
+++ b/netwerk/cache/nsCacheService.cpp
@@ -1141,17 +1141,17 @@ nsCacheService::Init()
nsresult rv;
mStorageService = do_GetService("@mozilla.org/storage/service;1", &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = NS_NewNamedThread("Cache I/O",
getter_AddRefs(mCacheIOThread));
if (NS_FAILED(rv)) {
- NS_RUNTIMEABORT("Can't create cache IO thread");
+ MOZ_CRASH("Can't create cache IO thread");
}
rv = nsDeleteDir::Init();
if (NS_FAILED(rv)) {
NS_WARNING("Can't initialize nsDeleteDir");
}
// initialize hashtable for active cache entries
@@ -1175,17 +1175,17 @@ nsCacheService::Init()
}
void
nsCacheService::Shutdown()
{
// This method must be called on the main thread because mCacheIOThread must
// only be modified on the main thread.
if (!NS_IsMainThread()) {
- NS_RUNTIMEABORT("nsCacheService::Shutdown called off the main thread");
+ MOZ_CRASH("nsCacheService::Shutdown called off the main thread");
}
nsCOMPtr<nsIThread> cacheIOThread;
Telemetry::AutoTimer<Telemetry::NETWORK_DISK_CACHE_SHUTDOWN> totalTimer;
bool shouldSanitize = false;
nsCOMPtr<nsIFile> parentDir;
--- a/netwerk/cache/nsDiskCacheStreams.cpp
+++ b/netwerk/cache/nsDiskCacheStreams.cpp
@@ -568,17 +568,17 @@ nsDiskCacheStreamIO::FlushBufferToFile()
int64_t dataSize = mBinding->mCacheEntry->PredictedDataSize();
if (dataSize != -1)
mozilla::fallocate(mFD, std::min<int64_t>(dataSize, kPreallocateLimit));
}
// write buffer to the file when there is data in it
if (mStreamEnd > 0) {
if (!mBuffer) {
- NS_RUNTIMEABORT("Fix me!");
+ MOZ_CRASH("Fix me!");
}
if (PR_Write(mFD, mBuffer, mStreamEnd) != (int32_t)mStreamEnd) {
NS_WARNING("failed to flush all data");
return NS_ERROR_UNEXPECTED; // NS_ErrorAccordingToNSPR()
}
}
// buffer is no longer valid
--- a/netwerk/ipc/NeckoChild.cpp
+++ b/netwerk/ipc/NeckoChild.cpp
@@ -108,17 +108,17 @@ NeckoChild::DeallocPAltDataOutputStreamC
}
PFTPChannelChild*
NeckoChild::AllocPFTPChannelChild(const PBrowserOrId& aBrowser,
const SerializedLoadContext& aSerialized,
const FTPChannelCreationArgs& aOpenArgs)
{
// We don't allocate here: see FTPChannelChild::AsyncOpen()
- NS_RUNTIMEABORT("AllocPFTPChannelChild should not be called");
+ MOZ_CRASH("AllocPFTPChannelChild should not be called");
return nullptr;
}
bool
NeckoChild::DeallocPFTPChannelChild(PFTPChannelChild* channel)
{
MOZ_ASSERT(IsNeckoChild(), "DeallocPFTPChannelChild called by non-child!");
--- a/netwerk/ipc/NeckoMessageUtils.h
+++ b/netwerk/ipc/NeckoMessageUtils.h
@@ -92,28 +92,28 @@ struct ParamTraits<mozilla::net::NetAddr
WriteParam(aMsg, aParam.inet6.port);
WriteParam(aMsg, aParam.inet6.flowinfo);
WriteParam(aMsg, aParam.inet6.ip.u64[0]);
WriteParam(aMsg, aParam.inet6.ip.u64[1]);
WriteParam(aMsg, aParam.inet6.scope_id);
#if defined(XP_UNIX)
} else if (aParam.raw.family == AF_LOCAL) {
// Train's already off the rails: let's get a stack trace at least...
- NS_RUNTIMEABORT("Error: please post stack trace to "
+ MOZ_CRASH("Error: please post stack trace to "
"https://bugzilla.mozilla.org/show_bug.cgi?id=661158");
aMsg->WriteBytes(aParam.local.path, sizeof(aParam.local.path));
#endif
} else {
#ifdef MOZ_CRASHREPORTER
if (XRE_IsParentProcess()) {
nsPrintfCString msg("%d", aParam.raw.family);
CrashReporter::AnnotateCrashReport(NS_LITERAL_CSTRING("Unknown NetAddr socket family"), msg);
}
#endif
- NS_RUNTIMEABORT("Unknown socket family");
+ MOZ_CRASH("Unknown socket family");
}
}
static bool Read(const Message* aMsg, PickleIterator* aIter, mozilla::net::NetAddr* aResult)
{
if (!ReadParam(aMsg, aIter, &aResult->raw.family))
return false;
--- a/netwerk/protocol/ftp/FTPChannelChild.cpp
+++ b/netwerk/protocol/ftp/FTPChannelChild.cpp
@@ -220,17 +220,17 @@ FTPChannelChild::IsPending(bool* result)
return NS_OK;
}
nsresult
FTPChannelChild::OpenContentStream(bool async,
nsIInputStream** stream,
nsIChannel** channel)
{
- NS_RUNTIMEABORT("FTPChannel*Child* should never have OpenContentStream called!");
+ MOZ_CRASH("FTPChannel*Child* should never have OpenContentStream called!");
return NS_OK;
}
//-----------------------------------------------------------------------------
// FTPChannelChild::PFTPChannelChild
//-----------------------------------------------------------------------------
class FTPStartRequestEvent : public ChannelEvent
--- a/storage/test/test_async_callbacks_with_spun_event_loops.cpp
+++ b/storage/test/test_async_callbacks_with_spun_event_loops.cpp
@@ -58,27 +58,27 @@ private:
}
public:
NS_IMETHOD HandleResult(mozIStorageResultSet* aResultSet) override
{
sResult = true;
spin_events_loop_until_true(&mCompleted);
if (!sAlive) {
- NS_RUNTIMEABORT("The statement callback was destroyed prematurely.");
+ MOZ_CRASH("The statement callback was destroyed prematurely.");
}
return NS_OK;
}
NS_IMETHOD HandleError(mozIStorageError* aError) override
{
sError = true;
spin_events_loop_until_true(&mCompleted);
if (!sAlive) {
- NS_RUNTIMEABORT("The statement callback was destroyed prematurely.");
+ MOZ_CRASH("The statement callback was destroyed prematurely.");
}
return NS_OK;
}
NS_IMETHOD HandleCompletion(uint16_t aReason) override
{
mCompleted = true;
return NS_OK;
--- a/storage/test/test_deadlock_detector.cpp
+++ b/storage/test/test_deadlock_detector.cpp
@@ -447,17 +447,17 @@ TwoThreads_thread(void* arg)
}
int
TwoThreads_Child()
{
ttM1 = new TestMutex("dd.twothreads.m1");
ttM2 = new TestMutex("dd.twothreads.m2");
if (!ttM1 || !ttM2)
- NS_RUNTIMEABORT("couldn't allocate mutexes");
+ MOZ_CRASH("couldn't allocate mutexes");
PRThread* t1 = spawn(TwoThreads_thread, (void*) 0);
PR_JoinThread(t1);
PRThread* t2 = spawn(TwoThreads_thread, (void*) 1);
PR_JoinThread(t2);
return 0;
--- a/toolkit/crashreporter/nsExceptionHandler.cpp
+++ b/toolkit/crashreporter/nsExceptionHandler.cpp
@@ -3444,17 +3444,17 @@ OOPInit()
nullptr, nullptr, // we don't care about process exit here
nullptr, nullptr, // we don't care about upload request here
true, // automatically generate dumps
&dumpPath);
#elif defined(XP_LINUX)
if (!CrashGenerationServer::CreateReportChannel(&serverSocketFd,
&clientSocketFd))
- NS_RUNTIMEABORT("can't create crash reporter socketpair()");
+ MOZ_CRASH("can't create crash reporter socketpair()");
const std::string dumpPath =
gExceptionHandler->minidump_descriptor().directory();
crashServer = new CrashGenerationServer(
serverSocketFd,
OnChildProcessDumpRequested, nullptr,
nullptr, nullptr, // we don't care about process exit here
true,
@@ -3472,17 +3472,17 @@ OOPInit()
nullptr,
OnChildProcessDumpRequested, nullptr,
nullptr, nullptr,
true, // automatically generate dumps
dumpPath);
#endif
if (!crashServer->Start())
- NS_RUNTIMEABORT("can't start crash reporter server()");
+ MOZ_CRASH("can't start crash reporter server()");
pidToMinidump = new ChildMinidumpMap();
dumpMapLock = new Mutex("CrashReporter::dumpMapLock");
FindPendingDir();
UpdateCrashEventsDir();
}
--- a/toolkit/crashreporter/test/nsTestCrasher.cpp
+++ b/toolkit/crashreporter/test/nsTestCrasher.cpp
@@ -40,17 +40,17 @@ void PureVirtualCall()
b.use(); // make sure b's actually used
}
// Keep these in sync with CrashTestUtils.jsm!
const int16_t CRASH_INVALID_POINTER_DEREF = 0;
const int16_t CRASH_PURE_VIRTUAL_CALL = 1;
const int16_t CRASH_RUNTIMEABORT = 2;
const int16_t CRASH_OOM = 3;
-const int16_t CRASH_MOZ_CRASH = 4;
+const int16_t CRASH_NS_RUNTIMEABORT = 4;
const int16_t CRASH_ABORT = 5;
extern "C" NS_EXPORT
void Crash(int16_t how)
{
switch (how) {
case CRASH_INVALID_POINTER_DEREF: {
volatile int* foo = (int*)0x42;
@@ -68,18 +68,18 @@ void Crash(int16_t how)
break;
}
case CRASH_OOM: {
mozilla::Unused << moz_xmalloc((size_t) -1);
mozilla::Unused << moz_xmalloc((size_t) -1);
mozilla::Unused << moz_xmalloc((size_t) -1);
break;
}
- case CRASH_MOZ_CRASH: {
- MOZ_CRASH();
+ case CRASH_NS_RUNTIMEABORT: {
+ NS_RUNTIMEABORT("CRASH_NS_RUNTIMEABORT");
break;
}
case CRASH_ABORT: {
abort();
break;
}
default:
break;
--- a/toolkit/xre/nsEmbedFunctions.cpp
+++ b/toolkit/xre/nsEmbedFunctions.cpp
@@ -603,17 +603,17 @@ XRE_InitChildProcess(int aArgc,
nsAutoPtr<ProcessChild> process;
#ifdef XP_WIN
mozilla::ipc::windows::InitUIThread();
#endif
switch (XRE_GetProcessType()) {
case GeckoProcessType_Default:
- NS_RUNTIMEABORT("This makes no sense");
+ MOZ_CRASH("This makes no sense");
break;
case GeckoProcessType_Plugin:
process = new PluginProcessChild(parentPID);
break;
case GeckoProcessType_Content: {
process = new ContentProcess(parentPID);
@@ -659,30 +659,30 @@ XRE_InitChildProcess(int aArgc,
}
}
break;
case GeckoProcessType_IPDLUnitTest:
#ifdef MOZ_IPDL_TESTS
process = new IPDLUnitTestProcessChild(parentPID);
#else
- NS_RUNTIMEABORT("rebuild with --enable-ipdl-tests");
+ MOZ_CRASH("rebuild with --enable-ipdl-tests");
#endif
break;
case GeckoProcessType_GMPlugin:
process = new gmp::GMPProcessChild(parentPID);
break;
case GeckoProcessType_GPU:
process = new gfx::GPUProcessImpl(parentPID);
break;
default:
- NS_RUNTIMEABORT("Unknown main thread class");
+ MOZ_CRASH("Unknown main thread class");
}
if (!process->Init()) {
return NS_ERROR_FAILURE;
}
#ifdef MOZ_CRASHREPORTER
#if defined(XP_WIN) || defined(XP_MACOSX)
--- a/widget/gonk/nsScreenManagerGonk.cpp
+++ b/widget/gonk/nsScreenManagerGonk.cpp
@@ -134,17 +134,17 @@ nsScreenGonk::nsScreenGonk(uint32_t aId,
, mEGLSurface(EGL_NO_SURFACE)
, mGLContext(nullptr)
, mFramebuffer(nullptr)
, mMappedBuffer(nullptr)
{
if (mNativeWindow->query(mNativeWindow.get(), NATIVE_WINDOW_WIDTH, &mVirtualBounds.width) ||
mNativeWindow->query(mNativeWindow.get(), NATIVE_WINDOW_HEIGHT, &mVirtualBounds.height) ||
mNativeWindow->query(mNativeWindow.get(), NATIVE_WINDOW_FORMAT, &mSurfaceFormat)) {
- NS_RUNTIMEABORT("Failed to get native window size, aborting...");
+ MOZ_CRASH("Failed to get native window size, aborting...");
}
mNaturalBounds = mVirtualBounds;
if (IsPrimaryScreen()) {
char propValue[PROPERTY_VALUE_MAX];
property_get("ro.sf.hwrotation", propValue, "0");
mPhysicalScreenRotation = atoi(propValue) / 90;
--- a/widget/gonk/nsWindow.cpp
+++ b/widget/gonk/nsWindow.cpp
@@ -118,17 +118,17 @@ nsWindow::DoDraw(void)
}
listener = targetWindow->GetWidgetListener();
if (listener) {
LayerManager* lm = targetWindow->GetLayerManager();
if (mozilla::layers::LayersBackend::LAYERS_CLIENT == lm->GetBackendType()) {
// No need to do anything, the compositor will handle drawing
} else {
- NS_RUNTIMEABORT("Unexpected layer manager type");
+ MOZ_CRASH("Unexpected layer manager type");
}
listener->DidPaintWindow();
}
}
void
nsWindow::ConfigureAPZControllerThread()
--- a/xpcom/base/nsAutoPtr.h
+++ b/xpcom/base/nsAutoPtr.h
@@ -33,17 +33,17 @@ private:
}
void
assign(T* aNewPtr)
{
T* oldPtr = mRawPtr;
if (aNewPtr && aNewPtr == oldPtr) {
- NS_RUNTIMEABORT("Logic flaw in the caller");
+ MOZ_CRASH("Logic flaw in the caller");
}
mRawPtr = aNewPtr;
delete oldPtr;
}
// |class Ptr| helps us prevent implicit "copy construction"
// through |operator T*() const| from a |const nsAutoPtr<T>|
--- a/xpcom/build/LateWriteChecks.cpp
+++ b/xpcom/build/LateWriteChecks.cpp
@@ -146,23 +146,23 @@ LateWriteObserver::Observe(IOInterposeOb
do {
// mkstemp isn't supported so keep trying until we get a file
int result = _mktemp_s(name, strlen(name) + 1);
hFile = CreateFileA(name, GENERIC_WRITE, 0, nullptr, CREATE_NEW,
FILE_ATTRIBUTE_NORMAL, nullptr);
} while (GetLastError() == ERROR_FILE_EXISTS);
if (hFile == INVALID_HANDLE_VALUE) {
- NS_RUNTIMEABORT("Um, how did we get here?");
+ MOZ_CRASH("Um, how did we get here?");
}
// http://support.microsoft.com/kb/139640
int fd = _open_osfhandle((intptr_t)hFile, _O_APPEND);
if (fd == -1) {
- NS_RUNTIMEABORT("Um, how did we get here?");
+ MOZ_CRASH("Um, how did we get here?");
}
stream = _fdopen(fd, "w");
#else
int fd = mkstemp(name);
stream = fdopen(fd, "w");
#endif
--- a/xpcom/build/XPCOMInit.cpp
+++ b/xpcom/build/XPCOMInit.cpp
@@ -858,30 +858,30 @@ namespace mozilla {
void
SetICUMemoryFunctions()
{
static bool sICUReporterInitialized = false;
if (!sICUReporterInitialized) {
if (!JS_SetICUMemoryFunctions(ICUReporter::Alloc, ICUReporter::Realloc,
ICUReporter::Free)) {
- NS_RUNTIMEABORT("JS_SetICUMemoryFunctions failed.");
+ MOZ_CRASH("JS_SetICUMemoryFunctions failed.");
}
sICUReporterInitialized = true;
}
}
nsresult
ShutdownXPCOM(nsIServiceManager* aServMgr)
{
// Make sure the hang monitor is enabled for shutdown.
HangMonitor::NotifyActivity();
if (!NS_IsMainThread()) {
- NS_RUNTIMEABORT("Shutdown on wrong thread");
+ MOZ_CRASH("Shutdown on wrong thread");
}
nsresult rv;
nsCOMPtr<nsISimpleEnumerator> moduleLoaders;
// Notify observers of xpcom shutting down
{
// Block it so that the COMPtr will get deleted before we hit
--- a/xpcom/glue/BlockingResourceBase.cpp
+++ b/xpcom/glue/BlockingResourceBase.cpp
@@ -211,17 +211,17 @@ BlockingResourceBase::BlockingResourceBa
#else
, mAcquired()
#endif
{
MOZ_ASSERT(mName, "Name must be nonnull");
// PR_CallOnce guaranatees that InitStatics is called in a
// thread-safe way
if (PR_SUCCESS != PR_CallOnce(&sCallOnce, InitStatics)) {
- NS_RUNTIMEABORT("can't initialize blocking resource static members");
+ MOZ_CRASH("can't initialize blocking resource static members");
}
mChainPrev = 0;
sDeadlockDetector->Add(this);
}
BlockingResourceBase::~BlockingResourceBase()
@@ -246,17 +246,17 @@ BlockingResourceBase::SizeOfDeadlockDete
PRStatus
BlockingResourceBase::InitStatics()
{
PR_NewThreadPrivateIndex(&sResourceAcqnChainFrontTPI, 0);
sDeadlockDetector = new DDT();
if (!sDeadlockDetector) {
- NS_RUNTIMEABORT("can't allocate deadlock detector");
+ MOZ_CRASH("can't allocate deadlock detector");
}
return PR_SUCCESS;
}
void
BlockingResourceBase::Shutdown()
{
--- a/xpcom/glue/CondVar.h
+++ b/xpcom/glue/CondVar.h
@@ -41,17 +41,17 @@ public:
CondVar(Mutex& aLock, const char* aName)
: BlockingResourceBase(aName, eCondVar)
, mLock(&aLock)
{
MOZ_COUNT_CTOR(CondVar);
// |aLock| must necessarily already be known to the deadlock detector
mCvar = PR_NewCondVar(mLock->mLock);
if (!mCvar) {
- NS_RUNTIMEABORT("Can't allocate mozilla::CondVar");
+ MOZ_CRASH("Can't allocate mozilla::CondVar");
}
}
/**
* ~CondVar
* Clean up after this CondVar, but NOT its associated Mutex.
**/
~CondVar()
--- a/xpcom/glue/DeadlockDetector.h
+++ b/xpcom/glue/DeadlockDetector.h
@@ -125,17 +125,17 @@ public:
* @param aNumResourcesGuess Guess at approximate number of resources
* that will be checked.
*/
explicit DeadlockDetector(uint32_t aNumResourcesGuess = kDefaultNumBuckets)
: mOrdering(aNumResourcesGuess)
{
mLock = PR_NewLock();
if (!mLock) {
- NS_RUNTIMEABORT("couldn't allocate deadlock detector lock");
+ MOZ_CRASH("couldn't allocate deadlock detector lock");
}
}
/**
* ~DeadlockDetector
*
* *NOT* thread safe.
*/
@@ -239,17 +239,17 @@ public:
// this is the crux of the deadlock detector algorithm
if (current == proposed) {
// reflexive deadlock. fastpath b/c InTransitiveClosure is
// not applicable here.
ResourceAcquisitionArray* cycle = new ResourceAcquisitionArray();
if (!cycle) {
- NS_RUNTIMEABORT("can't allocate dep. cycle array");
+ MOZ_CRASH("can't allocate dep. cycle array");
}
cycle->AppendElement(current->mResource);
cycle->AppendElement(aProposed);
return cycle;
}
if (InTransitiveClosure(current, proposed)) {
// we've already established |aLast < aProposed|. all is well.
return 0;
@@ -315,17 +315,17 @@ public:
*
* @precondition |aStart != aTarget|
*/
ResourceAcquisitionArray* GetDeductionChain(const OrderingEntry* aStart,
const OrderingEntry* aTarget)
{
ResourceAcquisitionArray* chain = new ResourceAcquisitionArray();
if (!chain) {
- NS_RUNTIMEABORT("can't allocate dep. cycle array");
+ MOZ_CRASH("can't allocate dep. cycle array");
}
chain->AppendElement(aStart->mResource);
NS_ASSERTION(GetDeductionChain_Helper(aStart, aTarget, chain),
"GetDeductionChain called when there's no deadlock");
return chain;
}
--- a/xpcom/glue/Mutex.h
+++ b/xpcom/glue/Mutex.h
@@ -43,17 +43,17 @@ public:
* If success, a valid Mutex* which must be destroyed
* by Mutex::DestroyMutex()
**/
explicit OffTheBooksMutex(const char* aName)
: BlockingResourceBase(aName, eMutex)
{
mLock = PR_NewLock();
if (!mLock) {
- NS_RUNTIMEABORT("Can't allocate mozilla::Mutex");
+ MOZ_CRASH("Can't allocate mozilla::Mutex");
}
}
~OffTheBooksMutex()
{
NS_ASSERTION(mLock,
"improperly constructed Lock or double free");
// NSPR does consistency checks for us
--- a/xpcom/glue/ReentrantMonitor.h
+++ b/xpcom/glue/ReentrantMonitor.h
@@ -45,17 +45,17 @@ public:
: BlockingResourceBase(aName, eReentrantMonitor)
#ifdef DEBUG
, mEntryCount(0)
#endif
{
MOZ_COUNT_CTOR(ReentrantMonitor);
mReentrantMonitor = PR_NewMonitor();
if (!mReentrantMonitor) {
- NS_RUNTIMEABORT("Can't allocate mozilla::ReentrantMonitor");
+ MOZ_CRASH("Can't allocate mozilla::ReentrantMonitor");
}
}
/**
* ~ReentrantMonitor
**/
~ReentrantMonitor()
{
--- a/xpcom/glue/nsTArray.h
+++ b/xpcom/glue/nsTArray.h
@@ -169,24 +169,24 @@ struct nsTArrayInfallibleAllocatorBase
typedef nsTArrayInfallibleResult ResultTypeProxy;
static ResultType Result(ResultTypeProxy aResult) {}
static bool Successful(ResultTypeProxy) { return true; }
static ResultTypeProxy SuccessResult() { return ResultTypeProxy(); }
static ResultTypeProxy FailureResult()
{
- NS_RUNTIMEABORT("Infallible nsTArray should never fail");
+ MOZ_CRASH("Infallible nsTArray should never fail");
return ResultTypeProxy();
}
static ResultType ConvertBoolToResultType(bool aValue)
{
if (!aValue) {
- NS_RUNTIMEABORT("infallible nsTArray should never convert false to ResultType");
+ MOZ_CRASH("infallible nsTArray should never convert false to ResultType");
}
}
};
struct nsTArrayFallibleAllocator : nsTArrayFallibleAllocatorBase
{
static void* Malloc(size_t aSize) { return malloc(aSize); }
static void* Realloc(void* aPtr, size_t aSize)
--- a/xpcom/io/Base64.cpp
+++ b/xpcom/io/Base64.cpp
@@ -195,20 +195,20 @@ EncodeInputStream(nsIInputStream* aInput
uint32_t read = 0;
rv = aInputStream->ReadSegments(&EncodeInputStream_Encoder<T>,
(void*)&state,
aCount,
&read);
if (NS_FAILED(rv)) {
if (rv == NS_BASE_STREAM_WOULD_BLOCK) {
- NS_RUNTIMEABORT("Not implemented for async streams!");
+ MOZ_CRASH("Not implemented for async streams!");
}
if (rv == NS_ERROR_NOT_IMPLEMENTED) {
- NS_RUNTIMEABORT("Requires a stream that implements ReadSegments!");
+ MOZ_CRASH("Requires a stream that implements ReadSegments!");
}
return rv;
}
if (!read) {
break;
}
}
--- a/xpcom/string/nsTSubstring.cpp
+++ b/xpcom/string/nsTSubstring.cpp
@@ -913,27 +913,27 @@ nsTSubstring_CharT::AppendFunc(void* aAr
void
nsTSubstring_CharT::AppendPrintf(const char* aFormat, ...)
{
va_list ap;
va_start(ap, aFormat);
uint32_t r = PR_vsxprintf(AppendFunc, this, aFormat, ap);
if (r == (uint32_t)-1) {
- NS_RUNTIMEABORT("Allocation or other failure in PR_vsxprintf");
+ MOZ_CRASH("Allocation or other failure in PR_vsxprintf");
}
va_end(ap);
}
void
nsTSubstring_CharT::AppendPrintf(const char* aFormat, va_list aAp)
{
uint32_t r = PR_vsxprintf(AppendFunc, this, aFormat, aAp);
if (r == (uint32_t)-1) {
- NS_RUNTIMEABORT("Allocation or other failure in PR_vsxprintf");
+ MOZ_CRASH("Allocation or other failure in PR_vsxprintf");
}
}
/* hack to make sure we define FormatWithoutTrailingZeros only once */
#ifdef CharT_is_PRUnichar
// Returns the length of the formatted aDouble in aBuf.
static int
FormatWithoutTrailingZeros(char (&aBuf)[40], double aDouble,
--- a/xpcom/threads/HangMonitor.cpp
+++ b/xpcom/threads/HangMonitor.cpp
@@ -115,17 +115,17 @@ Crash()
// If you change this, you must also deal with the threadsafety of AnnotateCrashReport in
// non-chrome processes!
if (GeckoProcessType_Default == XRE_GetProcessType()) {
CrashReporter::AnnotateCrashReport(NS_LITERAL_CSTRING("Hang"),
NS_LITERAL_CSTRING("1"));
}
#endif
- NS_RUNTIMEABORT("HangMonitor triggered");
+ MOZ_CRASH("HangMonitor triggered");
}
#ifdef REPORT_CHROME_HANGS
static void
ChromeStackWalker(uint32_t aFrameNumber, void* aPC, void* aSP, void* aClosure)
{
MOZ_ASSERT(aClosure);