Revert "Capture/Replay: Reset GL Fence Sync objects"

src/libANGLE/capture/FrameCapture.cpp

@@ -931,37 +931,6 @@ void MaybeResetResources(std::stringstream &out,
     }
 }
 
-void MaybeResetFenceSyncObjects(std::stringstream &out,
-                                DataTracker *dataTracker,
-                                std::stringstream &header,
-                                ResourceTracker *resourceTracker,
-                                std::vector<uint8_t> *binaryData)
-{
-    FenceSyncCalls &fenceSyncRegenCalls = resourceTracker->getFenceSyncRegenCalls();
-
-    // If any of our starting fence sync objects were deleted during the run, recreate them
-    FenceSyncSet &fenceSyncsToRegen = resourceTracker->getFenceSyncsToRegen();
-    for (const GLsync sync : fenceSyncsToRegen)
-    {
-        // Emit their regen calls
-        for (CallCapture &call : fenceSyncRegenCalls[sync])
-        {
-            out << "    ";
-            WriteCppReplayForCall(call, dataTracker, out, header, binaryData);
-            out << ";\n";
-        }
-    }
-}
-
-void MaybeResetOpaqueTypeObjects(std::stringstream &out,
-                                 DataTracker *dataTracker,
-                                 std::stringstream &header,
-                                 ResourceTracker *resourceTracker,
-                                 std::vector<uint8_t> *binaryData)
-{
-    MaybeResetFenceSyncObjects(out, dataTracker, header, resourceTracker, binaryData);
-}
-
 void WriteCppReplayFunctionWithParts(const gl::Context *context,
                                      ReplayFunc replayFunc,
                                      DataTracker *dataTracker,
@@ -1089,11 +1058,8 @@ void WriteCppReplay(bool compression,
                                 resourceTracker, binaryData);
         }
 
-        // Reset opaque type objects that don't have IDs, so are not ResourceIDTypes.
-        MaybeResetOpaqueTypeObjects(restoreCallStream, &dataTracker, header, resourceTracker,
-                                    binaryData);
-
         out << restoreCallStream.str();
+
         out << "}\n";
     }
 
@@ -2138,18 +2104,6 @@ void CaptureBufferResetCalls(const gl::State &replayState,
             CaptureUnmapBuffer(replayState, true, gl::BufferBinding::Array, GL_TRUE));
 }
 
-void CaptureFenceSyncResetCalls(const gl::State &replayState,
-                                ResourceTracker *resourceTracker,
-                                GLsync syncID,
-                                const gl::Sync *sync)
-{
-    // Track calls to regenerate a given fence sync
-    FenceSyncCalls &fenceSyncRegenCalls = resourceTracker->getFenceSyncRegenCalls();
-    Capture(&fenceSyncRegenCalls[syncID],
-            CaptureFenceSync(replayState, true, sync->getCondition(), sync->getFlags(), syncID));
-    MaybeCaptureUpdateResourceIDs(&fenceSyncRegenCalls[syncID]);
-}
-
 void CaptureBufferBindingResetCalls(const gl::State &replayState,
                                     ResourceTracker *resourceTracker,
                                     gl::BufferBinding binding,
@@ -3119,8 +3073,6 @@ void CaptureMidExecutionSetup(const gl::Context *context,
             continue;
         }
         cap(CaptureFenceSync(replayState, true, sync->getCondition(), sync->getFlags(), syncID));
-        CaptureFenceSyncResetCalls(replayState, resourceTracker, syncID, sync);
-        resourceTracker->getStartingFenceSyncs().insert(syncID);
     }
 
     // Capture Image Texture bindings
@@ -4095,7 +4047,7 @@ void FrameCapture::maybeCapturePreCallUpdates(const gl::Context *context, CallCa
                     mBufferDataMap.erase(bufferDataInfo);
                 }
                 // If we're capturing, track what buffers have been deleted
-                if (isCaptureActive())
+                if (mFrameIndex >= mCaptureStartFrame)
                 {
                     mResourceTracker.setDeletedBuffer(bufferIDs[i]);
                 }
@@ -4112,7 +4064,7 @@ void FrameCapture::maybeCapturePreCallUpdates(const gl::Context *context, CallCa
             for (GLsizei i = 0; i < count; i++)
             {
                 // If we're capturing, track what new buffers have been genned
-                if (isCaptureActive())
+                if (mFrameIndex >= mCaptureStartFrame)
                 {
                     mResourceTracker.setGennedBuffer(bufferIDs[i]);
                 }
@@ -4120,17 +4072,6 @@ void FrameCapture::maybeCapturePreCallUpdates(const gl::Context *context, CallCa
             break;
         }
 
-        case EntryPoint::GLDeleteSync:
-        {
-            GLsync sync = call.params.getParam("sync", ParamType::TGLsync, 0).value.GLsyncVal;
-            // If we're capturing, track which fence sync has been deleted
-            if (isCaptureActive())
-            {
-                mResourceTracker.setDeletedFenceSync(sync);
-            }
-            break;
-        }
-
         case EntryPoint::GLDrawArrays:
         {
             maybeCaptureDrawArraysClientData(context, call, 1);
@@ -4565,17 +4506,11 @@ void FrameCapture::checkForCaptureTrigger()
 
 void FrameCapture::onEndFrame(const gl::Context *context)
 {
-    if (mFrameIndex > mCaptureEndFrame)
-    {
-        setCaptureInactive();
-        return;
-    }
-
     // On Android, we can trigger a capture during the run
     checkForCaptureTrigger();
 
     // Note that we currently capture before the start frame to collect shader and program sources.
-    if (!mFrameCalls.empty() && isCaptureActive())
+    if (!mFrameCalls.empty() && mFrameIndex >= mCaptureStartFrame)
     {
         if (mIsFirstFrame)
         {
@@ -4620,8 +4555,6 @@ void FrameCapture::onEndFrame(const gl::Context *context)
 
     if (enabled() && mFrameIndex == mCaptureStartFrame)
     {
-        setCaptureActive();
-
         mSetupCalls.clear();
         CaptureMidExecutionSetup(context, &mSetupCalls, &mResourceTracker, this);
     }
@@ -4728,19 +4661,6 @@ void ResourceTracker::setDeletedBuffer(gl::BufferID id)
     mBuffersToRestore.insert(id);
 }
 
-void ResourceTracker::setDeletedFenceSync(GLsync sync)
-{
-    ASSERT(sync != nullptr);
-    if (mStartingFenceSyncs.find(sync) == mStartingFenceSyncs.end())
-    {
-        // This is a fence sync created after MEC was initialized. Ignore it.
-        return;
-    }
-
-    // In this case, the app is deleting a fence sync we started with, we need to regen on loop.
-    mFenceSyncsToRegen.insert(sync);
-}
-
 void ResourceTracker::setGennedBuffer(gl::BufferID id)
 {
     if (mStartingBuffers.find(id) == mStartingBuffers.end())

src/libANGLE/capture/FrameCapture.h

@@ -213,9 +213,6 @@ using BufferCalls = std::map<gl::BufferID, std::vector<CallCapture>>;
 // true means mapped, false means unmapped
 using BufferMapStatusMap = std::map<gl::BufferID, bool>;
 
-using FenceSyncSet   = std::set<GLsync>;
-using FenceSyncCalls = std::map<GLsync, std::vector<CallCapture>>;
-
 // Helper to track resource changes during the capture
 class ResourceTracker final : angle::NonCopyable
 {
@@ -261,11 +258,6 @@ class ResourceTracker final : angle::NonCopyable
     void onShaderProgramAccess(gl::ShaderProgramID shaderProgramID);
     uint32_t getMaxShaderPrograms() const { return mMaxShaderPrograms; }
 
-    FenceSyncSet &getStartingFenceSyncs() { return mStartingFenceSyncs; }
-    FenceSyncCalls &getFenceSyncRegenCalls() { return mFenceSyncRegenCalls; }
-    FenceSyncSet &getFenceSyncsToRegen() { return mFenceSyncsToRegen; }
-    void setDeletedFenceSync(GLsync sync);
-
   private:
     // Buffer regen calls will delete and gen a buffer
     BufferCalls mBufferRegenCalls;
@@ -295,14 +287,6 @@ class ResourceTracker final : angle::NonCopyable
 
     // Maximum accessed shader program ID.
     uint32_t mMaxShaderPrograms = 0;
-
-    // Fence sync objects created during MEC setup
-    FenceSyncSet mStartingFenceSyncs;
-    // Fence sync regen calls will create a fence sync objects
-    FenceSyncCalls mFenceSyncRegenCalls;
-    // Fence syncs to regen are a list of starting fence sync objects that were deleted and need to
-    // be regen'ed.
-    FenceSyncSet mFenceSyncsToRegen;
 };
 
 // Used by the CPP replay to filter out unnecessary code.
@@ -377,10 +361,6 @@ class FrameCapture final : angle::NonCopyable
                            ReplayContext *replayContext,
                            const CallCapture &call);
 
-    void setCaptureActive() { mCaptureActive = true; }
-    void setCaptureInactive() { mCaptureActive = false; }
-    bool isCaptureActive() { return mCaptureActive; }
-
     std::vector<CallCapture> mSetupCalls;
     std::vector<CallCapture> mFrameCalls;
 
@@ -411,8 +391,6 @@ class FrameCapture final : angle::NonCopyable
     // Initialize it to the number of frames you want to capture, and then clear the value to 0 when
     // you reach the content you want to capture. Currently only available on Android.
     uint32_t mCaptureTrigger;
-
-    bool mCaptureActive = false;
 };
 
 // Shared class for any items that need to be tracked by FrameCapture across shared contexts