Use RecordReplayAllowSideEffects API (#962)

Author: bhackett1024

dom/base/Document.cpp

@@ -10547,7 +10547,7 @@ class nsDocumentOnStack {
 
 void Document::FlushPendingNotifications(mozilla::ChangesToFlush aFlush) {
   // See PresShell::DoFlushPendingNotifications.
-  if (!mozilla::recordreplay::IsUnhandledDivergenceAllowed()) {
+  if (!mozilla::recordreplay::AllowSideEffects()) {
     return;
   }
 

dom/canvas/CanvasRenderingContext2D.cpp

@@ -4068,7 +4068,7 @@ gfxFontGroup* CanvasRenderingContext2D::GetCurrentFontStyle() {
     // Creating new font groups interacts with the system and could trigger
     // unhandled divergences from the recording, so avoid this when those
     // divergences aren't allowed.
-    if (!recordreplay::IsUnhandledDivergenceAllowed()) {
+    if (!recordreplay::AllowSideEffects()) {
       return nullptr;
     }
 

layout/base/PresShell.cpp

@@ -4062,7 +4062,7 @@ static inline void AssertFrameTreeIsSane(const PresShell& aPresShell) {
 void PresShell::DoFlushPendingNotifications(mozilla::ChangesToFlush aFlush) {
   // Flushing layout can interact with the system in new ways, and doesn't
   // happen when unhandled divergence isn't allowed.
-  if (!mozilla::recordreplay::IsUnhandledDivergenceAllowed()) {
+  if (!mozilla::recordreplay::AllowSideEffects()) {
     return;
   }
 

layout/generic/nsBlockFrame.cpp

@@ -1228,7 +1228,7 @@ static bool IsLineClampItem(const ReflowInput& aReflowInput) {
 void nsBlockFrame::Reflow(nsPresContext* aPresContext, ReflowOutput& aMetrics,
                           const ReflowInput& aReflowInput,
                           nsReflowStatus& aStatus) {
-  MOZ_RELEASE_ASSERT(mozilla::recordreplay::IsUnhandledDivergenceAllowed());
+  MOZ_RELEASE_ASSERT(mozilla::recordreplay::AllowSideEffects());
 
   MarkInReflow();
   DO_GLOBAL_REFLOW_COUNT("nsBlockFrame");

layout/generic/nsGfxScrollFrame.cpp

@@ -875,7 +875,7 @@ bool nsHTMLScrollFrame::InInitialReflow() const {
 
 void nsHTMLScrollFrame::ReflowContents(ScrollReflowInput* aState,
                                        const ReflowOutput& aDesiredSize) {
-  MOZ_RELEASE_ASSERT(mozilla::recordreplay::IsUnhandledDivergenceAllowed());
+  MOZ_RELEASE_ASSERT(mozilla::recordreplay::AllowSideEffects());
 
   ReflowOutput kidDesiredSize(aDesiredSize.GetWritingMode());
   ReflowScrolledFrame(aState, GuessHScrollbarNeeded(*aState),

layout/generic/nsTextFrame.cpp

@@ -1624,7 +1624,7 @@ void BuildTextRunsScanner::FlushFrames(bool aFlushLineBreaks,
                                        bool aSuppressTrailingBreak) {
   // For now we avoid flushing layout state after diverging from the recording,
   // so we don't encounter new calls into the system.
-  if (!recordreplay::IsUnhandledDivergenceAllowed()) {
+  if (!recordreplay::AllowSideEffects()) {
     return;
   }
 

mfbt/RecordReplay.cpp

@@ -31,7 +31,7 @@ namespace recordreplay {
   Macro(InternalRecordReplayValue, size_t, (const char* aWhy, size_t aValue),  \
         (aWhy, aValue))                                                        \
   Macro(InternalHasDivergedFromRecording, bool, (), ())                        \
-  Macro(InternalIsUnhandledDivergenceAllowed, bool, (), ())                    \
+  Macro(InternalAllowSideEffects, bool, (), ())                                \
   Macro(InternalThingIndex, size_t, (void* aThing), (aThing))                  \
   Macro(InternalIndexThing, void*, (size_t aId), (aId))                        \
   Macro(InternalCreateOrderedLock, int, (const char* aName), (aName))          \

mfbt/RecordReplay.h

@@ -151,7 +151,7 @@ static inline bool HasDivergedFromRecording();
 // Return whether execution is allowed to interact with the system in a way
 // that could trigger an unhandled divergence. This returns true except during
 // certain operations while diverged from the recording.
-static inline bool IsUnhandledDivergenceAllowed();
+static inline bool AllowSideEffects();
 
 // API for debugging inconsistent behavior between recording and replay.
 // By calling Assert or AssertBytes a thread event will be inserted and any
@@ -418,7 +418,7 @@ MOZ_MAKE_RECORD_REPLAY_WRAPPER_VOID(RecordReplayBytes,
                                     (const char* aWhy, void* aData, size_t aSize),
                                     (aWhy, aData, aSize))
 MOZ_MAKE_RECORD_REPLAY_WRAPPER(HasDivergedFromRecording, bool, false, (), ())
-MOZ_MAKE_RECORD_REPLAY_WRAPPER(IsUnhandledDivergenceAllowed, bool, true, (), ())
+MOZ_MAKE_RECORD_REPLAY_WRAPPER(AllowSideEffects, bool, true, (), ())
 MOZ_MAKE_RECORD_REPLAY_WRAPPER_VOID(InvalidateRecording, (const char* aWhy),
                                     (aWhy))
 MOZ_MAKE_RECORD_REPLAY_WRAPPER_VOID(RecordReplayAssertBytes,

toolkit/recordreplay/ProcessRecordReplay.cpp

@@ -107,7 +107,7 @@ static void (*gBeginDisallowEvents)();
 static void (*gEndDisallowEvents)();
 static bool (*gAreEventsDisallowed)();
 static bool (*gHasDivergedFromRecording)();
-static bool (*gIsUnhandledDivergenceAllowed)();
+static bool (*gAllowSideEffects)();
 static void (*gRecordReplayNewCheckpoint)();
 static bool (*gRecordReplayIsReplaying)();
 static int (*gCreateOrderedLock)(const char* aName);
@@ -433,7 +433,7 @@ MOZ_EXPORT void RecordReplayInterface_Initialize(int* aArgc, char*** aArgv) {
   LoadSymbol("RecordReplayEndDisallowEvents", gEndDisallowEvents);
   LoadSymbol("RecordReplayAreEventsDisallowed", gAreEventsDisallowed);
   LoadSymbol("RecordReplayHasDivergedFromRecording", gHasDivergedFromRecording);
-  LoadSymbol("RecordReplayIsUnhandledDivergenceAllowed", gIsUnhandledDivergenceAllowed);
+  LoadSymbol("RecordReplayAllowSideEffects", gAllowSideEffects);
   LoadSymbol("RecordReplayNewCheckpoint", gRecordReplayNewCheckpoint);
   LoadSymbol("RecordReplayIsReplaying", gRecordReplayIsReplaying);
   LoadSymbol("RecordReplayCreateOrderedLock", gCreateOrderedLock);
@@ -665,8 +665,8 @@ MOZ_EXPORT bool RecordReplayInterface_InternalHasDivergedFromRecording() {
   return gHasDivergedFromRecording();
 }
 
-MOZ_EXPORT bool RecordReplayInterface_InternalIsUnhandledDivergenceAllowed() {
-  return gIsUnhandledDivergenceAllowed();
+MOZ_EXPORT bool RecordReplayInterface_InternalAllowSideEffects() {
+  return gAllowSideEffects();
 }
 
 MOZ_EXPORT int RecordReplayInterface_InternalCreateOrderedLock(const char* aName) {