Bug 1373536 - Clean up static API of TimeoutBudgetManager. r=smaug

dom/base/TimeoutBudgetManager.cpp

@@ -6,17 +6,18 @@
 
 #include "TimeoutBudgetManager.h"
 
+#include "mozilla/dom/Timeout.h"
+
 namespace mozilla {
 namespace dom {
 
 // Time between sampling timeout execution time.
 const uint32_t kTelemetryPeriodMS = 1000;
 
-static TimeoutBudgetManager gTimeoutBudgetManager;
-
 /* static */ TimeoutBudgetManager&
 TimeoutBudgetManager::Get()
 {
+  static TimeoutBudgetManager gTimeoutBudgetManager;
   return gTimeoutBudgetManager;
 }
 
@@ -32,34 +33,32 @@ TimeoutBudgetManager::StopRecording()
   mStart = TimeStamp();
 }
 
-TimeDuration
+void
 TimeoutBudgetManager::RecordExecution(const TimeStamp& aNow,
-                                      bool aIsTracking,
+                                      const Timeout* aTimeout,
                                       bool aIsBackground)
 {
   if (!mStart) {
     // If we've started a sync operation mStart might be null, in
     // which case we should not record this piece of execution.
-    return TimeDuration();
+    return;
   }
 
   TimeDuration duration = aNow - mStart;
 
   if (aIsBackground) {
-    if (aIsTracking) {
+    if (aTimeout->mIsTracking) {
       mTelemetryData.mBackgroundTracking += duration;
     } else {
       mTelemetryData.mBackgroundNonTracking += duration;
     }
   } else {
-    if (aIsTracking) {
+    if (aTimeout->mIsTracking) {
       mTelemetryData.mForegroundTracking += duration;
     } else {
       mTelemetryData.mForegroundNonTracking += duration;
     }
   }
-
-  return duration;
 }
 
 void

dom/base/TimeoutBudgetManager.h

@@ -13,19 +13,20 @@
 namespace mozilla {
 namespace dom {
 
+class Timeout;
+
 class TimeoutBudgetManager
 {
 public:
   static TimeoutBudgetManager& Get();
-  TimeoutBudgetManager() : mLastCollection(TimeStamp::Now()) {}
-
   void StartRecording(const TimeStamp& aNow);
   void StopRecording();
-  TimeDuration RecordExecution(const TimeStamp& aNow,
-                               bool aIsTracking,
+  void RecordExecution(const TimeStamp& aNow,
+                       const Timeout* aTimeout,
                        bool aIsBackground);
   void MaybeCollectTelemetry(const TimeStamp& aNow);
 private:
+  TimeoutBudgetManager() : mLastCollection(TimeStamp::Now()) {}
   struct TelemetryData
   {
     TimeDuration mForegroundTracking;

dom/base/TimeoutManager.cpp

@@ -154,20 +154,23 @@ TimeoutManager::RecordExecution(Timeout* aRunningTimeout,
     return;
   }
 
+  TimeoutBudgetManager& budgetManager = TimeoutBudgetManager::Get();
   TimeStamp now = TimeStamp::Now();
+
   if (aRunningTimeout) {
     // If we're running a timeout callback, record any execution until
     // now.
-    TimeoutBudgetManager::Get().RecordExecution(
-      now, aRunningTimeout->mIsTracking, IsBackground());
-    TimeoutBudgetManager::Get().MaybeCollectTelemetry(now);
+    budgetManager.RecordExecution(
+      now, aRunningTimeout, mWindow.IsBackgroundInternal());
+    budgetManager.MaybeCollectTelemetry(now);
   }
 
   if (aTimeout) {
     // If we're starting a new timeout callback, start recording.
-    TimeoutBudgetManager::Get().StartRecording(now);
+    budgetManager.StartRecording(now);
   } else {
-    TimeoutBudgetManager::Get().StopRecording();
+    // Else stop by clearing the start timestamp.
+    budgetManager.StopRecording();
   }
 }