The Tor Browser / file comparison
comparison: xpcom/base/nsDebugImpl.cpp
xpcom/base/nsDebugImpl.cpp
- branch
- TOR_BUG_9701
- changeset 15
- b8a032363ba2
equal
deleted
inserted
replaced
| -1:000000000000 | 0:87e22e9efdfe |
|---|---|
| 1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ | |
| 2 /* This Source Code Form is subject to the terms of the Mozilla Public | |
| 3 * License, v. 2.0. If a copy of the MPL was not distributed with this | |
| 4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | |
| 5 | |
| 6 // Chromium headers must come before Mozilla headers. | |
| 7 #include "base/process_util.h" | |
| 8 | |
| 9 #include "mozilla/Atomics.h" | |
| 10 | |
| 11 #include "nsDebugImpl.h" | |
| 12 #include "nsDebug.h" | |
| 13 #ifdef MOZ_CRASHREPORTER | |
| 14 # include "nsExceptionHandler.h" | |
| 15 #endif | |
| 16 #include "nsString.h" | |
| 17 #include "prprf.h" | |
| 18 #include "prlog.h" | |
| 19 #include "nsError.h" | |
| 20 #include "prerror.h" | |
| 21 #include "prerr.h" | |
| 22 #include "prenv.h" | |
| 23 | |
| 24 #ifdef ANDROID | |
| 25 #include <android/log.h> | |
| 26 #endif | |
| 27 | |
| 28 #ifdef _WIN32 | |
| 29 /* for getenv() */ | |
| 30 #include <stdlib.h> | |
| 31 #endif | |
| 32 | |
| 33 #include "nsTraceRefcnt.h" | |
| 34 | |
| 35 #if defined(XP_UNIX) | |
| 36 #include <signal.h> | |
| 37 #endif | |
| 38 | |
| 39 #if defined(XP_WIN) | |
| 40 #include <tchar.h> | |
| 41 #include "nsString.h" | |
| 42 #ifdef MOZ_METRO | |
| 43 #include "nsWindowsHelpers.h" | |
| 44 #endif | |
| 45 #endif | |
| 46 | |
| 47 #if defined(XP_MACOSX) | |
| 48 #include <stdbool.h> | |
| 49 #include <unistd.h> | |
| 50 #include <sys/sysctl.h> | |
| 51 #endif | |
| 52 | |
| 53 #include "mozilla/mozalloc_abort.h" | |
| 54 | |
| 55 static void | |
| 56 Abort(const char *aMsg); | |
| 57 | |
| 58 static void | |
| 59 RealBreak(); | |
| 60 | |
| 61 static void | |
| 62 Break(const char *aMsg); | |
| 63 | |
| 64 #if defined(_WIN32) | |
| 65 #include <windows.h> | |
| 66 #include <signal.h> | |
| 67 #include <malloc.h> // for _alloca | |
| 68 #elif defined(XP_UNIX) | |
| 69 #include <stdlib.h> | |
| 70 #endif | |
| 71 | |
| 72 using namespace mozilla; | |
| 73 | |
| 74 static const char *sMultiprocessDescription = nullptr; | |
| 75 | |
| 76 static Atomic<int32_t> gAssertionCount; | |
| 77 | |
| 78 NS_IMPL_QUERY_INTERFACE(nsDebugImpl, nsIDebug, nsIDebug2) | |
| 79 | |
| 80 NS_IMETHODIMP_(MozExternalRefCountType) | |
| 81 nsDebugImpl::AddRef() | |
| 82 { | |
| 83 return 2; | |
| 84 } | |
| 85 | |
| 86 NS_IMETHODIMP_(MozExternalRefCountType) | |
| 87 nsDebugImpl::Release() | |
| 88 { | |
| 89 return 1; | |
| 90 } | |
| 91 | |
| 92 NS_IMETHODIMP | |
| 93 nsDebugImpl::Assertion(const char *aStr, const char *aExpr, | |
| 94 const char *aFile, int32_t aLine) | |
| 95 { | |
| 96 NS_DebugBreak(NS_DEBUG_ASSERTION, aStr, aExpr, aFile, aLine); | |
| 97 return NS_OK; | |
| 98 } | |
| 99 | |
| 100 NS_IMETHODIMP | |
| 101 nsDebugImpl::Warning(const char *aStr, const char *aFile, int32_t aLine) | |
| 102 { | |
| 103 NS_DebugBreak(NS_DEBUG_WARNING, aStr, nullptr, aFile, aLine); | |
| 104 return NS_OK; | |
| 105 } | |
| 106 | |
| 107 NS_IMETHODIMP | |
| 108 nsDebugImpl::Break(const char *aFile, int32_t aLine) | |
| 109 { | |
| 110 NS_DebugBreak(NS_DEBUG_BREAK, nullptr, nullptr, aFile, aLine); | |
| 111 return NS_OK; | |
| 112 } | |
| 113 | |
| 114 NS_IMETHODIMP | |
| 115 nsDebugImpl::Abort(const char *aFile, int32_t aLine) | |
| 116 { | |
| 117 NS_DebugBreak(NS_DEBUG_ABORT, nullptr, nullptr, aFile, aLine); | |
| 118 return NS_OK; | |
| 119 } | |
| 120 | |
| 121 NS_IMETHODIMP | |
| 122 nsDebugImpl::GetIsDebugBuild(bool* aResult) | |
| 123 { | |
| 124 #ifdef DEBUG | |
| 125 *aResult = true; | |
| 126 #else | |
| 127 *aResult = false; | |
| 128 #endif | |
| 129 return NS_OK; | |
| 130 } | |
| 131 | |
| 132 NS_IMETHODIMP | |
| 133 nsDebugImpl::GetAssertionCount(int32_t* aResult) | |
| 134 { | |
| 135 *aResult = gAssertionCount; | |
| 136 return NS_OK; | |
| 137 } | |
| 138 | |
| 139 NS_IMETHODIMP | |
| 140 nsDebugImpl::GetIsDebuggerAttached(bool* aResult) | |
| 141 { | |
| 142 *aResult = false; | |
| 143 | |
| 144 #if defined(XP_WIN) | |
| 145 *aResult = ::IsDebuggerPresent(); | |
| 146 #elif defined(XP_MACOSX) | |
| 147 // Specify the info we're looking for | |
| 148 int mib[4]; | |
| 149 mib[0] = CTL_KERN; | |
| 150 mib[1] = KERN_PROC; | |
| 151 mib[2] = KERN_PROC_PID; | |
| 152 mib[3] = getpid(); | |
| 153 size_t mibSize = sizeof(mib) / sizeof(int); | |
| 154 | |
| 155 struct kinfo_proc info; | |
| 156 size_t infoSize = sizeof(info); | |
| 157 memset(&info, 0, infoSize); | |
| 158 | |
| 159 if (sysctl(mib, mibSize, &info, &infoSize, nullptr, 0)) { | |
| 160 // if the call fails, default to false | |
| 161 *aResult = false; | |
| 162 return NS_OK; | |
| 163 } | |
| 164 | |
| 165 if (info.kp_proc.p_flag & P_TRACED) { | |
| 166 *aResult = true; | |
| 167 } | |
| 168 #endif | |
| 169 | |
| 170 return NS_OK; | |
| 171 } | |
| 172 | |
| 173 /* static */ void | |
| 174 nsDebugImpl::SetMultiprocessMode(const char *aDesc) | |
| 175 { | |
| 176 sMultiprocessDescription = aDesc; | |
| 177 } | |
| 178 | |
| 179 /** | |
| 180 * Implementation of the nsDebug methods. Note that this code is | |
| 181 * always compiled in, in case some other module that uses it is | |
| 182 * compiled with debugging even if this library is not. | |
| 183 */ | |
| 184 static PRLogModuleInfo* gDebugLog; | |
| 185 | |
| 186 static void InitLog(void) | |
| 187 { | |
| 188 if (0 == gDebugLog) { | |
| 189 gDebugLog = PR_NewLogModule("nsDebug"); | |
| 190 } | |
| 191 } | |
| 192 | |
| 193 enum nsAssertBehavior { | |
| 194 NS_ASSERT_UNINITIALIZED, | |
| 195 NS_ASSERT_WARN, | |
| 196 NS_ASSERT_SUSPEND, | |
| 197 NS_ASSERT_STACK, | |
| 198 NS_ASSERT_TRAP, | |
| 199 NS_ASSERT_ABORT, | |
| 200 NS_ASSERT_STACK_AND_ABORT | |
| 201 }; | |
| 202 | |
| 203 static nsAssertBehavior GetAssertBehavior() | |
| 204 { | |
| 205 static nsAssertBehavior gAssertBehavior = NS_ASSERT_UNINITIALIZED; | |
| 206 if (gAssertBehavior != NS_ASSERT_UNINITIALIZED) | |
| 207 return gAssertBehavior; | |
| 208 | |
| 209 #if defined(XP_WIN) && defined(MOZ_METRO) | |
| 210 if (IsRunningInWindowsMetro()) | |
| 211 gAssertBehavior = NS_ASSERT_WARN; | |
| 212 else | |
| 213 gAssertBehavior = NS_ASSERT_TRAP; | |
| 214 #elif defined(XP_WIN) | |
| 215 gAssertBehavior = NS_ASSERT_TRAP; | |
| 216 #else | |
| 217 gAssertBehavior = NS_ASSERT_WARN; | |
| 218 #endif | |
| 219 | |
| 220 const char *assertString = PR_GetEnv("XPCOM_DEBUG_BREAK"); | |
| 221 if (!assertString || !*assertString) | |
| 222 return gAssertBehavior; | |
| 223 | |
| 224 if (!strcmp(assertString, "warn")) | |
| 225 return gAssertBehavior = NS_ASSERT_WARN; | |
| 226 | |
| 227 if (!strcmp(assertString, "suspend")) | |
| 228 return gAssertBehavior = NS_ASSERT_SUSPEND; | |
| 229 | |
| 230 if (!strcmp(assertString, "stack")) | |
| 231 return gAssertBehavior = NS_ASSERT_STACK; | |
| 232 | |
| 233 if (!strcmp(assertString, "abort")) | |
| 234 return gAssertBehavior = NS_ASSERT_ABORT; | |
| 235 | |
| 236 if (!strcmp(assertString, "trap") || !strcmp(assertString, "break")) | |
| 237 return gAssertBehavior = NS_ASSERT_TRAP; | |
| 238 | |
| 239 if (!strcmp(assertString, "stack-and-abort")) | |
| 240 return gAssertBehavior = NS_ASSERT_STACK_AND_ABORT; | |
| 241 | |
| 242 fprintf(stderr, "Unrecognized value of XPCOM_DEBUG_BREAK\n"); | |
| 243 return gAssertBehavior; | |
| 244 } | |
| 245 | |
| 246 struct FixedBuffer | |
| 247 { | |
| 248 FixedBuffer() : curlen(0) { buffer[0] = '\0'; } | |
| 249 | |
| 250 char buffer[1000]; | |
| 251 uint32_t curlen; | |
| 252 }; | |
| 253 | |
| 254 static int | |
| 255 StuffFixedBuffer(void *closure, const char *buf, uint32_t len) | |
| 256 { | |
| 257 if (!len) | |
| 258 return 0; | |
| 259 | |
| 260 FixedBuffer *fb = (FixedBuffer*) closure; | |
| 261 | |
| 262 // strip the trailing null, we add it again later | |
| 263 if (buf[len - 1] == '\0') | |
| 264 --len; | |
| 265 | |
| 266 if (fb->curlen + len >= sizeof(fb->buffer)) | |
| 267 len = sizeof(fb->buffer) - fb->curlen - 1; | |
| 268 | |
| 269 if (len) { | |
| 270 memcpy(fb->buffer + fb->curlen, buf, len); | |
| 271 fb->curlen += len; | |
| 272 fb->buffer[fb->curlen] = '\0'; | |
| 273 } | |
| 274 | |
| 275 return len; | |
| 276 } | |
| 277 | |
| 278 EXPORT_XPCOM_API(void) | |
| 279 NS_DebugBreak(uint32_t aSeverity, const char *aStr, const char *aExpr, | |
| 280 const char *aFile, int32_t aLine) | |
| 281 { | |
| 282 InitLog(); | |
| 283 | |
| 284 FixedBuffer buf; | |
| 285 PRLogModuleLevel ll = PR_LOG_WARNING; | |
| 286 const char *sevString = "WARNING"; | |
| 287 | |
| 288 switch (aSeverity) { | |
| 289 case NS_DEBUG_ASSERTION: | |
| 290 sevString = "###!!! ASSERTION"; | |
| 291 ll = PR_LOG_ERROR; | |
| 292 break; | |
| 293 | |
| 294 case NS_DEBUG_BREAK: | |
| 295 sevString = "###!!! BREAK"; | |
| 296 ll = PR_LOG_ALWAYS; | |
| 297 break; | |
| 298 | |
| 299 case NS_DEBUG_ABORT: | |
| 300 sevString = "###!!! ABORT"; | |
| 301 ll = PR_LOG_ALWAYS; | |
| 302 break; | |
| 303 | |
| 304 default: | |
| 305 aSeverity = NS_DEBUG_WARNING; | |
| 306 }; | |
| 307 | |
| 308 # define PrintToBuffer(...) PR_sxprintf(StuffFixedBuffer, &buf, __VA_ARGS__) | |
| 309 | |
| 310 // Print "[PID]" or "[Desc PID]" at the beginning of the message. | |
| 311 PrintToBuffer("["); | |
| 312 if (sMultiprocessDescription) { | |
| 313 PrintToBuffer("%s ", sMultiprocessDescription); | |
| 314 } | |
| 315 PrintToBuffer("%d] ", base::GetCurrentProcId()); | |
| 316 | |
| 317 PrintToBuffer("%s: ", sevString); | |
| 318 | |
| 319 if (aStr) | |
| 320 PrintToBuffer("%s: ", aStr); | |
| 321 | |
| 322 if (aExpr) | |
| 323 PrintToBuffer("'%s', ", aExpr); | |
| 324 | |
| 325 if (aFile) | |
| 326 PrintToBuffer("file %s, ", aFile); | |
| 327 | |
| 328 if (aLine != -1) | |
| 329 PrintToBuffer("line %d", aLine); | |
| 330 | |
| 331 # undef PrintToBuffer | |
| 332 | |
| 333 // Write out the message to the debug log | |
| 334 PR_LOG(gDebugLog, ll, ("%s", buf.buffer)); | |
| 335 PR_LogFlush(); | |
| 336 | |
| 337 // errors on platforms without a debugdlg ring a bell on stderr | |
| 338 #if !defined(XP_WIN) | |
| 339 if (ll != PR_LOG_WARNING) | |
| 340 fprintf(stderr, "\07"); | |
| 341 #endif | |
| 342 | |
| 343 #ifdef ANDROID | |
| 344 __android_log_print(ANDROID_LOG_INFO, "Gecko", "%s", buf.buffer); | |
| 345 #endif | |
| 346 | |
| 347 // Write the message to stderr unless it's a warning and MOZ_IGNORE_WARNINGS | |
| 348 // is set. | |
| 349 if (!(PR_GetEnv("MOZ_IGNORE_WARNINGS") && aSeverity == NS_DEBUG_WARNING)) { | |
| 350 fprintf(stderr, "%s\n", buf.buffer); | |
| 351 fflush(stderr); | |
| 352 } | |
| 353 | |
| 354 switch (aSeverity) { | |
| 355 case NS_DEBUG_WARNING: | |
| 356 return; | |
| 357 | |
| 358 case NS_DEBUG_BREAK: | |
| 359 Break(buf.buffer); | |
| 360 return; | |
| 361 | |
| 362 case NS_DEBUG_ABORT: { | |
| 363 #if defined(MOZ_CRASHREPORTER) | |
| 364 nsCString note("xpcom_runtime_abort("); | |
| 365 note += buf.buffer; | |
| 366 note += ")"; | |
| 367 CrashReporter::AppendAppNotesToCrashReport(note); | |
| 368 CrashReporter::AnnotateCrashReport(NS_LITERAL_CSTRING("AbortMessage"), | |
| 369 nsDependentCString(buf.buffer)); | |
| 370 #endif // MOZ_CRASHREPORTER | |
| 371 | |
| 372 #if defined(DEBUG) && defined(_WIN32) | |
| 373 RealBreak(); | |
| 374 #endif | |
| 375 #ifdef DEBUG | |
| 376 nsTraceRefcnt::WalkTheStack(stderr); | |
| 377 #endif | |
| 378 Abort(buf.buffer); | |
| 379 return; | |
| 380 } | |
| 381 } | |
| 382 | |
| 383 // Now we deal with assertions | |
| 384 gAssertionCount++; | |
| 385 | |
| 386 switch (GetAssertBehavior()) { | |
| 387 case NS_ASSERT_WARN: | |
| 388 return; | |
| 389 | |
| 390 case NS_ASSERT_SUSPEND: | |
| 391 #ifdef XP_UNIX | |
| 392 fprintf(stderr, "Suspending process; attach with the debugger.\n"); | |
| 393 kill(0, SIGSTOP); | |
| 394 #else | |
| 395 Break(buf.buffer); | |
| 396 #endif | |
| 397 return; | |
| 398 | |
| 399 case NS_ASSERT_STACK: | |
| 400 nsTraceRefcnt::WalkTheStack(stderr); | |
| 401 return; | |
| 402 | |
| 403 case NS_ASSERT_STACK_AND_ABORT: | |
| 404 nsTraceRefcnt::WalkTheStack(stderr); | |
| 405 // Fall through to abort | |
| 406 | |
| 407 case NS_ASSERT_ABORT: | |
| 408 Abort(buf.buffer); | |
| 409 return; | |
| 410 | |
| 411 case NS_ASSERT_TRAP: | |
| 412 case NS_ASSERT_UNINITIALIZED: // Default to "trap" behavior | |
| 413 Break(buf.buffer); | |
| 414 return; | |
| 415 } | |
| 416 } | |
| 417 | |
| 418 static void | |
| 419 Abort(const char *aMsg) | |
| 420 { | |
| 421 mozalloc_abort(aMsg); | |
| 422 } | |
| 423 | |
| 424 static void | |
| 425 RealBreak() | |
| 426 { | |
| 427 #if defined(_WIN32) | |
| 428 ::DebugBreak(); | |
| 429 #elif defined(XP_MACOSX) | |
| 430 raise(SIGTRAP); | |
| 431 #elif defined(__GNUC__) && (defined(__i386__) || defined(__i386) || defined(__x86_64__)) | |
| 432 asm("int $3"); | |
| 433 #elif defined(__arm__) | |
| 434 asm( | |
| 435 #ifdef __ARM_ARCH_4T__ | |
| 436 /* ARMv4T doesn't support the BKPT instruction, so if the compiler target | |
| 437 * is ARMv4T, we want to ensure the assembler will understand that ARMv5T | |
| 438 * instruction, while keeping the resulting object tagged as ARMv4T. | |
| 439 */ | |
| 440 ".arch armv5t\n" | |
| 441 ".object_arch armv4t\n" | |
| 442 #endif | |
| 443 "BKPT #0"); | |
| 444 #elif defined(SOLARIS) | |
| 445 #if defined(__i386__) || defined(__i386) || defined(__x86_64__) | |
| 446 asm("int $3"); | |
| 447 #else | |
| 448 raise(SIGTRAP); | |
| 449 #endif | |
| 450 #else | |
| 451 #warning do not know how to break on this platform | |
| 452 #endif | |
| 453 } | |
| 454 | |
| 455 // Abort() calls this function, don't call it! | |
| 456 static void | |
| 457 Break(const char *aMsg) | |
| 458 { | |
| 459 #if defined(_WIN32) | |
| 460 static int ignoreDebugger; | |
| 461 if (!ignoreDebugger) { | |
| 462 const char *shouldIgnoreDebugger = getenv("XPCOM_DEBUG_DLG"); | |
| 463 ignoreDebugger = 1 + (shouldIgnoreDebugger && !strcmp(shouldIgnoreDebugger, "1")); | |
| 464 } | |
| 465 if ((ignoreDebugger == 2) || !::IsDebuggerPresent()) { | |
| 466 DWORD code = IDRETRY; | |
| 467 | |
| 468 /* Create the debug dialog out of process to avoid the crashes caused by | |
| 469 * Windows events leaking into our event loop from an in process dialog. | |
| 470 * We do this by launching windbgdlg.exe (built in xpcom/windbgdlg). | |
| 471 * See http://bugzilla.mozilla.org/show_bug.cgi?id=54792 | |
| 472 */ | |
| 473 PROCESS_INFORMATION pi; | |
| 474 STARTUPINFOW si; | |
| 475 wchar_t executable[MAX_PATH]; | |
| 476 wchar_t* pName; | |
| 477 | |
| 478 memset(&pi, 0, sizeof(pi)); | |
| 479 | |
| 480 memset(&si, 0, sizeof(si)); | |
| 481 si.cb = sizeof(si); | |
| 482 si.wShowWindow = SW_SHOW; | |
| 483 | |
| 484 // 2nd arg of CreateProcess is in/out | |
| 485 wchar_t *msgCopy = (wchar_t*) _alloca((strlen(aMsg) + 1)*sizeof(wchar_t)); | |
| 486 wcscpy(msgCopy, NS_ConvertUTF8toUTF16(aMsg).get()); | |
| 487 | |
| 488 if(GetModuleFileNameW(GetModuleHandleW(L"xpcom.dll"), executable, MAX_PATH) && | |
| 489 nullptr != (pName = wcsrchr(executable, '\\')) && | |
| 490 nullptr != wcscpy(pName + 1, L"windbgdlg.exe") && | |
| 491 CreateProcessW(executable, msgCopy, nullptr, nullptr, | |
| 492 false, DETACHED_PROCESS | NORMAL_PRIORITY_CLASS, | |
| 493 nullptr, nullptr, &si, &pi)) { | |
| 494 WaitForSingleObject(pi.hProcess, INFINITE); | |
| 495 GetExitCodeProcess(pi.hProcess, &code); | |
| 496 CloseHandle(pi.hProcess); | |
| 497 CloseHandle(pi.hThread); | |
| 498 } | |
| 499 | |
| 500 switch(code) { | |
| 501 case IDABORT: | |
| 502 //This should exit us | |
| 503 raise(SIGABRT); | |
| 504 //If we are ignored exit this way.. | |
| 505 _exit(3); | |
| 506 | |
| 507 case IDIGNORE: | |
| 508 return; | |
| 509 } | |
| 510 } | |
| 511 | |
| 512 RealBreak(); | |
| 513 #elif defined(XP_MACOSX) | |
| 514 /* Note that we put this Mac OS X test above the GNUC/x86 test because the | |
| 515 * GNUC/x86 test is also true on Intel Mac OS X and we want the PPC/x86 | |
| 516 * impls to be the same. | |
| 517 */ | |
| 518 RealBreak(); | |
| 519 #elif defined(__GNUC__) && (defined(__i386__) || defined(__i386) || defined(__x86_64__)) | |
| 520 RealBreak(); | |
| 521 #elif defined(__arm__) | |
| 522 RealBreak(); | |
| 523 #elif defined(SOLARIS) | |
| 524 RealBreak(); | |
| 525 #else | |
| 526 #warning do not know how to break on this platform | |
| 527 #endif | |
| 528 } | |
| 529 | |
| 530 static const nsDebugImpl kImpl; | |
| 531 | |
| 532 nsresult | |
| 533 nsDebugImpl::Create(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr) | |
| 534 { | |
| 535 if (NS_WARN_IF(outer)) | |
| 536 return NS_ERROR_NO_AGGREGATION; | |
| 537 | |
| 538 return const_cast<nsDebugImpl*>(&kImpl)-> | |
| 539 QueryInterface(aIID, aInstancePtr); | |
| 540 } | |
| 541 | |
| 542 //////////////////////////////////////////////////////////////////////////////// | |
| 543 | |
| 544 nsresult | |
| 545 NS_ErrorAccordingToNSPR() | |
| 546 { | |
| 547 PRErrorCode err = PR_GetError(); | |
| 548 switch (err) { | |
| 549 case PR_OUT_OF_MEMORY_ERROR: return NS_ERROR_OUT_OF_MEMORY; | |
| 550 case PR_WOULD_BLOCK_ERROR: return NS_BASE_STREAM_WOULD_BLOCK; | |
| 551 case PR_FILE_NOT_FOUND_ERROR: return NS_ERROR_FILE_NOT_FOUND; | |
| 552 case PR_READ_ONLY_FILESYSTEM_ERROR: return NS_ERROR_FILE_READ_ONLY; | |
| 553 case PR_NOT_DIRECTORY_ERROR: return NS_ERROR_FILE_NOT_DIRECTORY; | |
| 554 case PR_IS_DIRECTORY_ERROR: return NS_ERROR_FILE_IS_DIRECTORY; | |
| 555 case PR_LOOP_ERROR: return NS_ERROR_FILE_UNRESOLVABLE_SYMLINK; | |
| 556 case PR_FILE_EXISTS_ERROR: return NS_ERROR_FILE_ALREADY_EXISTS; | |
| 557 case PR_FILE_IS_LOCKED_ERROR: return NS_ERROR_FILE_IS_LOCKED; | |
| 558 case PR_FILE_TOO_BIG_ERROR: return NS_ERROR_FILE_TOO_BIG; | |
| 559 case PR_NO_DEVICE_SPACE_ERROR: return NS_ERROR_FILE_NO_DEVICE_SPACE; | |
| 560 case PR_NAME_TOO_LONG_ERROR: return NS_ERROR_FILE_NAME_TOO_LONG; | |
| 561 case PR_DIRECTORY_NOT_EMPTY_ERROR: return NS_ERROR_FILE_DIR_NOT_EMPTY; | |
| 562 case PR_NO_ACCESS_RIGHTS_ERROR: return NS_ERROR_FILE_ACCESS_DENIED; | |
| 563 default: return NS_ERROR_FAILURE; | |
| 564 } | |
| 565 } | |
| 566 | |
| 567 void | |
| 568 NS_ABORT_OOM(size_t size) | |
| 569 { | |
| 570 #ifdef MOZ_CRASHREPORTER | |
| 571 CrashReporter::AnnotateOOMAllocationSize(size); | |
| 572 #endif | |
| 573 MOZ_CRASH(); | |
| 574 } | |
| 575 |
