make sanitizer happy

include/class_loader/class_loader_core.hpp

@@ -282,6 +282,23 @@ registerPlugin(const std::string & class_name, const std::string & base_class_na
           break;
         }
       }
+
+      BaseToFactoryMapMap & factory_map_map = getGlobalPluginBaseToFactoryMapMap();
+      bool erase_flag = false;
+      for (auto & factory_map_item : factory_map_map) {
+        FactoryMap & factory_map = factory_map_item.second;
+        for (auto iter = factory_map.begin(); iter != factory_map.end(); ++iter) {
+          if (iter->second == p) {
+            factory_map.erase(iter);
+            erase_flag = true;
+            break;
+          }
+        }
+        if (erase_flag) {
+          break;
+        }
+      }
+
       getPluginBaseToFactoryMapMapMutex().unlock();
 
 #ifndef _WIN32

src/class_loader.cpp

@@ -117,10 +117,10 @@ int ClassLoader::unloadLibrary()
 
 int ClassLoader::unloadLibraryInternal(bool lock_plugin_ref_count)
 {
-  std::lock_guard<std::recursive_mutex> load_ref_lock(load_ref_count_mutex_);
   if (lock_plugin_ref_count) {
     plugin_ref_count_mutex_.lock();
   }
+  std::lock_guard<std::recursive_mutex> load_ref_lock(load_ref_count_mutex_);
 
   try {
     if (plugin_ref_count_ > 0) {

src/class_loader_core.cpp

@@ -521,9 +521,12 @@ void unloadLibrary(const std::string & library_path, ClassLoader * loader)
         throw class_loader::LibraryUnloadException(
                 "Could not unload library (rcpputils exception = " + std::string(e.what()) + ")");
       }
+    } else {
+      CONSOLE_BRIDGE_logDebug(
+        "class_loader.impl: "
+        "Attempt to unload library %s that class_loader is unaware of or is already unloaded",
+        library_path.c_str());
     }
-    throw class_loader::LibraryUnloadException(
-            "Attempt to unload library that class_loader is unaware of.");
   }
 }
 

src/multi_library_class_loader.cpp

@@ -37,14 +37,47 @@
 namespace class_loader
 {
 
+typedef std::vector<std::shared_ptr<class_loader::ClassLoader>> ClassLoaderPtrVector;
+
+class ClassLoaderDependency
+{
+protected:
+  ClassLoaderDependency()
+  {
+    // make the static variable in `ClassLoader` destroyed after `class_loader_ptrs_`,
+    // which is a member of ClassLoaderPtrVectorImpl defined as a static instance in the
+    // `getClassLoaderPtrVectorImpl`
+    class_loader::impl::getLoadedLibraryVectorMutex();
+    class_loader::impl::getPluginBaseToFactoryMapMapMutex();
+    class_loader::impl::getGlobalPluginBaseToFactoryMapMap();
+    class_loader::impl::getMetaObjectGraveyard();
+    class_loader::impl::getLoadedLibraryVector();
+    class_loader::impl::getCurrentlyLoadingLibraryName();
+    class_loader::impl::getCurrentlyActiveClassLoader();
+    class_loader::impl::hasANonPurePluginLibraryBeenOpened();
+  }
+};
+
+class ClassLoaderPtrVectorImpl : public ClassLoaderDependency
+{
+public:
+  ClassLoaderPtrVector class_loader_ptrs_;
+  std::mutex loader_mutex_;
+};
+
 class MultiLibraryClassLoaderImpl
 {
 public:
   bool enable_ondemand_loadunload_;
   LibraryToClassLoaderMap active_class_loaders_;
-  std::mutex loader_mutex_;
 };
 
+ClassLoaderPtrVectorImpl & getClassLoaderPtrVectorImpl()
+{
+  static ClassLoaderPtrVectorImpl instance;
+  return instance;
+}
+
 MultiLibraryClassLoader::MultiLibraryClassLoader(bool enable_ondemand_loadunload)
 : impl_(new MultiLibraryClassLoaderImpl())
 {
@@ -92,8 +125,12 @@ bool MultiLibraryClassLoader::isLibraryAvailable(const std::string & library_nam
 void MultiLibraryClassLoader::loadLibrary(const std::string & library_path)
 {
   if (!isLibraryAvailable(library_path)) {
+    std::lock_guard<std::mutex> lock(getClassLoaderPtrVectorImpl().loader_mutex_);
+    getClassLoaderPtrVectorImpl().class_loader_ptrs_.emplace_back(
+      std::make_shared<class_loader::ClassLoader>(library_path, isOnDemandLoadUnloadEnabled())
+    );
     impl_->active_class_loaders_[library_path] =
-      new class_loader::ClassLoader(library_path, isOnDemandLoadUnloadEnabled());
+      getClassLoaderPtrVectorImpl().class_loader_ptrs_.back().get();
   }
 }
 
@@ -112,7 +149,14 @@ int MultiLibraryClassLoader::unloadLibrary(const std::string & library_path)
     remaining_unloads = loader->unloadLibrary();
     if (remaining_unloads == 0) {
       impl_->active_class_loaders_[library_path] = nullptr;
-      delete (loader);
+      std::lock_guard<std::mutex> lock(getClassLoaderPtrVectorImpl().loader_mutex_);
+      auto & class_loader_ptrs = getClassLoaderPtrVectorImpl().class_loader_ptrs_;
+      for (auto iter = class_loader_ptrs.begin(); iter != class_loader_ptrs.end(); ++iter) {
+        if (iter->get() == loader) {
+          class_loader_ptrs.erase(iter);
+          break;
+        }
+      }
     }
   }
   return remaining_unloads;

test/unique_ptr_test.cpp

@@ -94,9 +94,6 @@ TEST(ClassLoaderUniquePtrTest, basicLoadFailures) {
   EXPECT_THROW(
     class_loader::impl::loadLibrary("LIBRARY_1", &loader1),
     class_loader::LibraryLoadException);
-  EXPECT_THROW(
-    class_loader::impl::unloadLibrary("LIBRARY_1", &loader1),
-    class_loader::LibraryUnloadException);
 }
 
 TEST(ClassLoaderUniquePtrTest, MultiLibraryClassLoaderFailures) {

test/utest.cpp

@@ -121,9 +121,6 @@ TEST(ClassLoaderUniquePtrTest, basicLoadFailures) {
   EXPECT_THROW(
     class_loader::impl::loadLibrary("LIBRARY_1", &loader1),
     class_loader::LibraryLoadException);
-  EXPECT_THROW(
-    class_loader::impl::unloadLibrary("LIBRARY_1", &loader1),
-    class_loader::LibraryUnloadException);
 }
 
 TEST(ClassLoaderUniquePtrTest, MultiLibraryClassLoaderFailures) {