Bug 1358320 - Make TimeStamp::ProcessCreation()'s outparam optional. r=gsvelto.
authorNicholas Nethercote <nnethercote@mozilla.com>
Wed, 26 Apr 2017 14:55:54 +1000
changeset 355051 e1eb2550cb111e242ded6a12d6e50731fcefcbf6
parent 355050 1a95eef9b0b55b1f072a1cafe702b84bf8faa142
child 355052 774240b19c633c7035f8d5fe92d33965fd6cedb3
push id31720
push userkwierso@gmail.com
push dateThu, 27 Apr 2017 00:30:39 +0000
treeherdermozilla-central@0b77ed3f26c5 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersgsvelto
bugs1358320
milestone55.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1358320 - Make TimeStamp::ProcessCreation()'s outparam optional. r=gsvelto. TimeStamp::ProcessCreations()'s aIsInconsistent outparam is ignored by the majority of its caller. This patch makes it optional. Notably, this makes ProcessCreation() easier to use in a constructor's initializer list.
devtools/shared/heapsnapshot/HeapSnapshot.cpp
docshell/base/nsDocShell.cpp
docshell/base/timeline/AbstractTimelineMarker.cpp
dom/base/nsImageLoadingContent.cpp
gfx/thebes/gfxPlatform.cpp
ipc/mscom/InterceptorLog.cpp
js/src/builtin/Promise.cpp
js/src/builtin/TestingFunctions.cpp
js/src/gc/Statistics.cpp
js/src/vm/Debugger.cpp
js/src/vm/DebuggerMemory.cpp
js/src/vm/Initialization.cpp
js/xpconnect/src/XPCComponents.cpp
mozglue/misc/TimeStamp.cpp
mozglue/misc/TimeStamp.h
toolkit/components/startup/nsAppStartup.cpp
toolkit/components/telemetry/TelemetryCommon.cpp
toolkit/components/telemetry/TelemetryEvent.cpp
toolkit/crashreporter/nsExceptionHandler.cpp
tools/memory-profiler/MemoryProfiler.cpp
tools/profiler/core/platform.cpp
xpcom/threads/HangMonitor.cpp
--- a/devtools/shared/heapsnapshot/HeapSnapshot.cpp
+++ b/devtools/shared/heapsnapshot/HeapSnapshot.cpp
@@ -1431,18 +1431,17 @@ WriteHeapGraph(JSContext* cx,
   }
 
   return ok;
 }
 
 static unsigned long
 msSinceProcessCreation(const TimeStamp& now)
 {
-  bool ignored;
-  auto duration = now - TimeStamp::ProcessCreation(ignored);
+  auto duration = now - TimeStamp::ProcessCreation();
   return (unsigned long) duration.ToMilliseconds();
 }
 
 /* static */ already_AddRefed<nsIFile>
 HeapSnapshot::CreateUniqueCoreDumpFile(ErrorResult& rv,
                                        const TimeStamp& now,
                                        nsAString& outFilePath,
                                        nsAString& outSnapshotId)
--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -3019,19 +3019,17 @@ nsDocShell::PopProfileTimelineMarkers(
   }
 
   return NS_OK;
 }
 
 nsresult
 nsDocShell::Now(DOMHighResTimeStamp* aWhen)
 {
-  bool ignore;
-  *aWhen =
-    (TimeStamp::Now() - TimeStamp::ProcessCreation(ignore)).ToMilliseconds();
+  *aWhen = (TimeStamp::Now() - TimeStamp::ProcessCreation()).ToMilliseconds();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDocShell::SetWindowDraggingAllowed(bool aValue)
 {
   RefPtr<nsDocShell> parent = GetParentDocshell();
   if (!aValue && mItemType == typeChrome && !parent) {
--- a/docshell/base/timeline/AbstractTimelineMarker.cpp
+++ b/docshell/base/timeline/AbstractTimelineMarker.cpp
@@ -60,18 +60,17 @@ AbstractTimelineMarker::SetCurrentTime()
 {
   TimeStamp now = TimeStamp::Now();
   SetCustomTime(now);
 }
 
 void
 AbstractTimelineMarker::SetCustomTime(const TimeStamp& aTime)
 {
-  bool isInconsistent = false;
-  mTime = (aTime - TimeStamp::ProcessCreation(isInconsistent)).ToMilliseconds();
+  mTime = (aTime - TimeStamp::ProcessCreation()).ToMilliseconds();
 }
 
 void
 AbstractTimelineMarker::SetCustomTime(DOMHighResTimeStamp aTime)
 {
   mTime = aTime;
 }
 
--- a/dom/base/nsImageLoadingContent.cpp
+++ b/dom/base/nsImageLoadingContent.cpp
@@ -95,18 +95,17 @@ nsImageLoadingContent::nsImageLoadingCon
     mStateChangerDepth(0),
     mCurrentRequestRegistered(false),
     mPendingRequestRegistered(false)
 {
   if (!nsContentUtils::GetImgLoaderForChannel(nullptr, nullptr)) {
     mLoadingEnabled = false;
   }
 
-  bool isInconsistent;
-  mMostRecentRequestChange = TimeStamp::ProcessCreation(isInconsistent);
+  mMostRecentRequestChange = TimeStamp::ProcessCreation();
 }
 
 void
 nsImageLoadingContent::DestroyImageLoadingContent()
 {
   // Cancel our requests so they won't hold stale refs to us
   // NB: Don't ask to discard the images here.
   ClearCurrentRequest(NS_BINDING_ABORTED);
--- a/gfx/thebes/gfxPlatform.cpp
+++ b/gfx/thebes/gfxPlatform.cpp
@@ -249,18 +249,17 @@ CrashStatsLogForwarder::UpdateStringsVec
   mIndex += 1;
   MOZ_ASSERT(mIndex >= 0);
 
   // index will count 0, 1, 2, ..., max-1, 1, 2, ..., max-1, 1, 2, ...
   int32_t index = mIndex ? (mIndex-1) % (mMaxCapacity-1) + 1 : 0;
   MOZ_ASSERT(index >= 0 && index < (int32_t)mMaxCapacity);
   MOZ_ASSERT(index <= mIndex && index <= (int32_t)mBuffer.size());
 
-  bool ignored;
-  double tStamp = (TimeStamp::NowLoRes()-TimeStamp::ProcessCreation(ignored)).ToSecondsSigDigits();
+  double tStamp = (TimeStamp::NowLoRes() - TimeStamp::ProcessCreation()).ToSecondsSigDigits();
 
   // Checking for index >= mBuffer.size(), rather than index == mBuffer.size()
   // just out of paranoia, but we know index <= mBuffer.size().
   LoggingRecordEntry newEntry(mIndex,aString,tStamp);
   if (index >= static_cast<int32_t>(mBuffer.size())) {
     mBuffer.push_back(newEntry);
   } else {
     mBuffer[index] = newEntry;
--- a/ipc/mscom/InterceptorLog.cpp
+++ b/ipc/mscom/InterceptorLog.cpp
@@ -253,18 +253,17 @@ Logger::VariantToString(const VARIANT& a
     }
   }
 }
 
 /* static */ double
 Logger::GetElapsedTime()
 {
   TimeStamp ts = TimeStamp::Now();
-  bool inconsistent;
-  TimeDuration duration = ts - TimeStamp::ProcessCreation(inconsistent);
+  TimeDuration duration = ts - TimeStamp::ProcessCreation();
   return duration.ToMicroseconds();
 }
 
 void
 Logger::LogQI(HRESULT aResult, IUnknown* aTarget, REFIID aIid, IUnknown* aInterface)
 {
   if (FAILED(aResult)) {
     return;
--- a/js/src/builtin/Promise.cpp
+++ b/js/src/builtin/Promise.cpp
@@ -25,18 +25,17 @@
 #include "vm/NativeObject-inl.h"
 
 using namespace js;
 
 static double
 MillisecondsSinceStartup()
 {
     auto now = mozilla::TimeStamp::Now();
-    bool ignored;
-    return (now - mozilla::TimeStamp::ProcessCreation(ignored)).ToMilliseconds();
+    return (now - mozilla::TimeStamp::ProcessCreation()).ToMilliseconds();
 }
 
 enum PromiseHandler {
     PromiseHandlerIdentity = 0,
     PromiseHandlerThrower,
     PromiseHandlerAsyncFunctionAwaitFulfilled,
     PromiseHandlerAsyncFunctionAwaitRejected,
     PromiseHandlerAsyncGeneratorAwaitFulfilled,
--- a/js/src/builtin/TestingFunctions.cpp
+++ b/js/src/builtin/TestingFunctions.cpp
@@ -4314,19 +4314,18 @@ AflLoop(JSContext* cx, unsigned argc, Va
     return true;
 }
 #endif
 
 static bool
 TimeSinceCreation(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
-    bool ignore;
-    double when = (mozilla::TimeStamp::Now()
-                   - mozilla::TimeStamp::ProcessCreation(ignore)).ToMilliseconds();
+    double when = (mozilla::TimeStamp::Now() -
+                   mozilla::TimeStamp::ProcessCreation()).ToMilliseconds();
     args.rval().setNumber(when);
     return true;
 }
 
 static bool
 GetErrorNotes(JSContext* cx, unsigned argc, Value* vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
--- a/js/src/gc/Statistics.cpp
+++ b/js/src/gc/Statistics.cpp
@@ -742,18 +742,17 @@ Statistics::formatJsonSliceDescription(u
 {
     TimeDuration duration = slice.duration();
     lldiv_t durationParts = SplitDurationMS(duration);
     TimeDuration when = slice.start - slices[0].start;
     lldiv_t whenParts = SplitDurationMS(when);
     char budgetDescription[200];
     slice.budget.describe(budgetDescription, sizeof(budgetDescription) - 1);
     int64_t pageFaults = slice.endFaults - slice.startFaults;
-    bool ignore;
-    TimeStamp originTime = TimeStamp::ProcessCreation(ignore);
+    TimeStamp originTime = TimeStamp::ProcessCreation();
 
     const char* format =
         "\"slice\":%d,"
         "\"pause\":%llu.%03llu,"
         "\"when\":%llu.%03llu,"
         "\"reason\":\"%s\","
         "\"initial_state\":\"%s\","
         "\"final_state\":\"%s\","
@@ -1024,19 +1023,18 @@ LongestPhaseSelfTime(const Statistics::P
 void
 Statistics::printStats()
 {
     if (aborted) {
         fprintf(fp, "OOM during GC statistics collection. The report is unavailable for this GC.\n");
     } else {
         UniqueChars msg = formatDetailedMessage();
         if (msg) {
-            bool ignoredInconsistency;
             double secSinceStart =
-                (slices[0].start - TimeStamp::ProcessCreation(ignoredInconsistency)).ToSeconds();
+                (slices[0].start - TimeStamp::ProcessCreation()).ToSeconds();
             fprintf(fp, "GC(T+%.3fs) %s\n", secSinceStart, msg.get());
         }
     }
     fflush(fp);
 }
 
 void
 Statistics::beginGC(JSGCInvocationKind kind)
--- a/js/src/vm/Debugger.cpp
+++ b/js/src/vm/Debugger.cpp
@@ -11791,18 +11791,17 @@ GarbageCollectionEvent::toJSObject(JSCon
     {
         return nullptr;
     }
 
     RootedArrayObject slicesArray(cx, NewDenseEmptyArray(cx));
     if (!slicesArray)
         return nullptr;
 
-    bool ignored; // Ignore inconsistencies in process creation timestamp.
-    TimeStamp originTime = TimeStamp::ProcessCreation(ignored);
+    TimeStamp originTime = TimeStamp::ProcessCreation();
 
     size_t idx = 0;
     for (auto range = collections.all(); !range.empty(); range.popFront()) {
         RootedPlainObject collectionObj(cx, NewBuiltinClassInstance<PlainObject>(cx));
         if (!collectionObj)
             return nullptr;
 
         RootedValue start(cx), end(cx);
--- a/js/src/vm/DebuggerMemory.cpp
+++ b/js/src/vm/DebuggerMemory.cpp
@@ -201,18 +201,18 @@ DebuggerMemory::drainAllocationsLog(JSCo
         // we must edit them with great care. Use the queue entry in place, and
         // then pop and delete together.
         Debugger::AllocationsLogEntry& entry = dbg->allocationsLog.front();
 
         RootedValue frame(cx, ObjectOrNullValue(entry.frame));
         if (!DefineProperty(cx, obj, cx->names().frame, frame))
             return false;
 
-        bool ignore;
-        double when = (entry.when - mozilla::TimeStamp::ProcessCreation(ignore)).ToMilliseconds();
+        double when = (entry.when -
+                       mozilla::TimeStamp::ProcessCreation()).ToMilliseconds();
         RootedValue timestampValue(cx, NumberValue(when));
         if (!DefineProperty(cx, obj, cx->names().timestamp, timestampValue))
             return false;
 
         RootedString className(cx, Atomize(cx, entry.className, strlen(entry.className)));
         if (!className)
             return false;
         RootedValue classNameValue(cx, StringValue(className));
--- a/js/src/vm/Initialization.cpp
+++ b/js/src/vm/Initialization.cpp
@@ -83,18 +83,17 @@ JS::detail::InitWithFailureDiagnostic(bo
                "how do we have live runtimes before JS_Init?");
 
     PRMJ_NowInit();
 
     // The first invocation of `ProcessCreation` creates a temporary thread
     // and crashes if that fails, i.e. because we're out of memory. To prevent
     // that from happening at some later time, get it out of the way during
     // startup.
-    bool ignored;
-    mozilla::TimeStamp::ProcessCreation(ignored);
+    mozilla::TimeStamp::ProcessCreation();
 
 #ifdef DEBUG
     CheckMessageParameterCounts();
 #endif
 
     RETURN_IF_FAIL(js::TlsContext.init());
 
 #if defined(DEBUG) || defined(JS_OOM_BREAKPOINT)
--- a/js/xpconnect/src/XPCComponents.cpp
+++ b/js/xpconnect/src/XPCComponents.cpp
@@ -3351,18 +3351,17 @@ nsXPCComponents_Utils::AllowCPOWsInAddon
         return NS_ERROR_FAILURE;
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsXPCComponents_Utils::Now(double* aRetval)
 {
-    bool isInconsistent = false;
-    TimeStamp start = TimeStamp::ProcessCreation(isInconsistent);
+    TimeStamp start = TimeStamp::ProcessCreation();
     *aRetval = (TimeStamp::Now() - start).ToMilliseconds();
     return NS_OK;
 }
 
 /***************************************************************************/
 /***************************************************************************/
 /***************************************************************************/
 
--- a/mozglue/misc/TimeStamp.cpp
+++ b/mozglue/misc/TimeStamp.cpp
@@ -42,19 +42,21 @@ struct TimeStampInitialization
   {
     TimeStamp::Shutdown();
   };
 };
 
 static TimeStampInitialization sInitOnce;
 
 MFBT_API TimeStamp
-TimeStamp::ProcessCreation(bool& aIsInconsistent)
+TimeStamp::ProcessCreation(bool* aIsInconsistent)
 {
-  aIsInconsistent = false;
+  if (aIsInconsistent) {
+    *aIsInconsistent = false;
+  }
 
   if (sInitOnce.mProcessCreation.IsNull()) {
     char* mozAppRestart = getenv("MOZ_APP_RESTART");
     TimeStamp ts;
 
     /* When calling PR_SetEnv() with an empty value the existing variable may
      * be unset or set to the empty string depending on the underlying platform
      * thus we have to check if the variable is present and not empty. */
@@ -67,17 +69,19 @@ TimeStamp::ProcessCreation(bool& aIsInco
       uint64_t uptime = ComputeProcessUptime();
 
       ts = now - TimeDuration::FromMicroseconds(uptime);
 
       if ((ts > sInitOnce.mFirstTimeStamp) || (uptime == 0)) {
         /* If the process creation timestamp was inconsistent replace it with
          * the first one instead and notify that a telemetry error was
          * detected. */
-        aIsInconsistent = true;
+        if (aIsInconsistent) {
+          *aIsInconsistent = true;
+        }
         ts = sInitOnce.mFirstTimeStamp;
       }
     }
 
     sInitOnce.mProcessCreation = ts;
   }
 
   return sInitOnce.mProcessCreation;
--- a/mozglue/misc/TimeStamp.h
+++ b/mozglue/misc/TimeStamp.h
@@ -469,22 +469,22 @@ public:
 
   /**
    * Return a timestamp representing the time when the current process was
    * created which will be comparable with other timestamps taken with this
    * class. If the actual process creation time is detected to be inconsistent
    * the @a aIsInconsistent parameter will be set to true, the returned
    * timestamp however will still be valid though inaccurate.
    *
-   * @param aIsInconsistent Set to true if an inconsistency was detected in the
-   * process creation time
+   * @param aIsInconsistent If non-null, set to true if an inconsistency was
+   * detected in the process creation time
    * @returns A timestamp representing the time when the process was created,
    * this timestamp is always valid even when errors are reported
    */
-  static MFBT_API TimeStamp ProcessCreation(bool& aIsInconsistent);
+  static MFBT_API TimeStamp ProcessCreation(bool* aIsInconsistent = nullptr);
 
   /**
    * Records a process restart. After this call ProcessCreation() will return
    * the time when the browser was restarted instead of the actual time when
    * the process was created.
    */
   static MFBT_API void RecordProcessRestart();
 
--- a/toolkit/components/startup/nsAppStartup.cpp
+++ b/toolkit/components/startup/nsAppStartup.cpp
@@ -753,17 +753,17 @@ nsAppStartup::GetStartupInfo(JSContext* 
 
   TimeStamp procTime = StartupTimeline::Get(StartupTimeline::PROCESS_CREATION);
   TimeStamp now = TimeStamp::Now();
   PRTime absNow = PR_Now();
 
   if (procTime.IsNull()) {
     bool error = false;
 
-    procTime = TimeStamp::ProcessCreation(error);
+    procTime = TimeStamp::ProcessCreation(&error);
 
     if (error) {
       Telemetry::Accumulate(Telemetry::STARTUP_MEASUREMENT_ERRORS,
         StartupTimeline::PROCESS_CREATION);
     }
 
     StartupTimeline::Record(StartupTimeline::PROCESS_CREATION, procTime);
   }
--- a/toolkit/components/telemetry/TelemetryCommon.cpp
+++ b/toolkit/components/telemetry/TelemetryCommon.cpp
@@ -78,17 +78,17 @@ CanRecordInProcess(RecordedProcessType p
          ((processType != GeckoProcessType_Default) && recordAllChild);
 }
 
 nsresult
 MsSinceProcessStart(double* aResult)
 {
   bool error;
   *aResult = (TimeStamp::NowLoRes() -
-              TimeStamp::ProcessCreation(error)).ToMilliseconds();
+              TimeStamp::ProcessCreation(&error)).ToMilliseconds();
   if (error) {
     return NS_ERROR_NOT_AVAILABLE;
   }
   return NS_OK;
 }
 
 void
 LogToBrowserConsole(uint32_t aLogLevel, const nsAString& aMsg)
--- a/toolkit/components/telemetry/TelemetryEvent.cpp
+++ b/toolkit/components/telemetry/TelemetryEvent.cpp
@@ -583,18 +583,17 @@ TelemetryEvent::RecordChildEvents(GeckoP
   MOZ_ASSERT(XRE_IsParentProcess());
   StaticMutexAutoLock locker(gTelemetryEventsMutex);
   for (uint32_t i = 0; i < aEvents.Length(); ++i) {
     const mozilla::Telemetry::ChildEventData e = aEvents[i];
 
     // Timestamps from child processes are absolute. We fix them up here to be
     // relative to the main process start time.
     // This allows us to put events from all processes on the same timeline.
-    bool inconsistent = false;
-    double relativeTimestamp = (e.timestamp - TimeStamp::ProcessCreation(inconsistent)).ToMilliseconds();
+    double relativeTimestamp = (e.timestamp - TimeStamp::ProcessCreation()).ToMilliseconds();
 
     ::RecordEvent(locker, aProcessType, relativeTimestamp, e.category, e.method, e.object, e.value, e.extra);
   }
   return NS_OK;
 }
 
 nsresult
 TelemetryEvent::RecordEvent(const nsACString& aCategory, const nsACString& aMethod,
--- a/toolkit/crashreporter/nsExceptionHandler.cpp
+++ b/toolkit/crashreporter/nsExceptionHandler.cpp
@@ -1036,19 +1036,18 @@ bool MinidumpCallback(
     XP_TTOA(timeSinceLastCrash, timeSinceLastCrashString, 10);
   }
   // write crash time to file
   if (lastCrashTimeFilename[0] != 0) {
     PlatformWriter lastCrashFile(lastCrashTimeFilename);
     WriteString(lastCrashFile, crashTimeString);
   }
 
-  bool ignored = false;
-  double uptimeTS = (TimeStamp::NowLoRes()-
-                     TimeStamp::ProcessCreation(ignored)).ToSecondsSigDigits();
+  double uptimeTS = (TimeStamp::NowLoRes() -
+                     TimeStamp::ProcessCreation()).ToSecondsSigDigits();
   char uptimeTSString[64];
   SimpleNoCLibDtoA(uptimeTS, uptimeTSString, sizeof(uptimeTSString));
 
   // Write crash event file.
 
   // Minidump IDs are UUIDs (36) + NULL.
   static char id_ascii[37];
 #ifdef XP_LINUX
@@ -3210,19 +3209,18 @@ WriteExtraData(nsIFile* extraFile,
     time_t crashTime = time(nullptr);
     char crashTimeString[32];
     XP_TTOA(crashTime, crashTimeString, 10);
 
     WriteAnnotation(fd,
                     nsDependentCString("CrashTime"),
                     nsDependentCString(crashTimeString));
 
-    bool ignored = false;
-    double uptimeTS = (TimeStamp::NowLoRes()-
-                       TimeStamp::ProcessCreation(ignored)).ToSecondsSigDigits();
+    double uptimeTS = (TimeStamp::NowLoRes() -
+                       TimeStamp::ProcessCreation()).ToSecondsSigDigits();
     char uptimeTSString[64];
     SimpleNoCLibDtoA(uptimeTS, uptimeTSString, sizeof(uptimeTSString));
 
     WriteAnnotation(fd,
                     nsDependentCString("UptimeTS"),
                     nsDependentCString(uptimeTSString));
   }
 
--- a/tools/memory-profiler/MemoryProfiler.cpp
+++ b/tools/memory-profiler/MemoryProfiler.cpp
@@ -90,18 +90,17 @@ MemoryProfiler::InitOnce()
   if (!initialized) {
     MallocHook::Initialize();
     sLock = PR_NewLock();
     sProfileContextCount = 0;
     sJSContextProfilerMap = new JSContextProfilerMap();
     ClearOnShutdown(&sJSContextProfilerMap);
     ClearOnShutdown(&sNativeProfiler);
     std::srand(PR_Now());
-    bool ignored;
-    sStartTime = TimeStamp::ProcessCreation(ignored);
+    sStartTime = TimeStamp::ProcessCreation();
     initialized = true;
   }
 }
 
 NS_IMETHODIMP
 MemoryProfiler::StartProfiler()
 {
   InitOnce();
--- a/tools/profiler/core/platform.cpp
+++ b/tools/profiler/core/platform.cpp
@@ -1973,18 +1973,17 @@ profiler_init(void* aStackTop)
 
   {
     PSAutoLock lock(gPSMutex);
 
     // We've passed the possible failure point. Instantiate gPS, which
     // indicates that the profiler has initialized successfully.
     gPS = new PS();
 
-    bool ignore;
-    gPS->SetProcessStartTime(lock, mozilla::TimeStamp::ProcessCreation(ignore));
+    gPS->SetProcessStartTime(lock, mozilla::TimeStamp::ProcessCreation());
 
     locked_register_thread(lock, kMainThreadName, aStackTop);
 
     // Platform-specific initialization.
     PlatformInit(lock);
 
 #ifdef MOZ_TASK_TRACER
     mozilla::tasktracer::InitTaskTracer();
--- a/xpcom/threads/HangMonitor.cpp
+++ b/xpcom/threads/HangMonitor.cpp
@@ -178,17 +178,17 @@ GetChromeHangReport(Telemetry::Processed
   }
   aStack = Telemetry::GetStackAndModules(rawStack);
 
   // Record system uptime (in minutes) at the time of the hang
   aSystemUptime = ((GetTickCount() / 1000) - (gTimeout * 2)) / 60;
 
   // Record Firefox uptime (in minutes) at the time of the hang
   bool error;
-  TimeStamp processCreation = TimeStamp::ProcessCreation(error);
+  TimeStamp processCreation = TimeStamp::ProcessCreation(&error);
   if (!error) {
     TimeDuration td = TimeStamp::Now() - processCreation;
     aFirefoxUptime = (static_cast<int32_t>(td.ToSeconds()) - (gTimeout * 2)) / 60;
   } else {
     aFirefoxUptime = -1;
   }
 }