Add a separate ServiceManager implementation.

src/com/dmdirc/Main.java

     private final Set<CommandDetails> commands;
     /** Mode alias reporter to use. */
     private final ModeAliasReporter reporter;
+    private final ServiceManager serviceManager;
 
     /**
      * Creates a new instance of {@link Main}.
             final Set<Migrator> migrators,
             final DMDircMBassador eventBus,
             final Set<CommandDetails> commands,
-            final ModeAliasReporter reporter) {
+            final ModeAliasReporter reporter,
+            final ServiceManager serviceManager) {
         this.identityManager = identityManager;
         this.connectionManager = connectionManager;
         this.commandLineParser = commandLineParser;
         this.eventBus = eventBus;
         this.commands = commands;
         this.reporter = reporter;
+        this.serviceManager = serviceManager;
     }
 
     /**
         migrators.stream().filter(Migrator::needsMigration).forEach(Migrator::migrate);
         commands.forEach(c -> commandManager.registerCommand(c.getCommand(), c.getInfo()));
 
-        loadUIs(pluginManager);
+        loadUIs(serviceManager);
 
         doFirstRun();
 

src/com/dmdirc/ParserFactory.java

 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.parser.interfaces.ProtocolDescription;
 import com.dmdirc.plugins.NoSuchProviderException;
-import com.dmdirc.plugins.PluginManager;
 import com.dmdirc.plugins.Service;
+import com.dmdirc.plugins.ServiceManager;
 import com.dmdirc.plugins.ServiceProvider;
 
 import java.net.URI;
     /** The name of the server domain. */
     private static final String DOMAIN_SERVER = "server";
 
-    /** PluginManager used by this ParserFactory */
-    private final PluginManager pluginManager;
+    /** ServiceManager used by this ParserFactory */
+    private final ServiceManager serviceManager;
     /** The event bus to post events to. */
     private final DMDircMBassador eventBus;
 
     /**
      * Creates a new instance of {@link ParserFactory}.
-     *
-     * @param pluginManager The plugin manager used by this factory.
-     * @param eventBus      The event bus to post events to.
      */
     @Inject
     public ParserFactory(
-            final PluginManager pluginManager,
+            final ServiceManager serviceManager,
             final DMDircMBassador eventBus) {
-        this.pluginManager = pluginManager;
+        this.serviceManager = serviceManager;
         this.eventBus = eventBus;
     }
 
         final String scheme = address.getScheme() == null ? "irc" : address.getScheme();
 
         try {
-            final Service service = pluginManager.getService("parser", scheme);
+            final Service service = serviceManager.getService("parser", scheme);
 
             if (service != null && !service.getProviders().isEmpty()) {
                 final ServiceProvider provider = service.getProviders().get(0);

src/com/dmdirc/commandparser/commands/global/NewServer.java

 import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.Connection;
 import com.dmdirc.interfaces.ConnectionFactory;
-import com.dmdirc.plugins.PluginManager;
+import com.dmdirc.plugins.ServiceManager;
 import com.dmdirc.ui.input.AdditionalTabTargets;
 import com.dmdirc.util.InvalidURIException;
 import com.dmdirc.util.URIParser;
             CommandType.TYPE_GLOBAL);
     /** The factory to use to construct servers. */
     private final ConnectionFactory connectionFactory;
-    /** Plugin manager to query for available services. */
-    private final PluginManager pluginManager;
+    /** Service manager to query for available services. */
+    private final ServiceManager serviceManager;
     /** Manager to use to find profiles. */
     private final ProfileManager profileManager;
     /** The parser to use for user input. */
 
     /**
      * Creates a new newserver command which will use the specified factory to construct servers.
-     *
-     * @param controller         The controller to use for command information.
-     * @param connectionFactory      The factory to use to construct servers.
-     * @param pluginManager      The plugin manager to use to query available services.
-     * @param profileManager     Manager to use to find profiles.
-     * @param uriParser          The parser to use for user input.
      */
     @Inject
     public NewServer(
             final CommandController controller,
             final ConnectionFactory connectionFactory,
-            final PluginManager pluginManager,
+            final ServiceManager serviceManager,
             final ProfileManager profileManager,
             final URIParser uriParser) {
         super(controller);
         this.connectionFactory = connectionFactory;
-        this.pluginManager = pluginManager;
+        this.serviceManager = serviceManager;
         this.profileManager = profileManager;
         this.uriParser = uriParser;
     }
         final AdditionalTabTargets res = new AdditionalTabTargets();
 
         if (arg == 0) {
-            res.addAll(pluginManager.getServicesByType("parser").stream()
+            res.addAll(serviceManager.getServicesByType("parser").stream()
                     .map(parserType -> parserType.getName() + "://").collect(Collectors.toList()));
         }
         res.excludeAll();

src/com/dmdirc/config/prefs/PreferencesDialogModel.java

 import com.dmdirc.events.ClientPrefsOpenedEvent;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.config.ConfigProvider;
-import com.dmdirc.plugins.PluginManager;
 import com.dmdirc.plugins.Service;
+import com.dmdirc.plugins.ServiceManager;
 import com.dmdirc.util.collections.ListenerList;
 import com.dmdirc.util.validators.NumericalValidator;
 import com.dmdirc.util.validators.OptionalValidator;
     private final AggregateConfigProvider configManager;
     /** Identity to write settings to. */
     private final ConfigProvider identity;
-    /** Plugin manager. */
-    private final PluginManager pluginManager;
+    /** Service manager. */
+    private final ServiceManager serviceManager;
     /** Event bus to post events on. */
     private final DMDircMBassador eventBus;
 
     /**
      * Creates a new instance of PreferencesDialogModel.
-     *
-     * @param pluginPanel     UI specific plugin panel
-     * @param themePanel      UI specific theme panel
-     * @param updatesPanel    UI specific updates panel
-     * @param urlHandlerPanel UI specific URL panel
-     * @param configManager   Config manager to read settings from
-     * @param identity        Identity to write settings to
-     * @param pluginManager   Plugin manager to retrieve plugins from
-     * @param eventBus        Event bus to post events on
      */
     @Inject
     public PreferencesDialogModel(final PreferencesInterface pluginPanel,
             final PreferencesInterface urlHandlerPanel,
             final AggregateConfigProvider configManager,
             final ConfigProvider identity,
-            final PluginManager pluginManager,
+            final ServiceManager serviceManager,
             final DMDircMBassador eventBus) {
         this.pluginPanel = pluginPanel;
         this.themePanel = themePanel;
         this.urlHandlerPanel = urlHandlerPanel;
         this.configManager = configManager;
         this.identity = identity;
-        this.pluginManager = pluginManager;
+        this.serviceManager = serviceManager;
         this.eventBus = eventBus;
 
         addDefaultCategories();
         final PreferencesCategory category = new PreferencesCategory("Tab Completion", "");
         final Map<String, String> taboptions = new HashMap<>();
 
-        for (Service service : pluginManager.getServicesByType("tabcompletion")) {
+        for (Service service : serviceManager.getServicesByType("tabcompletion")) {
             taboptions.put(service.getName(), service.getName());
         }
 

src/com/dmdirc/plugins/CorePluginHelper.java

 @Singleton
 public class CorePluginHelper {
 
+    private final ServiceManager serviceManager;
+
     @Inject
-    public CorePluginHelper() {
+    public CorePluginHelper(final ServiceManager serviceManager) {
+        this.serviceManager = serviceManager;
     }
 
     /**
             final CorePluginExtractor corePluginExtractor,
             final PluginManager pm,
             final String serviceType) {
-        if (pm.getServicesByType(serviceType).isEmpty()) {
+        if (serviceManager.getServicesByType(serviceType).isEmpty()) {
             corePluginExtractor.extractCorePlugins(serviceType + "_");
             pm.refreshPlugins();
         }

src/com/dmdirc/plugins/PluginInfo.java

     private final PluginMetaData metaData;
     /** The manager to use to look up other plugins. */
     private final PluginManager pluginManager;
+    /** The manager to register services with. */
+    private final ServiceManager serviceManager;
     /** The initialiser to use for the injector. */
     private final Provider<PluginInjectorInitialiser> injectorInitialiser;
     /** The object graph to pass to plugins for DI purposes. */
      */
     public PluginInfo(
             final PluginManager pluginManager,
+            final ServiceManager serviceManager,
             final String pluginDirectory,
             final PluginMetaData metadata,
             final Provider<PluginInjectorInitialiser> injectorInitialiser,
             final IdentityController identityController,
             final ObjectGraph objectGraph) throws PluginException {
         this.pluginManager = pluginManager;
+        this.serviceManager = serviceManager;
         this.injectorInitialiser = injectorInitialiser;
         this.objectGraph = objectGraph;
         this.eventBus = eventBus;
                 final String type = bits.length > 1 ? bits[1] : "misc";
 
                 if (!"any".equalsIgnoreCase(name) && !"export".equalsIgnoreCase(type)) {
-                    final Service service = pluginManager.getService(type, name, true);
+                    final Service service = serviceManager.getService(type, name, true);
                     synchronized (provides) {
                         service.addProvider(this);
                         provides.add(service);
                 Service best = null;
                 boolean found = false;
 
-                for (Service service : pluginManager.getServicesByType(parts[1])) {
+                for (Service service : serviceManager.getServicesByType(parts[1])) {
                     if (service.isActive()) {
                         found = true;
                         break;
                     return false;
                 }
             } else {
-                final Service service = pluginManager.getService(parts[1], parts[0]);
+                final Service service = serviceManager.getService(parts[1], parts[0]);
 
                 if (service == null || !service.activate()) {
                     return false;
                 final String serviceName = bits.length > 4 ? bits[4] : bits[0];
 
                 // Add a provides for this
-                final Service service = pluginManager.getService("export", serviceName, true);
+                final Service service = serviceManager.getService("export", serviceName, true);
                 synchronized (provides) {
                     service.addProvider(this);
                     provides.add(service);

src/com/dmdirc/plugins/PluginManager.java

 /**
  * Searches for and manages plugins and services.
  */
-public class PluginManager implements ServiceManager {
+public class PluginManager {
 
     /** List of known plugins' file names to their corresponding {@link PluginInfo} objects. */
     private final Map<String, PluginInfo> knownPlugins = new HashMap<>();
     private final UpdateManager updateManager;
     /** A provider of initialisers for plugin injectors. */
     private final Provider<PluginInjectorInitialiser> initialiserProvider;
-    /** Map of services. */
-    private final Map<String, Map<String, Service>> services = new HashMap<>();
     /** Global ClassLoader used by plugins from this manager. */
     private final GlobalClassLoader globalClassLoader;
     /** The graph to pass to plugins for DI purposes. */
     private final ObjectGraph objectGraph;
     /** Event bus to pass to plugin info for plugin loaded events. */
     private final DMDircMBassador eventBus;
+    /** The service manager to use. */
+    private final ServiceManager serviceManager;
 
     /**
      * Creates a new instance of PluginManager.
      */
     public PluginManager(
             final DMDircMBassador eventBus,
+            final ServiceManager serviceManager,
             final IdentityController identityController,
             final UpdateManager updateManager,
             final Provider<PluginInjectorInitialiser> initialiserProvider,
             final ObjectGraph objectGraph,
             final String directory) {
         this.identityController = identityController;
+        this.serviceManager = serviceManager;
         this.updateManager = updateManager;
         this.initialiserProvider = initialiserProvider;
         this.directory = directory;
         return globalClassLoader;
     }
 
-    @Override
-    public Service getService(final String type, final String name) {
-        return getService(type, name, false);
-    }
-
-    @Override
-    public Service getService(final String type, final String name, final boolean create) {
-        // Find the type first
-        if (services.containsKey(type)) {
-            final Map<String, Service> map = services.get(type);
-            // Now the name
-            if (map.containsKey(name)) {
-                return map.get(name);
-            } else if (create) {
-                final Service service = new Service(type, name);
-                map.put(name, service);
-                return service;
-            }
-        } else if (create) {
-            final Map<String, Service> map = new HashMap<>();
-            final Service service = new Service(type, name);
-            map.put(name, service);
-            services.put(type, map);
-            return service;
-        }
-
-        return null;
-    }
-
-    @Override
-    public ServiceProvider getServiceProvider(final String type, final String name) throws
-            NoSuchProviderException {
-        final Service service = getService(type, name);
-        if (service != null) {
-            ServiceProvider provider = service.getActiveProvider();
-            if (provider != null) {
-                return provider;
-            } else {
-                // Try to activate the service then try again.
-                service.activate();
-                provider = service.getActiveProvider();
-                if (provider != null) {
-                    return provider;
-                }
-            }
-        }
-
-        throw new NoSuchProviderException("No provider found for: " + type + "->" + name);
-    }
-
-    @Override
-    public ServiceProvider getServiceProvider(final String type, final List<String> names,
-            final boolean fallback) throws NoSuchProviderException {
-        for (final String name : names) {
-            final ServiceProvider provider = getServiceProvider(type, name);
-            if (provider != null) {
-                return provider;
-            }
-        }
-
-        if (fallback) {
-            final List<Service> servicesType = getServicesByType(type);
-            if (!servicesType.isEmpty()) {
-                final Service service = servicesType.get(0);
-                return getServiceProvider(type, service.getName());
-            }
-        }
-
-        throw new NoSuchProviderException("No provider found for " + type + "from the given list");
-    }
-
-    @Override
-    public ExportedService getExportedService(final String name) {
-        return getServiceProvider("export", name).getExportedService(name);
-    }
-
-    @Override
-    public List<Service> getServicesByType(final String type) {
-        // Find the type first
-        if (services.containsKey(type)) {
-            final Map<String, Service> map = services.get(type);
-            return new ArrayList<>(map.values());
-        }
-
-        return new ArrayList<>();
-    }
-
-    @Override
-    public List<Service> getAllServices() {
-        // Find the type first
-        final List<Service> allServices = new ArrayList<>();
-        for (Map<String, Service> map : services.values()) {
-            allServices.addAll(map.values());
-        }
-
-        return allServices;
-    }
-
     /**
      * Autoloads plugins.
      */
                             + "!/META-INF/plugin.config"),
                     Paths.get(directory, filename));
             metadata.load();
-            final PluginInfo pluginInfo = new PluginInfo(this, directory, metadata,
+            final PluginInfo pluginInfo = new PluginInfo(this, serviceManager, directory, metadata,
                     initialiserProvider, eventBus,
                     identityController, objectGraph);
             final PluginInfo existing = getPluginInfoByName(metadata.getName());

src/com/dmdirc/plugins/PluginModule.java

             final UpdateManager updateManager,
             final Provider<PluginInjectorInitialiser> initialiserProvider,
             final ObjectGraph objectGraph,
+            final ServiceManager serviceManager,
             final CorePluginHelper pluginHelper,
             @Directory(DirectoryType.PLUGINS) final String directory) {
-        final PluginManager manager = new PluginManager(eventBus, identityController,
-                updateManager, initialiserProvider, objectGraph, directory);
+        final PluginManager manager = new PluginManager(eventBus, serviceManager,
+                identityController, updateManager, initialiserProvider, objectGraph, directory);
         final CorePluginExtractor extractor = new CorePluginExtractor(manager, directory, eventBus);
         pluginHelper.checkBundledPlugins(extractor, manager,
                 identityController.getGlobalConfiguration());
     }
 
     @Provides
-    public ServiceManager getServiceManager(final PluginManager pluginManager) {
-        return pluginManager;
+    public ServiceManager getServiceManager(final ServiceManagerImpl serviceManager) {
+        return serviceManager;
     }
 
     @Provides

src/com/dmdirc/plugins/ServiceManagerImpl.java

+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.plugins;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+/**
+ * Implementation of {@link ServiceManager}.
+ */
+@Singleton
+public class ServiceManagerImpl implements ServiceManager {
+
+    /** Map of services. */
+    private final Map<String, Map<String, Service>> services = new HashMap<>();
+
+    @Inject
+    public ServiceManagerImpl() {
+    }
+
+    @Override
+    public Service getService(final String type, final String name) {
+        return getService(type, name, false);
+    }
+
+    @Override
+    public Service getService(final String type, final String name, final boolean create) {
+        // Find the type first
+        if (services.containsKey(type)) {
+            final Map<String, Service> map = services.get(type);
+            // Now the name
+            if (map.containsKey(name)) {
+                return map.get(name);
+            } else if (create) {
+                final Service service = new Service(type, name);
+                map.put(name, service);
+                return service;
+            }
+        } else if (create) {
+            final Map<String, Service> map = new HashMap<>();
+            final Service service = new Service(type, name);
+            map.put(name, service);
+            services.put(type, map);
+            return service;
+        }
+
+        return null;
+    }
+
+    @Override
+    public ServiceProvider getServiceProvider(final String type, final String name) throws
+            NoSuchProviderException {
+        final Service service = getService(type, name);
+        if (service != null) {
+            ServiceProvider provider = service.getActiveProvider();
+            if (provider != null) {
+                return provider;
+            } else {
+                // Try to activate the service then try again.
+                service.activate();
+                provider = service.getActiveProvider();
+                if (provider != null) {
+                    return provider;
+                }
+            }
+        }
+
+        throw new NoSuchProviderException("No provider found for: " + type + "->" + name);
+    }
+
+    @Override
+    public ServiceProvider getServiceProvider(final String type, final List<String> names,
+            final boolean fallback) throws NoSuchProviderException {
+        for (final String name : names) {
+            final ServiceProvider provider = getServiceProvider(type, name);
+            if (provider != null) {
+                return provider;
+            }
+        }
+
+        if (fallback) {
+            final List<Service> servicesType = getServicesByType(type);
+            if (!servicesType.isEmpty()) {
+                final Service service = servicesType.get(0);
+                return getServiceProvider(type, service.getName());
+            }
+        }
+
+        throw new NoSuchProviderException("No provider found for " + type + "from the given list");
+    }
+
+    @Override
+    public ExportedService getExportedService(final String name) {
+        return getServiceProvider("export", name).getExportedService(name);
+    }
+
+    @Override
+    public List<Service> getServicesByType(final String type) {
+        // Find the type first
+        if (services.containsKey(type)) {
+            final Map<String, Service> map = services.get(type);
+            return new ArrayList<>(map.values());
+        }
+
+        return new ArrayList<>();
+    }
+
+    @Override
+    public List<Service> getAllServices() {
+        // Find the type first
+        final List<Service> allServices = new ArrayList<>();
+        for (Map<String, Service> map : services.values()) {
+            allServices.addAll(map.values());
+        }
+
+        return allServices;
+    }
+
+}

test/com/dmdirc/commandparser/commands/global/NewServerTest.java

 import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.Connection;
 import com.dmdirc.interfaces.ConnectionFactory;
-import com.dmdirc.plugins.PluginManager;
+import com.dmdirc.plugins.ServiceManager;
 import com.dmdirc.util.URIParser;
 
 import java.net.URI;
     @Mock private ProfileManager profileManager;
     @Mock private Profile identity;
     @Mock private FrameContainer container;
-    @Mock private PluginManager pluginManager;
+    @Mock private ServiceManager serviceManager;
     @Mock private ConnectionFactory factory;
     @Mock private Connection connection;
     private NewServer command;
         when(factory.createServer(any(URI.class), any(Profile.class))).thenReturn(connection);
         when(profileManager.getProfiles()).thenReturn(
                 Collections.singletonList(identity));
-        command = new NewServer(controller, factory, pluginManager, profileManager, new URIParser());
+        command = new NewServer(controller, factory, serviceManager, profileManager, new URIParser());
     }
 
     @Test

test/com/dmdirc/config/prefs/PreferencesDialogModelTest.java

 import com.dmdirc.events.ClientPrefsClosedEvent;
 import com.dmdirc.events.ClientPrefsOpenedEvent;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
-import com.dmdirc.plugins.PluginManager;
 import com.dmdirc.plugins.Service;
+import com.dmdirc.plugins.ServiceManager;
 
 import java.util.ArrayList;
 import java.util.List;
 public class PreferencesDialogModelTest {
 
     @Mock private DMDircMBassador eventBus;
-    @Mock private PluginManager pluginManager;
+    @Mock private ServiceManager serviceManager;
 
     @Before
     public void setup() {
         when(tabcompleter.getName()).thenReturn("tabber");
         services.add(tabcompleter);
 
-        when(pluginManager.getServicesByType("tabcompletion")).thenReturn(services);
+        when(serviceManager.getServicesByType("tabcompletion")).thenReturn(services);
     }
 
     @Test
         final AggregateConfigProvider cm = mock(AggregateConfigProvider.class);
         when(cm.getOption("domain", "option")).thenReturn("fallback");
         final PreferencesDialogModel pm = new PreferencesDialogModel(null, null,
-                null, null, cm, null, pluginManager, eventBus);
+                null, null, cm, null, serviceManager, eventBus);
         assertNotNull(pm.getCategory("General"));
         assertNotNull(pm.getCategory("Connection"));
         assertNotNull(pm.getCategory("Messages"));
         when(cm.getOption("domain", "option")).thenReturn("fallback");
         final PreferencesCategory category = mock(PreferencesCategory.class);
         final PreferencesDialogModel pm = new PreferencesDialogModel(null, null,
-                null, null, cm, null, pluginManager, eventBus);
+                null, null, cm, null, serviceManager, eventBus);
         pm.addCategory(category);
         pm.dismiss();
 
         when(cm.getOption("domain", "option")).thenReturn("fallback");
 
         final PreferencesDialogModel pm = new PreferencesDialogModel(null, null,
-                null, null, cm, null, pluginManager, eventBus);
+                null, null, cm, null, serviceManager, eventBus);
         pm.addCategory(category);
         assertFalse(pm.save());
 
         when(cm.getOption("domain", "option")).thenReturn("fallback");
 
         final PreferencesDialogModel pm = new PreferencesDialogModel(null, null,
-                null, null, cm, null, pluginManager, eventBus);
+                null, null, cm, null, serviceManager, eventBus);
         pm.addCategory(category);
         assertTrue(pm.save());
 
         when(cm.getOption("domain", "option")).thenReturn("fallback");
 
         final PreferencesDialogModel pm = new PreferencesDialogModel(null, null,
-                null, null, cm, null, pluginManager, eventBus);
+                null, null, cm, null, serviceManager, eventBus);
         assertNull(pm.getCategory("unittest123"));
     }
 
         when(cm.getOption("domain", "option")).thenReturn("fallback");
 
         final PreferencesDialogModel pm = new PreferencesDialogModel(null, null,
-                null, null, cm, null, pluginManager, eventBus);
+                null, null, cm, null, serviceManager, eventBus);
         assertNotNull(pm.getCategories());
         assertFalse(pm.getCategories().isEmpty());
 
         when(cm.getOption("domain", "option")).thenReturn("fallback");
 
         final PreferencesDialogModel pm = new PreferencesDialogModel(null, null,
-                null, null, cm, null, pluginManager, eventBus);
+                null, null, cm, null, serviceManager, eventBus);
         final PreferencesInterface tpi = mock(PreferencesInterface.class);
 
         pm.registerSaveListener(tpi);
         final AggregateConfigProvider cm = mock(AggregateConfigProvider.class);
         when(cm.getOption("domain", "option")).thenReturn("fallback");
 
-        new PreferencesDialogModel(null, null, null, null, cm, null, pluginManager, eventBus);
+        new PreferencesDialogModel(null, null, null, null, cm, null, serviceManager, eventBus);
 
         verify(eventBus).publish(isA(ClientPrefsOpenedEvent.class));
     }
         final AggregateConfigProvider cm = mock(AggregateConfigProvider.class);
         when(cm.getOption("domain", "option")).thenReturn("fallback");
         final PreferencesDialogModel pm = new PreferencesDialogModel(null, null,
-                null, null, cm, null, pluginManager, eventBus);
+                null, null, cm, null, serviceManager, eventBus);
         pm.close();
 
         verify(eventBus).publishAsync(isA(ClientPrefsClosedEvent.class));
         when(cm.getOption("domain", "option")).thenReturn("fallback");
 
         final PreferencesDialogModel pm = new PreferencesDialogModel(null, null,
-                null, null, cm, null, pluginManager, eventBus);
+                null, null, cm, null, serviceManager, eventBus);
         final PreferencesCategory category = mock(PreferencesCategory.class);
         final PreferencesInterface tpi = mock(PreferencesInterface.class);
         when(category.hasObject()).thenReturn(true);