[audioplugins] re-validate rediscovered plugins instead of trusting Missing

scanPlugins marked a vanished plugin Missing regardless of its prior state,
and a later rediscovery flipped it straight to Validated. A plugin that was
Error before going Missing - or one whose binary changed to a broken build
while away - would thus be trusted without re-validation.

Route a reappeared (formerly Missing) path back through newPluginPaths so the
out-of-process validation re-derives Validated/Error, mirroring the Discovered
(interrupted-scan) handling. Drops the rediscoveredPluginIds list and the blind
setPluginsState(..., Validated) step. Adds scanPlugins classification tests.

Author: luapmartin

framework/audioplugins/internal/registeraudiopluginsscenario.cpp

@@ -89,11 +89,16 @@ PluginScanResult RegisterAudioPluginsScenario::scanPlugins(Progress* progress) c
                 continue;
             }
 
-            // Every formerly Missing ID under this path is rediscovered.
-            for (const CacheEntry& entry : entries) {
-                if (entry.state == AudioPluginState::Missing) {
-                    result.rediscoveredPluginIds.push_back(entry.id);
-                }
+            // A path we previously marked Missing is back. Re-validate it
+            // out-of-process rather than trusting the cache — the binary may now
+            // be a newer build that no longer passes validation. Mirrors the
+            // Discovered handling above.
+            const bool hasMissing = std::any_of(entries.cbegin(), entries.cend(),
+                                                [](const CacheEntry& e) {
+                return e.state == AudioPluginState::Missing;
+            });
+            if (hasMissing) {
+                result.newPluginPaths.push_back(path);
             }
             registered.erase(it);
         }
@@ -124,12 +129,6 @@ Ret RegisterAudioPluginsScenario::updatePluginsRegistry()
         return ret;
     }
 
-    ret = knownPluginsRegister()->setPluginsState(result.rediscoveredPluginIds, AudioPluginState::Validated);
-    if (!ret) {
-        LOGE() << "Failed to mark rediscovered plugins: " << ret.toString();
-        return ret;
-    }
-
     ret = registerNewPlugins(result.newPluginPaths, /*validate*/ true);
     if (!ret) {
         LOGE() << "Failed to register new plugins: " << ret.toString();

framework/audioplugins/iregisteraudiopluginsscenario.h

@@ -31,9 +31,11 @@
 
 namespace muse::audioplugins {
 struct PluginScanResult {
-    io::paths_t newPluginPaths;            // not in cache; will be inserted via subprocess validation
+    // not in cache, or a previously Missing entry the scanner found again: both
+    // get (re-)validated via subprocess. A returned plugin is re-validated rather
+    // than trusted, since the binary on disk may now be a newer, broken build.
+    io::paths_t newPluginPaths;
     PluginResourceIdList missingPluginIds;  // in cache but not currently found by any scanner
-    PluginResourceIdList rediscoveredPluginIds; // previously Missing entries the scanner found again
 };
 
 class IRegisterAudioPluginsScenario : MODULE_CONTEXT_INTERFACE

framework/audioplugins/tests/registeraudiopluginsscenariotest.cpp

@@ -297,9 +297,6 @@ TEST_F(AudioPlugins_RegisterAudioPluginsScenarioTest, UpdatePluginsRegistry_Mark
     EXPECT_CALL(*m_knownPlugins, setPluginsState(uninstalledPluginIdList, AudioPluginState::Missing))
     .WillOnce(Return(make_ok()));
 
-    EXPECT_CALL(*m_knownPlugins, setPluginsState(PluginResourceIdList {}, AudioPluginState::Validated))
-    .WillOnce(Return(make_ok()));
-
     EXPECT_CALL(*m_knownPlugins, unregisterPlugins(_))
     .Times(0);
 
@@ -313,7 +310,7 @@ TEST_F(AudioPlugins_RegisterAudioPluginsScenarioTest, UpdatePluginsRegistry_Mark
     EXPECT_TRUE(ret);
 }
 
-TEST_F(AudioPlugins_RegisterAudioPluginsScenarioTest, UpdatePluginsRegistry_RediscoverFormerlyMissing)
+TEST_F(AudioPlugins_RegisterAudioPluginsScenarioTest, ScanPlugins_FormerlyMissingFoundAgainIsRevalidated)
 {
     auto createPluginInfo = [](const io::path_t& path, AudioPluginState state) {
         AudioPluginInfo info;
@@ -324,7 +321,7 @@ TEST_F(AudioPlugins_RegisterAudioPluginsScenarioTest, UpdatePluginsRegistry_Redi
         return info;
     };
 
-    // [GIVEN] One Missing entry that gets reinstalled, one untouched Validated entry
+    // [GIVEN] One Missing entry that reappears, one untouched Validated entry
     AudioPluginInfoList knownPlugins;
     knownPlugins.push_back(createPluginInfo("/some/path/AAA.vst3", AudioPluginState::Missing));
     knownPlugins.push_back(createPluginInfo("/some/path/BBB.vst3", AudioPluginState::Validated));
@@ -346,20 +343,16 @@ TEST_F(AudioPlugins_RegisterAudioPluginsScenarioTest, UpdatePluginsRegistry_Redi
         .WillByDefault(Return(foundPluginPaths));
     }
 
-    // [THEN] Only AAA gets transitioned back to Validated
-    PluginResourceIdList rediscoveredIds { knownPlugins[0].meta.id };
-
-    EXPECT_CALL(*m_knownPlugins, setPluginsState(PluginResourceIdList {}, AudioPluginState::Missing))
-    .WillOnce(Return(make_ok()));
-
-    EXPECT_CALL(*m_knownPlugins, setPluginsState(rediscoveredIds, AudioPluginState::Validated))
-    .WillOnce(Return(make_ok()));
-
-    EXPECT_CALL(*m_knownPlugins, load())
-    .WillOnce(Return(muse::make_ok()));
+    // [WHEN] Scanning
+    const PluginScanResult result = m_scenario->scanPlugins();
 
-    Ret ret = m_scenario->updatePluginsRegistry();
-    EXPECT_TRUE(ret);
+    // [THEN] The reappeared Missing plugin is queued for out-of-process
+    // re-validation rather than trusted straight back to Validated — its binary
+    // may now be a newer build that no longer passes validation. The untouched
+    // Validated plugin is left alone.
+    EXPECT_TRUE(muse::contains(result.newPluginPaths, path_t("/some/path/AAA.vst3")));
+    EXPECT_FALSE(muse::contains(result.newPluginPaths, path_t("/some/path/BBB.vst3")));
+    EXPECT_TRUE(result.missingPluginIds.empty());
 }
 
 TEST_F(AudioPlugins_RegisterAudioPluginsScenarioTest, UpdatePluginsRegistry_MultiPluginBinaryMarksEveryIdMissing)
@@ -403,8 +396,6 @@ TEST_F(AudioPlugins_RegisterAudioPluginsScenarioTest, UpdatePluginsRegistry_Mult
 
     EXPECT_CALL(*m_knownPlugins, setPluginsState(expectedMissing, AudioPluginState::Missing))
     .WillOnce(Return(make_ok()));
-    EXPECT_CALL(*m_knownPlugins, setPluginsState(PluginResourceIdList {}, AudioPluginState::Validated))
-    .WillOnce(Return(make_ok()));
 
     EXPECT_CALL(*m_knownPlugins, load())
     .WillOnce(Return(make_ok()));
@@ -413,7 +404,7 @@ TEST_F(AudioPlugins_RegisterAudioPluginsScenarioTest, UpdatePluginsRegistry_Mult
     EXPECT_TRUE(ret);
 }
 
-TEST_F(AudioPlugins_RegisterAudioPluginsScenarioTest, UpdatePluginsRegistry_MultiPluginBinaryRediscoversEveryId)
+TEST_F(AudioPlugins_RegisterAudioPluginsScenarioTest, ScanPlugins_FormerlyMissingMultiIdBinaryQueuedOnce)
 {
     auto createPluginInfo = [](const io::path_t& path, const PluginResourceId& id, AudioPluginState state) {
         AudioPluginInfo info;
@@ -445,19 +436,14 @@ TEST_F(AudioPlugins_RegisterAudioPluginsScenarioTest, UpdatePluginsRegistry_Mult
         .WillByDefault(Return(foundPluginPaths));
     }
 
-    // [THEN] BOTH ids transition back to Validated — not just the last one.
-    PluginResourceIdList expectedRediscovered { "Shell FxA", "Shell FxB" };
-
-    EXPECT_CALL(*m_knownPlugins, setPluginsState(PluginResourceIdList {}, AudioPluginState::Missing))
-    .WillOnce(Return(make_ok()));
-    EXPECT_CALL(*m_knownPlugins, setPluginsState(expectedRediscovered, AudioPluginState::Validated))
-    .WillOnce(Return(make_ok()));
+    // [WHEN] Scanning
+    const PluginScanResult result = m_scenario->scanPlugins();
 
-    EXPECT_CALL(*m_knownPlugins, load())
-    .WillOnce(Return(make_ok()));
-
-    Ret ret = m_scenario->updatePluginsRegistry();
-    EXPECT_TRUE(ret);
+    // [THEN] The reappeared binary is queued once for re-validation; the
+    // subprocess re-derives each id's state. Nothing is trusted back to
+    // Validated, and nothing is left Missing.
+    EXPECT_EQ(result.newPluginPaths, paths_t { shellPath });
+    EXPECT_TRUE(result.missingPluginIds.empty());
 }
 
 TEST_F(AudioPlugins_RegisterAudioPluginsScenarioTest, UpdatePluginsRegistry_LeftoverDiscoveredRevalidates)
@@ -491,12 +477,9 @@ TEST_F(AudioPlugins_RegisterAudioPluginsScenarioTest, UpdatePluginsRegistry_Left
 
     // [THEN] The Discovered path is treated as new — registered as a fresh
     // placeholder and re-validated via subprocess. It is NOT marked Missing
-    // (it's still on disk) and it is NOT considered "rediscovered" (that's
-    // for paths transitioning out of Missing).
+    // (it's still on disk).
     EXPECT_CALL(*m_knownPlugins, setPluginsState(PluginResourceIdList {}, AudioPluginState::Missing))
     .WillOnce(Return(make_ok()));
-    EXPECT_CALL(*m_knownPlugins, setPluginsState(PluginResourceIdList {}, AudioPluginState::Validated))
-    .WillOnce(Return(make_ok()));
 
     // [THEN] registerNewPlugins writes a Discovered placeholder for the path
     // before spawning the subprocess.