Use raw pointers for the plugin factory

Since the object cleans up after itself after the smart pointers are
dropped on the host side this would result in a use after free by the
smart pointers.

src/plugin/bridges/vst3.cpp

@@ -86,10 +86,10 @@ Vst3PluginBridge::Vst3PluginBridge()
 Steinberg::IPluginFactory* Vst3PluginBridge::get_plugin_factory() {
     // Even though we're working with raw pointers here, we should pretend that
     // we're `IPtr<Steinberg::IPluginFactory>` and do the reference counting
-    // ourselves because you can't always safely pass those around The VST3
-    // interface can't pass smart pointers around because of binary
-    // compatibility, so we'll have to do the reference counting by hand like in
-    // the implementation in `public.sdk/source/main/pluginfactory.h`.
+    // ourselves. This should work the same was as the standard implementation
+    // in `public.sdk/source/main/pluginfactory.h`. If we were to use an IPtr or
+    // an STL smart pointer we would get a double free (or rather, a use after
+    // free).
     if (plugin_factory) {
         plugin_factory->addRef();
     } else {
@@ -97,11 +97,11 @@ Steinberg::IPluginFactory* Vst3PluginBridge::get_plugin_factory() {
         // will request after loading the module. Host callback handlers should
         // have started before this since the Wine plugin host will request a
         // copy of the configuration during its initialization.
-        plugin_factory = Steinberg::owned(new YaPluginFactoryPluginImpl(*this));
+        plugin_factory = new YaPluginFactoryPluginImpl(*this);
         sockets.host_vst_control.receive_into(
             WantsPluginFactory{}, *plugin_factory,
             std::pair<Vst3Logger&, bool>(logger, true));
     }
 
-    return plugin_factory.get();
+    return plugin_factory;
 }

src/plugin/bridges/vst3.h

@@ -80,11 +80,11 @@ class Vst3PluginBridge : PluginBridge<Vst3Sockets<std::jthread>> {
      * Our plugin factory. All information about the plugin and its supported
      * classes are copied directly from the Windows VST3 plugin's factory on the
      * Wine side, and we'll provide an implementation that can send control
-     * messages to the Wine plugin host. The VST3 interface only passes raw
-     * pointers around and the receiving side should then use `IPtr<T>::adopt()`
-     * or `owned()` to get back the orignal smart pointer.
+     * messages to the Wine plugin host. As explained in `get_plugin_factory()`,
+     * this cannot be a smart pointer because the factory is supposed to free
+     * itself when the host removes its last adopted `IPtr<IpluginFactory>`.
      *
      * @related get_plugin_factory
      */
-    Steinberg::IPtr<YaPluginFactory> plugin_factory;
+    YaPluginFactory* plugin_factory;
 };

src/plugin/vst3-plugin.cpp

@@ -38,9 +38,6 @@ bool InitModule() {
     assert(bridge == nullptr);
 
     try {
-        // This is the only place where we have to use manual memory management.
-        // The bridge's destructor is called when the `effClose` opcode is
-        // received.
         bridge = new Vst3PluginBridge();
 
         return true;