Merge lp:~jonas-drange/ubuntu-settings-components/printerbackend into lp:~phablet-team/ubuntu-settings-components/printer-components

[Jonas G. Drange]

* Rewrites Printer, PrinterJob, PrinterModel to all use a new backend.
* Adds new backend that bridges PDF and Cups implementations.
* Drops PIMPL idiom since we're not going to export C++ headers anyway.
* Drops most bridge patterns in classes that are now implementation details (QPrinterInfo, CupsFacade).
* Tries to deal with some RAII issues.

[lp:~jonas-drange/ubuntu-settings-components/printerbackend]

220. By Jonas G. Drange on 2017-01-22

improves RAII story

[Andrew Hayzen (ahayzen)]

Seems the ColorModelType in PrinterJob was broken in a previous branch.

Could you update PrinterJob::getColorModel() to this http://pastebin.ubuntu.com/23851653/ otherwise I've found that the ColorModeType remains UnknownType.

Other than this, I've not found any other regressions in the printing-app yet.

review: Needs Fixing

[Andrew Hayzen (ahayzen)]

3 minor inline comments from QtCreator

1x Q_ENUMS had a trailing semi-colon
2x Q_SLOT instead of Q_SLOTS

review: Needs Fixing

[lp:~jonas-drange/ubuntu-settings-components/printerbackend]

221. By Jonas G. Drange on 2017-01-23

addresses all of Andrew's comments

[Andrew Hayzen (ahayzen)]

LGTM, fixes the issues I was having. As discussed we may split up the PrinterBackend later, but it is fine for now.

review: Approve

=== modified file 'examples/Printers.qml'
--- examples/Printers.qml	2017-01-20 12:08:00 +0000
+++ examples/Printers.qml	2017-01-23 14:09:24 +0000
@@ -159,7 +159,7 @@
             ListView {
                 id: printerList
                 anchors { fill: parent }
-                model: Printers.allPrinters
+                model: Printers.allPrintersWithPdf
                 delegate: ListItem {
                     height: modelLayout.height + (divider.visible ? divider.height : 0)
                     ListItemLayout {

=== modified file 'plugins/Ubuntu/Settings/Printers/CMakeLists.txt'
--- plugins/Ubuntu/Settings/Printers/CMakeLists.txt	2017-01-19 17:59:17 +0000
+++ plugins/Ubuntu/Settings/Printers/CMakeLists.txt	2017-01-23 14:09:24 +0000
@@ -9,15 +9,14 @@
 find_package(Qt5Qml REQUIRED)
 
 add_library(UbuntuSettingsPrintersQml SHARED
+    backend/backend.cpp
+    backend/backend_cups.cpp
+    backend/backend_pdf.cpp
+    cups/cupsfacade.cpp
+    cups/cupspkhelper.cpp
     enums.h
-    cups/cupsfacade.h
-    cups/cupsfacade_impl.cpp
-    cups/cupspkhelper.cpp
     models/printermodel.cpp
     printer/printer.cpp
-    printer/printerinfo_allimpl.cpp
-    printer/printerinfo_pdfimpl.cpp
-    printer/printerinfo_impl.cpp
     printer/printerjob.cpp
     printers/printers.cpp
     plugin.cpp

=== added directory 'plugins/Ubuntu/Settings/Printers/backend'
=== added file 'plugins/Ubuntu/Settings/Printers/backend/backend.cpp'
--- plugins/Ubuntu/Settings/Printers/backend/backend.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend.cpp	2017-01-23 14:09:24 +0000
@@ -0,0 +1,291 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "backend/backend.h"
+
+PrinterBackend::PrinterBackend(QObject *parent)
+    : QObject(parent)
+{
+}
+
+PrinterBackend::PrinterBackend(const QString &printerName, QObject *parent)
+    : QObject(parent)
+    , m_printerName(printerName)
+{
+}
+
+PrinterBackend::~PrinterBackend()
+{
+}
+
+bool PrinterBackend::holdsDefinition() const
+{
+    return false;
+}
+
+QString PrinterBackend::printerAdd(const QString &name,
+                                   const QUrl &uri,
+                                   const QUrl &ppdFile,
+                                   const QString &info,
+                                   const QString &location)
+{
+    return QString();
+}
+
+QString PrinterBackend::printerAddWithPpd(const QString &name,
+                                          const QUrl &uri,
+                                          const QString &ppdFileName,
+                                          const QString &info,
+                                          const QString &location)
+{
+    return QString();
+}
+
+QString PrinterBackend::printerDelete(const QString &name)
+{
+    return QString();
+}
+
+QString PrinterBackend::printerSetEnabled(const QString &name,
+                                          const bool enabled)
+{
+    return QString();
+}
+
+QString PrinterBackend::printerSetAcceptJobs(
+    const QString &name,
+    const bool enabled,
+    const QString &reason)
+{
+    return QString();
+}
+
+QString PrinterBackend::printerSetInfo(const QString &name,
+                                       const QString &info)
+{
+    return QString();
+}
+
+QString PrinterBackend::printerSetLocation(const QString &name,
+                                           const QString &location)
+{
+    return QString();
+}
+
+QString PrinterBackend::printerSetShared(const QString &name,
+                                         const bool shared)
+{
+    return QString();
+}
+
+QString PrinterBackend::printerSetJobSheets(const QString &name,
+                                            const QString &start,
+                                            const QString &end)
+{
+    return QString();
+}
+
+QString PrinterBackend::printerSetErrorPolicy(const QString &name,
+                                              const PrinterEnum::ErrorPolicy &policy)
+{
+    return QString();
+}
+
+
+QString PrinterBackend::printerSetOpPolicy(const QString &name,
+                                           const PrinterEnum::OperationPolicy &policy)
+{
+    return QString();
+}
+
+QString PrinterBackend::printerSetUsersAllowed(const QString &name,
+                                               const QStringList &users)
+{
+    return QString();
+}
+
+QString PrinterBackend::printerSetUsersDenied(const QString &name,
+                                              const QStringList &users)
+{
+    return QString();
+}
+
+QString PrinterBackend::printerAddOptionDefault(const QString &name,
+                                                const QString &option,
+                                                const QStringList &values)
+{
+    return QString();
+}
+
+QString PrinterBackend::printerDeleteOptionDefault(const QString &name,
+                                                   const QString &value)
+{
+    return QString();
+}
+
+QString PrinterBackend::printerAddOption(const QString &name,
+                                         const QString &option,
+                                         const QStringList &values)
+{
+    return QString();
+}
+
+QVariant PrinterBackend::printerGetOption(const QString &name,
+                                          const QString &option) const
+{
+    return QVariant();
+}
+
+QMap<QString, QVariant> PrinterBackend::printerGetOptions(
+    const QString &name, const QStringList &options
+)
+{
+    return QMap<QString, QVariant>();
+}
+
+// FIXME: maybe have a PrinterDest iface that has a CupsDest impl?
+cups_dest_t* PrinterBackend::makeDest(const QString &name,
+                              const PrinterJob *options)
+{
+    return Q_NULLPTR;
+}
+
+QList<ColorModel> PrinterBackend::printerGetSupportedColorModels(
+    const QString &name) const
+{
+    return QList<ColorModel>();
+}
+
+ColorModel PrinterBackend::printerGetDefaultColorModel(
+    const QString &name) const
+{
+    Q_UNUSED(name);
+    return ColorModel();
+}
+
+QList<PrintQuality> PrinterBackend::printerGetSupportedQualities(
+    const QString &name) const
+{
+    return QList<PrintQuality>();
+}
+
+PrintQuality PrinterBackend::printerGetDefaultQuality(
+        const QString &name) const
+{
+    Q_UNUSED(name);
+    return PrintQuality();
+}
+
+int PrinterBackend::printFileToDest(const QString &filepath,
+                            const QString &title,
+                            const cups_dest_t *dest)
+{
+    return -1;
+}
+
+QString PrinterBackend::printerName() const
+{
+    return QString();
+}
+
+QString PrinterBackend::description() const
+{
+    return QString();
+}
+
+QString PrinterBackend::location() const
+{
+    return QString();
+}
+
+QString PrinterBackend::makeAndModel() const
+{
+    return QString();
+}
+
+PrinterEnum::State PrinterBackend::state() const
+{
+    return PrinterEnum::State::IdleState;
+}
+
+QList<QPageSize> PrinterBackend::supportedPageSizes() const
+{
+    return QList<QPageSize>();
+}
+
+QPageSize PrinterBackend::defaultPageSize() const
+{
+
+}
+
+bool PrinterBackend::supportsCustomPageSizes() const
+{
+    return false;
+}
+
+QPageSize PrinterBackend::minimumPhysicalPageSize() const
+{
+    return QPageSize();
+}
+
+QPageSize PrinterBackend::maximumPhysicalPageSize() const
+{
+    return QPageSize();
+}
+
+QList<int> PrinterBackend::supportedResolutions() const
+{
+    return QList<int>();
+}
+
+PrinterEnum::DuplexMode PrinterBackend::defaultDuplexMode() const
+{
+    return PrinterEnum::DuplexMode::DuplexNone;
+}
+
+QList<PrinterEnum::DuplexMode> PrinterBackend::supportedDuplexModes() const
+{
+    return QList<PrinterEnum::DuplexMode>();
+}
+
+QList<Printer*> PrinterBackend::availablePrinters()
+{
+    return QList<Printer*>();
+}
+
+QStringList PrinterBackend::availablePrinterNames()
+{
+    return QStringList();
+}
+
+Printer* PrinterBackend::getPrinter(const QString &printerName)
+{
+    return Q_NULLPTR;
+}
+
+QString PrinterBackend::defaultPrinterName()
+{
+    return QString();
+}
+
+PrinterBackend::BackendType PrinterBackend::backendType() const
+{
+    return BackendType::DefaultType;
+}
+
+void PrinterBackend::refresh()
+{
+}

=== added file 'plugins/Ubuntu/Settings/Printers/backend/backend.h'
--- plugins/Ubuntu/Settings/Printers/backend/backend.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend.h	2017-01-23 14:09:24 +0000
@@ -0,0 +1,153 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef USC_PRINTERS_BACKEND_H
+#define USC_PRINTERS_BACKEND_H
+
+#include "printer/printer.h"
+#include "printer/printerjob.h"
+
+// TODO: remove cups specific things from this API
+#include <cups/cups.h>
+
+#include <QObject>
+#include <QPageSize>
+#include <QList>
+#include <QString>
+#include <QStringList>
+
+class Printer;
+class PrinterJob;
+class PRINTERS_DECL_EXPORT PrinterBackend : public QObject
+{
+    Q_OBJECT
+public:
+    explicit PrinterBackend(QObject *parent = Q_NULLPTR);
+    explicit PrinterBackend(const QString &printerName,
+                            QObject *parent = Q_NULLPTR);
+    virtual ~PrinterBackend();
+
+    enum class BackendType
+    {
+        DefaultType = 0,
+        CupsType,
+        PdfType,
+    };
+    Q_ENUM(BackendType)
+
+    virtual bool holdsDefinition() const;
+
+    virtual QString printerAdd(const QString &name,
+                               const QUrl &uri,
+                               const QUrl &ppdFile,
+                               const QString &info,
+                               const QString &location);
+    virtual QString printerAddWithPpd(const QString &name,
+                                      const QUrl &uri,
+                                      const QString &ppdFileName,
+                                      const QString &info,
+                                      const QString &location);
+    virtual QString printerDelete(const QString &name);
+    virtual QString printerSetEnabled(const QString &name,
+                                      const bool enabled);
+    virtual QString printerSetAcceptJobs(
+        const QString &name,
+        const bool enabled,
+        const QString &reason = QString::null);
+    virtual QString printerSetInfo(const QString &name,
+                                   const QString &info);
+    virtual QString printerSetLocation(const QString &name,
+                                       const QString &location);
+    virtual QString printerSetShared(const QString &name,
+                                     const bool shared);
+    virtual QString printerSetJobSheets(const QString &name,
+                                        const QString &start,
+                                        const QString &end);
+    virtual QString printerSetErrorPolicy(const QString &name,
+                                          const PrinterEnum::ErrorPolicy &policy);
+
+    virtual QString printerSetOpPolicy(const QString &name,
+                                       const PrinterEnum::OperationPolicy &policy);
+    virtual QString printerSetUsersAllowed(const QString &name,
+                                           const QStringList &users);
+    virtual QString printerSetUsersDenied(const QString &name,
+                                          const QStringList &users);
+    virtual QString printerAddOptionDefault(const QString &name,
+                                            const QString &option,
+                                            const QStringList &values);
+    virtual QString printerDeleteOptionDefault(const QString &name,
+                                               const QString &value);
+    virtual QString printerAddOption(const QString &name,
+                                     const QString &option,
+                                     const QStringList &values);
+
+    // TODO: const for both these getters (if possible)!
+    virtual QVariant printerGetOption(const QString &name,
+                                      const QString &option) const;
+    virtual QMap<QString, QVariant> printerGetOptions(
+        const QString &name, const QStringList &options
+    );
+    // FIXME: maybe have a PrinterDest iface that has a CupsDest impl?
+    virtual cups_dest_t* makeDest(const QString &name,
+                                  const PrinterJob *options);
+
+    virtual QList<ColorModel> printerGetSupportedColorModels(
+        const QString &name) const;
+    virtual ColorModel printerGetDefaultColorModel(const QString &name) const;
+    virtual QList<PrintQuality> printerGetSupportedQualities(
+        const QString &name) const;
+    virtual PrintQuality printerGetDefaultQuality(const QString &name) const;
+    virtual int printFileToDest(const QString &filepath,
+                                const QString &title,
+                                const cups_dest_t *dest);
+
+    virtual QString printerName() const;
+    virtual QString description() const;
+    virtual QString location() const;
+    virtual QString makeAndModel() const;
+
+    virtual PrinterEnum::State state() const;
+    virtual QList<QPageSize> supportedPageSizes() const;
+    virtual QPageSize defaultPageSize() const;
+    virtual bool supportsCustomPageSizes() const;
+
+    virtual QPageSize minimumPhysicalPageSize() const;
+    virtual QPageSize maximumPhysicalPageSize() const;
+    virtual QList<int> supportedResolutions() const;
+    virtual PrinterEnum::DuplexMode defaultDuplexMode() const;
+    virtual QList<PrinterEnum::DuplexMode> supportedDuplexModes() const;
+
+    virtual QList<Printer*> availablePrinters();
+    virtual QStringList availablePrinterNames();
+    virtual Printer* getPrinter(const QString &printerName);
+    virtual QString defaultPrinterName();
+
+    virtual BackendType backendType() const;
+
+public Q_SLOTS:
+    virtual void refresh();
+
+Q_SIGNALS:
+    void printerAdded(const QString &name);
+    void printerModified(const QString &name, const bool ppdChanged);
+    void printerDeleted(const QString &name);
+    void printerStateChanged(const QString &name);
+
+protected:
+    const QString m_printerName;
+};
+
+#endif // USC_PRINTERS_BACKEND_H

=== added file 'plugins/Ubuntu/Settings/Printers/backend/backend_cups.cpp'
--- plugins/Ubuntu/Settings/Printers/backend/backend_cups.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend_cups.cpp	2017-01-23 14:09:24 +0000
@@ -0,0 +1,317 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "backend/backend_cups.h"
+#include "backend/backend_pdf.h"
+#include "utils.h"
+
+#include <exception>
+#include <stdexcept>
+
+PrinterCupsBackend::PrinterCupsBackend(QObject *parent)
+    : PrinterCupsBackend(new CupsFacade(), QPrinterInfo(), parent)
+{
+    // If we create the CupsFacade, we're in charge of RAII.
+    m_cups->setParent(this);
+}
+
+PrinterCupsBackend::PrinterCupsBackend(CupsFacade *cups, QPrinterInfo info,
+                                       QObject *parent)
+    : PrinterBackend(info.printerName(), parent)
+    , m_cups(cups)
+    , m_info(info)
+{
+}
+
+PrinterCupsBackend::~PrinterCupsBackend()
+{
+
+}
+
+QString PrinterCupsBackend::printerAdd(const QString &name,
+                                       const QUrl &uri,
+                                       const QUrl &ppdFile,
+                                       const QString &info,
+                                       const QString &location)
+{
+
+}
+
+QString PrinterCupsBackend::printerAddWithPpd(const QString &name,
+                                              const QUrl &uri,
+                                              const QString &ppdFileName,
+                                              const QString &info,
+                                              const QString &location)
+{
+
+}
+
+bool PrinterCupsBackend::holdsDefinition() const
+{
+    return !m_info.isNull();
+}
+
+QString PrinterCupsBackend::printerDelete(const QString &name)
+{
+
+}
+
+QString PrinterCupsBackend::printerSetEnabled(const QString &name,
+                                              const bool enabled)
+{
+
+}
+
+QString PrinterCupsBackend::printerSetAcceptJobs(
+        const QString &name,
+        const bool enabled,
+        const QString &reason)
+{
+
+}
+
+QString PrinterCupsBackend::printerSetInfo(const QString &name,
+                                           const QString &info)
+{
+    return m_cups->printerSetInfo(name, info);
+}
+
+QString PrinterCupsBackend::printerSetLocation(const QString &name,
+                                               const QString &location)
+{
+    return m_cups->printerSetLocation(name, location);
+}
+
+QString PrinterCupsBackend::printerSetShared(const QString &name,
+                                             const bool shared)
+{
+    return m_cups->printerSetShared(name, shared);
+}
+
+QString PrinterCupsBackend::printerSetJobSheets(const QString &name,
+                                                const QString &start,
+                                                const QString &end)
+{
+    return m_cups->printerSetJobSheets(name, start, end);
+}
+
+QString PrinterCupsBackend::printerSetErrorPolicy(const QString &name,
+                                                  const PrinterEnum::ErrorPolicy &policy)
+{
+    return m_cups->printerSetErrorPolicy(name, policy);
+}
+
+QString PrinterCupsBackend::printerSetOpPolicy(const QString &name,
+                                               const PrinterEnum::OperationPolicy &policy)
+{
+    return m_cups->printerSetOpPolicy(name, policy);
+}
+
+QString PrinterCupsBackend::printerSetUsersAllowed(const QString &name,
+                                                   const QStringList &users)
+{
+    return m_cups->printerSetUsersAllowed(name, users);
+}
+
+QString PrinterCupsBackend::printerSetUsersDenied(const QString &name,
+                                                  const QStringList &users)
+{
+    return m_cups->printerSetUsersDenied(name, users);
+}
+
+QString PrinterCupsBackend::printerAddOptionDefault(const QString &name,
+                                                    const QString &option,
+                                                    const QStringList &values)
+{
+    return m_cups->printerAddOptionDefault(name, option, values);
+}
+
+QString PrinterCupsBackend::printerDeleteOptionDefault(const QString &name,
+                                                       const QString &value)
+{
+    return m_cups->printerDeleteOptionDefault(name, value);
+}
+
+QString PrinterCupsBackend::printerAddOption(const QString &name,
+                                             const QString &option,
+                                             const QStringList &values)
+{
+    return m_cups->printerAddOption(name, option, values);
+}
+
+    // TODO: const for both these getters (if possible)!
+QVariant PrinterCupsBackend::printerGetOption(const QString &name,
+                                              const QString &option) const
+{
+    return m_cups->printerGetOption(name, option);
+}
+QMap<QString, QVariant> PrinterCupsBackend::printerGetOptions(
+        const QString &name, const QStringList &options)
+{
+    return m_cups->printerGetOptions(name, options);
+}
+
+// FIXME: maybe have a PrinterDest iface that has a CupsDest impl?
+cups_dest_t* PrinterCupsBackend::makeDest(const QString &name,
+                                          const PrinterJob *options)
+{
+    return m_cups->makeDest(name, options);
+}
+
+QList<ColorModel> PrinterCupsBackend::printerGetSupportedColorModels(
+        const QString &name) const
+{
+    return m_cups->printerGetSupportedColorModels(name);
+}
+
+ColorModel PrinterCupsBackend::printerGetDefaultColorModel(
+    const QString &name) const
+{
+    return printerGetOption(name, "DefaultColorModel").value<ColorModel>();
+}
+
+QList<PrintQuality> PrinterCupsBackend::printerGetSupportedQualities(
+        const QString &name) const
+{
+    return m_cups->printerGetSupportedQualities(name);
+}
+
+PrintQuality PrinterCupsBackend::printerGetDefaultQuality(
+        const QString &name) const
+{
+    return printerGetOption(name, "DefaultPrintQuality").value<PrintQuality>();
+}
+
+int PrinterCupsBackend::printFileToDest(const QString &filepath,
+                                        const QString &title,
+                                        const cups_dest_t *dest)
+{
+    return m_cups->printFileToDest(filepath, title, dest);
+}
+
+QString PrinterCupsBackend::printerName() const
+{
+    return m_info.printerName();
+}
+
+QString PrinterCupsBackend::description() const
+{
+    return m_info.description();
+}
+
+QString PrinterCupsBackend::location() const
+{
+
+}
+
+QString PrinterCupsBackend::makeAndModel() const
+{
+
+}
+
+PrinterEnum::State PrinterCupsBackend::state() const
+{
+
+}
+
+QList<QPageSize> PrinterCupsBackend::supportedPageSizes() const
+{
+    return m_info.supportedPageSizes();
+}
+
+QPageSize PrinterCupsBackend::defaultPageSize() const
+{
+    return m_info.defaultPageSize();
+}
+
+bool PrinterCupsBackend::supportsCustomPageSizes() const
+{
+
+}
+
+QPageSize PrinterCupsBackend::minimumPhysicalPageSize() const
+{
+
+}
+
+QPageSize PrinterCupsBackend::maximumPhysicalPageSize() const
+{
+
+}
+
+QList<int> PrinterCupsBackend::supportedResolutions() const
+{
+
+}
+
+PrinterEnum::DuplexMode PrinterCupsBackend::defaultDuplexMode() const
+{
+    return Utils::qDuplexModeToDuplexMode(m_info.defaultDuplexMode());
+}
+
+QList<PrinterEnum::DuplexMode> PrinterCupsBackend::supportedDuplexModes() const
+{
+    QList<PrinterEnum::DuplexMode> list;
+    Q_FOREACH(const QPrinter::DuplexMode mode, m_info.supportedDuplexModes()) {
+        if (mode != QPrinter::DuplexAuto) {
+            list.append(Utils::qDuplexModeToDuplexMode(mode));
+        }
+    }
+    return list;
+}
+
+QList<Printer*> PrinterCupsBackend::availablePrinters()
+{
+    QList<Printer*> list;
+    Q_FOREACH(QPrinterInfo info, QPrinterInfo::availablePrinters()) {
+        list.append(new Printer(new PrinterCupsBackend(m_cups, info)));
+    }
+
+    // Cups allows a faux PDF printer.
+    // TODO: Translate.
+    list.append(new Printer(new PrinterPdfBackend("Create PDF")));
+
+    return list;
+}
+
+QStringList PrinterCupsBackend::availablePrinterNames()
+{
+    return QPrinterInfo::availablePrinterNames();
+}
+
+Printer* PrinterCupsBackend::getPrinter(const QString &printerName)
+{
+
+}
+
+QString PrinterCupsBackend::defaultPrinterName()
+{
+    return QPrinterInfo::defaultPrinterName();
+}
+
+PrinterBackend::BackendType PrinterCupsBackend::backendType() const
+{
+    return PrinterBackend::BackendType::CupsType;
+}
+
+void PrinterCupsBackend::refresh()
+{
+    if (m_printerName.isEmpty()) {
+        throw std::invalid_argument("Trying to refresh unnamed printer.");
+    } else {
+        m_info = QPrinterInfo::printerInfo(m_printerName);
+    }
+}

=== added file 'plugins/Ubuntu/Settings/Printers/backend/backend_cups.h'
--- plugins/Ubuntu/Settings/Printers/backend/backend_cups.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend_cups.h	2017-01-23 14:09:24 +0000
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef USC_PRINTERS_CUPS_BACKEND_H
+#define USC_PRINTERS_CUPS_BACKEND_H
+
+#include "backend/backend.h"
+#include "cups/cupsfacade.h"
+
+#include <QPrinterInfo>
+
+class PRINTERS_DECL_EXPORT PrinterCupsBackend : public PrinterBackend
+{
+public:
+    explicit PrinterCupsBackend(QObject *parent = Q_NULLPTR);
+    explicit PrinterCupsBackend(CupsFacade *cups, QPrinterInfo info,
+                                QObject *parent = Q_NULLPTR);
+    virtual ~PrinterCupsBackend() override;
+
+    virtual bool holdsDefinition() const override;
+
+    virtual QString printerAdd(const QString &name,
+                               const QUrl &uri,
+                               const QUrl &ppdFile,
+                               const QString &info,
+                               const QString &location) override;
+    virtual QString printerAddWithPpd(const QString &name,
+                                      const QUrl &uri,
+                                      const QString &ppdFileName,
+                                      const QString &info,
+                                      const QString &location) override;
+    virtual QString printerDelete(const QString &name) override;
+    virtual QString printerSetEnabled(const QString &name,
+                                      const bool enabled) override;
+    virtual QString printerSetAcceptJobs(
+        const QString &name,
+        const bool enabled,
+        const QString &reason = QString::null) override;
+    virtual QString printerSetInfo(const QString &name,
+                                   const QString &info) override;
+    virtual QString printerSetLocation(const QString &name,
+                                       const QString &location) override;
+    virtual QString printerSetShared(const QString &name,
+                                     const bool shared) override;
+    virtual QString printerSetJobSheets(const QString &name,
+                                        const QString &start,
+                                        const QString &end) override;
+    virtual QString printerSetErrorPolicy(const QString &name,
+                                          const PrinterEnum::ErrorPolicy &policy) override;
+
+    virtual QString printerSetOpPolicy(const QString &name,
+                                       const PrinterEnum::OperationPolicy &policy) override;
+    virtual QString printerSetUsersAllowed(const QString &name,
+                                           const QStringList &users) override;
+    virtual QString printerSetUsersDenied(const QString &name,
+                                          const QStringList &users) override;
+    virtual QString printerAddOptionDefault(const QString &name,
+                                            const QString &option,
+                                            const QStringList &values) override;
+    virtual QString printerDeleteOptionDefault(const QString &name,
+                                               const QString &value) override;
+    virtual QString printerAddOption(const QString &name,
+                                     const QString &option,
+                                     const QStringList &values) override;
+
+    // TODO: const for both these getters (if possible)!
+    virtual QVariant printerGetOption(const QString &name,
+                                      const QString &option) const override;
+    virtual QMap<QString, QVariant> printerGetOptions(
+        const QString &name, const QStringList &options
+    ) override;
+    // FIXME: maybe have a PrinterDest iface that has a CupsDest impl?
+    virtual cups_dest_t* makeDest(const QString &name,
+                                  const PrinterJob *options) override;
+
+    virtual QList<ColorModel> printerGetSupportedColorModels(
+        const QString &name) const override;
+    virtual ColorModel printerGetDefaultColorModel(const QString &name) const;
+    virtual QList<PrintQuality> printerGetSupportedQualities(
+        const QString &name) const override;
+    virtual PrintQuality printerGetDefaultQuality(const QString &name) const;
+    virtual int printFileToDest(const QString &filepath,
+                                const QString &title,
+                                const cups_dest_t *dest) override;
+
+    virtual QString printerName() const override;
+    virtual QString description() const override;
+    virtual QString location() const override;
+    virtual QString makeAndModel() const override;
+
+    virtual PrinterEnum::State state() const override;
+    virtual QList<QPageSize> supportedPageSizes() const override;
+    virtual QPageSize defaultPageSize() const override;
+    virtual bool supportsCustomPageSizes() const override;
+
+    virtual QPageSize minimumPhysicalPageSize() const override;
+    virtual QPageSize maximumPhysicalPageSize() const override;
+    virtual QList<int> supportedResolutions() const override;
+    virtual PrinterEnum::DuplexMode defaultDuplexMode() const override;
+    virtual QList<PrinterEnum::DuplexMode> supportedDuplexModes() const override;
+
+    virtual QList<Printer*> availablePrinters() override;
+    virtual QStringList availablePrinterNames() override;
+    virtual Printer* getPrinter(const QString &printerName) override;
+    virtual QString defaultPrinterName() override;
+
+    virtual PrinterBackend::BackendType backendType() const override;
+
+public Q_SLOTS:
+    virtual void refresh() override;
+
+private:
+    CupsFacade *m_cups;
+    QPrinterInfo m_info;
+};
+
+#endif // USC_PRINTERS_CUPS_BACKEND_H

=== added file 'plugins/Ubuntu/Settings/Printers/backend/backend_pdf.cpp'
--- plugins/Ubuntu/Settings/Printers/backend/backend_pdf.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend_pdf.cpp	2017-01-23 14:09:24 +0000
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "backend/backend_pdf.h"
+
+PrinterPdfBackend::PrinterPdfBackend(const QString &printerName,
+                                     QObject *parent)
+    : PrinterBackend(printerName, parent)
+{
+}
+
+QList<ColorModel> PrinterPdfBackend::printerGetSupportedColorModels(
+    const QString &name) const
+{
+    return QList<ColorModel>{printerGetDefaultColorModel(name)};
+}
+
+ColorModel PrinterPdfBackend::printerGetDefaultColorModel(
+    const QString &name) const
+{
+    Q_UNUSED(name);
+    ColorModel rgb;
+    rgb.colorType = PrinterEnum::ColorModelType::ColorType;
+    rgb.name = "RGB";
+    rgb.text = "Color"; // TODO: translate
+    return rgb;
+}
+
+QList<PrintQuality> PrinterPdfBackend::printerGetSupportedQualities(
+    const QString &name) const
+{
+    return QList<PrintQuality>({printerGetDefaultQuality(name)});
+}
+
+PrintQuality PrinterPdfBackend::printerGetDefaultQuality(
+        const QString &name) const
+{
+    Q_UNUSED(name);
+    return PrintQuality();
+}
+
+QString PrinterPdfBackend::printerName() const
+{
+    return m_printerName;
+}
+
+QString PrinterPdfBackend::description() const
+{
+    return QStringLiteral("");
+}
+
+QString PrinterPdfBackend::location() const
+{
+    return QStringLiteral("");
+}
+
+QString PrinterPdfBackend::makeAndModel() const
+{
+    return QStringLiteral("");
+}
+
+PrinterEnum::State PrinterPdfBackend::state() const
+{
+    return PrinterEnum::State::IdleState;
+}
+
+QList<QPageSize> PrinterPdfBackend::supportedPageSizes() const
+{
+    return QList<QPageSize>{QPageSize(QPageSize::A4)};
+}
+
+QPageSize PrinterPdfBackend::defaultPageSize() const
+{
+    return QPageSize(QPageSize::A4);
+}
+
+bool PrinterPdfBackend::supportsCustomPageSizes() const
+{
+    return false;
+}
+
+
+QPageSize PrinterPdfBackend::minimumPhysicalPageSize() const
+{
+    return QPageSize(QPageSize::A4);
+}
+
+QPageSize PrinterPdfBackend::maximumPhysicalPageSize() const
+{
+    return QPageSize(QPageSize::A4);
+}
+
+QList<int> PrinterPdfBackend::supportedResolutions() const
+{
+
+}
+
+PrinterEnum::DuplexMode PrinterPdfBackend::defaultDuplexMode() const
+{
+    return PrinterEnum::DuplexMode::DuplexNone;
+}
+
+QList<PrinterEnum::DuplexMode> PrinterPdfBackend::supportedDuplexModes() const
+{
+    return QList<PrinterEnum::DuplexMode>{PrinterEnum::DuplexMode::DuplexNone};
+}
+
+PrinterBackend::BackendType PrinterPdfBackend::backendType() const
+{
+    return PrinterBackend::BackendType::PdfType;
+}

=== added file 'plugins/Ubuntu/Settings/Printers/backend/backend_pdf.h'
--- plugins/Ubuntu/Settings/Printers/backend/backend_pdf.h	1970-01-01 00:00:00 +0000
+++ plugins/Ubuntu/Settings/Printers/backend/backend_pdf.h	2017-01-23 14:09:24 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef USC_PRINTERS_PDF_BACKEND_H
+#define USC_PRINTERS_PDF_BACKEND_H
+
+#include "backend/backend.h"
+
+class PRINTERS_DECL_EXPORT PrinterPdfBackend : public PrinterBackend
+{
+public:
+    explicit PrinterPdfBackend(const QString &printerName,
+                               QObject *parent = Q_NULLPTR);
+    virtual QList<ColorModel> printerGetSupportedColorModels(
+        const QString &name) const override;
+    virtual ColorModel printerGetDefaultColorModel(const QString &name) const;
+    virtual QList<PrintQuality> printerGetSupportedQualities(
+        const QString &name) const override;
+    virtual PrintQuality printerGetDefaultQuality(const QString &name) const;
+
+    virtual QString printerName() const override;
+    virtual QString description() const override;
+    virtual QString location() const override;
+    virtual QString makeAndModel() const override;
+
+    virtual PrinterEnum::State state() const override;
+    virtual QList<QPageSize> supportedPageSizes() const override;
+    virtual QPageSize defaultPageSize() const override;
+    virtual bool supportsCustomPageSizes() const override;
+
+    virtual QPageSize minimumPhysicalPageSize() const override;
+    virtual QPageSize maximumPhysicalPageSize() const override;
+    virtual QList<int> supportedResolutions() const override;
+    virtual PrinterEnum::DuplexMode defaultDuplexMode() const override;
+    virtual QList<PrinterEnum::DuplexMode> supportedDuplexModes() const override;
+
+    virtual PrinterBackend::BackendType backendType() const override;
+};
+
+#endif // USC_PRINTERS_PDF_BACKEND_H

=== renamed file 'plugins/Ubuntu/Settings/Printers/cups/cupsfacade_impl.cpp' => 'plugins/Ubuntu/Settings/Printers/cups/cupsfacade.cpp'
--- plugins/Ubuntu/Settings/Printers/cups/cupsfacade_impl.cpp	2017-01-20 11:44:54 +0000
+++ plugins/Ubuntu/Settings/Printers/cups/cupsfacade.cpp	2017-01-23 14:09:24 +0000
@@ -16,7 +16,7 @@
 
 #include "utils.h"
 
-#include "cups/cupsfacade_impl.h"
+#include "cups/cupsfacade.h"
 
 #include <cups/http.h>
 #include <cups/ipp.h>
@@ -27,21 +27,20 @@
 #define __CUPS_ADD_OPTION(dest, name, value) dest->num_options = \
     cupsAddOption(name, value, dest->num_options, &dest->options);
 
-CupsFacadeImpl::CupsFacadeImpl(QObject *parent) : CupsFacade(parent)
-{
-
-}
-
-CupsFacadeImpl::~CupsFacadeImpl()
-{
-
-}
-
-QString CupsFacadeImpl::printerAdd(const QString &name,
-                                   const QUrl &uri,
-                                   const QUrl &ppdFile,
-                                   const QString &info,
-                                   const QString &location)
+CupsFacade::CupsFacade(QObject *parent) : QObject(parent)
+{
+}
+
+CupsFacade::~CupsFacade()
+{
+
+}
+
+QString CupsFacade::printerAdd(const QString &name,
+                               const QUrl &uri,
+                               const QUrl &ppdFile,
+                               const QString &info,
+                               const QString &location)
 {
     Q_UNUSED(name);
     Q_UNUSED(uri);
@@ -51,11 +50,11 @@
     return QString();
 }
 
-QString CupsFacadeImpl::printerAddWithPpd(const QString &name,
-                                          const QUrl &uri,
-                                          const QString &ppdFileName,
-                                          const QString &info,
-                                          const QString &location)
+QString CupsFacade::printerAddWithPpd(const QString &name,
+                                      const QUrl &uri,
+                                      const QString &ppdFileName,
+                                      const QString &info,
+                                      const QString &location)
 {
     Q_UNUSED(name);
     Q_UNUSED(uri);
@@ -65,21 +64,20 @@
     return QString();
 }
 
-QString CupsFacadeImpl::printerDelete(const QString &name)
+QString CupsFacade::printerDelete(const QString &name)
 {
     Q_UNUSED(name);
     return QString();
 }
 
-QString CupsFacadeImpl::printerSetEnabled(const QString &name,
-                                          const bool enabled)
+QString CupsFacade::printerSetEnabled(const QString &name, const bool enabled)
 {
     Q_UNUSED(name);
     Q_UNUSED(enabled);
     return QString();
 }
 
-QString CupsFacadeImpl::printerSetAcceptJobs(
+QString CupsFacade::printerSetAcceptJobs(
         const QString &name,
         const bool enabled,
         const QString &reason)
@@ -90,8 +88,7 @@
     return QString();
 }
 
-QString CupsFacadeImpl::printerSetInfo(const QString &name,
-                                       const QString &info)
+QString CupsFacade::printerSetInfo(const QString &name, const QString &info)
 {
     if (!helper.printerClassSetInfo(name, info)) {
         return helper.getLastError();
@@ -99,25 +96,24 @@
     return QString();
 }
 
-QString CupsFacadeImpl::printerSetLocation(const QString &name,
-                                           const QString &location)
+QString CupsFacade::printerSetLocation(const QString &name,
+                                       const QString &location)
 {
     Q_UNUSED(name);
     Q_UNUSED(location);
     return QString();
 }
 
-QString CupsFacadeImpl::printerSetShared(const QString &name,
-                                         const bool shared)
+QString CupsFacade::printerSetShared(const QString &name, const bool shared)
 {
     Q_UNUSED(name);
     Q_UNUSED(shared);
     return QString();
 }
 
-QString CupsFacadeImpl::printerSetJobSheets(const QString &name,
-                                            const QString &start,
-                                            const QString &end)
+QString CupsFacade::printerSetJobSheets(const QString &name,
+                                        const QString &start,
+                                        const QString &end)
 {
     Q_UNUSED(name);
     Q_UNUSED(start);
@@ -125,41 +121,41 @@
     return QString();
 }
 
-QString CupsFacadeImpl::printerSetErrorPolicy(const QString &name,
-                                              const PrinterEnum::ErrorPolicy &policy)
-{
-    Q_UNUSED(name);
-    Q_UNUSED(policy);
-    return QString();
-}
-
-QString CupsFacadeImpl::printerSetOpPolicy(const QString &name,
-                                           const PrinterEnum::OperationPolicy &policy)
-{
-    Q_UNUSED(name);
-    Q_UNUSED(policy);
-    return QString();
-}
-
-QString CupsFacadeImpl::printerSetUsersAllowed(const QString &name,
-                                               const QStringList &users)
-{
-    Q_UNUSED(name);
-    Q_UNUSED(users);
-    return QString();
-}
-
-QString CupsFacadeImpl::printerSetUsersDenied(const QString &name,
-                                              const QStringList &users)
-{
-    Q_UNUSED(name);
-    Q_UNUSED(users);
-    return QString();
-}
-
-QString CupsFacadeImpl::printerAddOptionDefault(const QString &name,
-                                                const QString &option,
-                                                const QStringList &values)
+QString CupsFacade::printerSetErrorPolicy(const QString &name,
+                                          const PrinterEnum::ErrorPolicy &policy)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(policy);
+    return QString();
+}
+
+QString CupsFacade::printerSetOpPolicy(const QString &name,
+                                       const PrinterEnum::OperationPolicy &policy)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(policy);
+    return QString();
+}
+
+QString CupsFacade::printerSetUsersAllowed(const QString &name,
+                                           const QStringList &users)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(users);
+    return QString();
+}
+
+QString CupsFacade::printerSetUsersDenied(const QString &name,
+                                          const QStringList &users)
+{
+    Q_UNUSED(name);
+    Q_UNUSED(users);
+    return QString();
+}
+
+QString CupsFacade::printerAddOptionDefault(const QString &name,
+                                            const QString &option,
+                                            const QStringList &values)
 {
     Q_UNUSED(name);
     Q_UNUSED(option);
@@ -167,17 +163,17 @@
     return QString();
 }
 
-QString CupsFacadeImpl::printerDeleteOptionDefault(const QString &name,
-                                                   const QString &value)
+QString CupsFacade::printerDeleteOptionDefault(const QString &name,
+                                               const QString &value)
 {
     Q_UNUSED(name);
     Q_UNUSED(value);
     return QString();
 }
 
-QString CupsFacadeImpl::printerAddOption(const QString &name,
-                                         const QString &option,
-                                         const QStringList &values)
+QString CupsFacade::printerAddOption(const QString &name,
+                                     const QString &option,
+                                     const QStringList &values)
 {
     if (!helper.printerClassSetOption(name, option, values)) {
         return helper.getLastError();
@@ -187,15 +183,15 @@
     return QString();
 }
 
-QVariant CupsFacadeImpl::printerGetOption(const QString &name,
-                                          const QString &option)
+QVariant CupsFacade::printerGetOption(const QString &name,
+                                      const QString &option)
 {
     QStringList opts({option});
     auto res = printerGetOptions(name, opts);
     return res[option];
 }
 
-QMap<QString, QVariant> CupsFacadeImpl::printerGetOptions(
+QMap<QString, QVariant> CupsFacade::printerGetOptions(
     const QString &name, const QStringList &options)
 {
     QMap<QString, QVariant> ret;
@@ -263,7 +259,7 @@
     return ret;
 }
 
-QList<ColorModel> CupsFacadeImpl::printerGetSupportedColorModels(
+QList<ColorModel> CupsFacade::printerGetSupportedColorModels(
     const QString &name) const
 {
     QList<ColorModel> ret;
@@ -288,7 +284,8 @@
     return ret;
 }
 
-QList<PrintQuality> CupsFacadeImpl::printerGetSupportedQualities(const QString &name) const
+QList<PrintQuality> CupsFacade::printerGetSupportedQualities(
+    const QString &name) const
 {
     QList<PrintQuality> ret;
     ppd_file_t* ppd;
@@ -313,13 +310,13 @@
     return ret;
 }
 
-QString CupsFacadeImpl::getPrinterName(const QString &name) const
+QString CupsFacade::getPrinterName(const QString &name) const
 {
     const auto parts = name.splitRef(QLatin1Char('/'));
     return parts.at(0).toString();
 }
 
-QString CupsFacadeImpl::getPrinterInstance(const QString &name) const
+QString CupsFacade::getPrinterInstance(const QString &name) const
 {
     const auto parts = name.splitRef(QLatin1Char('/'));
     QString instance;
@@ -329,8 +326,8 @@
     return instance;
 }
 
-cups_dest_t* CupsFacadeImpl::makeDest(const QString &name,
-                                      const PrinterJob *options)
+cups_dest_t* CupsFacade::makeDest(const QString &name,
+                                  const PrinterJob *options)
 {
     // Get the cups dest
     cups_dest_t *dest = helper.getDest(getPrinterName(name), getPrinterInstance(name));
@@ -358,9 +355,8 @@
     return dest;
 }
 
-int CupsFacadeImpl::printFileToDest(const QString &filepath,
-                                    const QString &title,
-                                    const cups_dest_t *dest)
+int CupsFacade::printFileToDest(const QString &filepath, const QString &title,
+                                const cups_dest_t *dest)
 {
     qDebug() << "Printing:" << filepath << title << dest->name << dest->num_options;
     return cupsPrintFile(dest->name,

=== modified file 'plugins/Ubuntu/Settings/Printers/cups/cupsfacade.h'
--- plugins/Ubuntu/Settings/Printers/cups/cupsfacade.h	2017-01-19 21:00:28 +0000
+++ plugins/Ubuntu/Settings/Printers/cups/cupsfacade.h	2017-01-23 14:09:24 +0000
@@ -17,11 +17,10 @@
 #ifndef USC_PRINTERS_CUPSFACADE_H
 #define USC_PRINTERS_CUPSFACADE_H
 
-#include "printers_global.h"
-
 #include "enums.h"
 #include "structs.h"
 
+#include "cups/cupspkhelper.h"
 #include "printer/printerjob.h"
 
 #include <cups/cups.h>
@@ -34,79 +33,78 @@
 #include <QUrl>
 #include <QVariant>
 
-class PRINTERS_DECL_EXPORT CupsFacade : public QObject
+class PrinterJob;
+class CupsFacade : public QObject
 {
     Q_OBJECT
 public:
-    explicit CupsFacade(QObject *parent = nullptr) : QObject(parent) {};
-    virtual ~CupsFacade() {};
-    virtual QString printerAdd(const QString &name,
-                               const QUrl &uri,
-                               const QUrl &ppdFile,
-                               const QString &info,
-                               const QString &location) = 0;
-    virtual QString printerAddWithPpd(const QString &name,
-                                      const QUrl &uri,
-                                      const QString &ppdFileName,
-                                      const QString &info,
-                                      const QString &location) = 0;
-    virtual QString printerDelete(const QString &name) = 0;
-    virtual QString printerSetEnabled(const QString &name,
-                                      const bool enabled) = 0;
-    virtual QString printerSetAcceptJobs(
+    explicit CupsFacade(QObject *parent = Q_NULLPTR);
+    ~CupsFacade();
+    QString printerAdd(const QString &name,
+                       const QUrl &uri,
+                       const QUrl &ppdFile,
+                       const QString &info,
+                       const QString &location);
+    QString printerAddWithPpd(const QString &name,
+                              const QUrl &uri,
+                              const QString &ppdFileName,
+                              const QString &info,
+                              const QString &location);
+    QString printerDelete(const QString &name);
+    QString printerSetEnabled(const QString &name, const bool enabled);
+    QString printerSetAcceptJobs(
         const QString &name,
         const bool enabled,
-        const QString &reason = QString::null) = 0;
-    virtual QString printerSetInfo(const QString &name,
-                                   const QString &info) = 0;
-    virtual QString printerSetLocation(const QString &name,
-                                       const QString &location) = 0;
-    virtual QString printerSetShared(const QString &name,
-                                     const bool shared) = 0;
-    virtual QString printerSetJobSheets(const QString &name,
-                                        const QString &start,
-                                        const QString &end) = 0;
-    virtual QString printerSetErrorPolicy(const QString &name,
-                                          const PrinterEnum::ErrorPolicy &policy) = 0;
+        const QString &reason = QString::null);
+    QString printerSetInfo(const QString &name, const QString &info);
+    QString printerSetLocation(const QString &name, const QString &location);
+    QString printerSetShared(const QString &name, const bool shared);
+    QString printerSetJobSheets(const QString &name, const QString &start,
+                                const QString &end);
+    QString printerSetErrorPolicy(const QString &name,
+                                  const PrinterEnum::ErrorPolicy &policy);
 
-    virtual QString printerSetOpPolicy(const QString &name,
-                                       const PrinterEnum::OperationPolicy &policy) = 0;
-    virtual QString printerSetUsersAllowed(const QString &name,
-                                           const QStringList &users) = 0;
-    virtual QString printerSetUsersDenied(const QString &name,
-                                          const QStringList &users) = 0;
-    virtual QString printerAddOptionDefault(const QString &name,
-                                            const QString &option,
-                                            const QStringList &values) = 0;
-    virtual QString printerDeleteOptionDefault(const QString &name,
-                                               const QString &value) = 0;
-    virtual QString printerAddOption(const QString &name,
-                                     const QString &option,
-                                     const QStringList &values) = 0;
+    QString printerSetOpPolicy(const QString &name,
+                               const PrinterEnum::OperationPolicy &policy);
+    QString printerSetUsersAllowed(const QString &name,
+                                   const QStringList &users);
+    QString printerSetUsersDenied(const QString &name,
+                                  const QStringList &users);
+    QString printerAddOptionDefault(const QString &name,
+                                    const QString &option,
+                                    const QStringList &values);
+    QString printerDeleteOptionDefault(const QString &name,
+                                       const QString &value);
+    QString printerAddOption(const QString &name,
+                             const QString &option,
+                             const QStringList &values);
 
     // TODO: const for both these getters (if possible)!
-    virtual QVariant printerGetOption(const QString &name,
-                                      const QString &option) = 0;
-    virtual QMap<QString, QVariant> printerGetOptions(
-        const QString &name, const QStringList &options
-    ) = 0;
+    QVariant printerGetOption(const QString &name, const QString &option);
+    QMap<QString, QVariant> printerGetOptions(const QString &name,
+                                              const QStringList &options);
     // FIXME: maybe have a PrinterDest iface that has a CupsDest impl?
-    virtual cups_dest_t* makeDest(const QString &name,
-                                  const PrinterJob *options) = 0;
-
-    virtual QList<ColorModel> printerGetSupportedColorModels(
-        const QString &name) const = 0;
-    virtual QList<PrintQuality> printerGetSupportedQualities(
-        const QString &name) const = 0;
-    virtual int printFileToDest(const QString &filepath,
-                                const QString &title,
-                                const cups_dest_t *dest) = 0;
-
+    cups_dest_t* makeDest(const QString &name, const PrinterJob *options);
+
+    QList<ColorModel> printerGetSupportedColorModels(const QString &name) const;
+    QList<PrintQuality> printerGetSupportedQualities(const QString &name) const;
+    int printFileToDest(const QString &filepath, const QString &title,
+                        const cups_dest_t *dest);
 Q_SIGNALS:
     void printerAdded(const QString &name);
     void printerModified(const QString &name, const bool ppdChanged);
     void printerDeleted(const QString &name);
     void printerStateChanged(const QString &name);
+
+private:
+    QString getPrinterName(const QString &name) const;
+    QString getPrinterInstance(const QString &name) const;
+    QStringList parsePpdColorModel(const QString &colorModel);
+    const QStringList m_knownQualityOptions = QStringList({
+        "Quality", "PrintQuality", "HPPrintQuality", "StpQuality",
+        "OutputMode",
+    });
+    CupsPkHelper helper;
 };
 
 #endif // USC_PRINTERS_CUPSFACADE_H

=== removed file 'plugins/Ubuntu/Settings/Printers/cups/cupsfacade_impl.h'
--- plugins/Ubuntu/Settings/Printers/cups/cupsfacade_impl.h	2017-01-20 11:44:54 +0000
+++ plugins/Ubuntu/Settings/Printers/cups/cupsfacade_impl.h	1970-01-01 00:00:00 +0000
@@ -1,98 +0,0 @@
-/*
- * Copyright (C) 2017 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef USC_PRINTERS_CUPSFACADE_IMPL_H
-#define USC_PRINTERS_CUPSFACADE_IMPL_H
-
-#include "cups/cupsfacade.h"
-#include "cups/cupspkhelper.h"
-
-class CupsFacadeImpl : public CupsFacade
-{
-    Q_OBJECT
-public:
-    explicit CupsFacadeImpl(QObject *parent = nullptr);
-    virtual ~CupsFacadeImpl() override;
-    virtual QString printerAdd(const QString &name,
-                               const QUrl &uri,
-                               const QUrl &ppdFile,
-                               const QString &info,
-                               const QString &location) override;
-    virtual QString printerAddWithPpd(const QString &name,
-                                      const QUrl &uri,
-                                      const QString &ppdFileName,
-                                      const QString &info,
-                                      const QString &location) override;
-    virtual QString printerDelete(const QString &name) override;
-    virtual QString printerSetEnabled(const QString &name,
-                                      const bool enabled) override;
-    virtual QString printerSetAcceptJobs(
-        const QString &name,
-        const bool enabled,
-        const QString &reason = QString::null) override;
-    virtual QString printerSetInfo(const QString &name,
-                                   const QString &info) override;
-    virtual QString printerSetLocation(const QString &name,
-                                       const QString &location) override;
-    virtual QString printerSetShared(const QString &name,
-                                     const bool shared) override;
-    virtual QString printerSetJobSheets(const QString &name,
-                                        const QString &start,
-                                        const QString &end) override;
-    virtual QString printerSetErrorPolicy(const QString &name,
-                                          const PrinterEnum::ErrorPolicy &policy) override;
-
-    virtual QString printerSetOpPolicy(const QString &name,
-                                       const PrinterEnum::OperationPolicy &policy) override;
-    virtual QString printerSetUsersAllowed(const QString &name,
-                                           const QStringList &users) override;
-    virtual QString printerSetUsersDenied(const QString &name,
-                                          const QStringList &users) override;
-    virtual QString printerAddOptionDefault(const QString &name,
-                                            const QString &option,
-                                            const QStringList &values) override;
-    virtual QString printerDeleteOptionDefault(const QString &name,
-                                               const QString &value) override;
-    virtual QString printerAddOption(const QString &name,
-                                     const QString &option,
-                                     const QStringList &values) override;
-    virtual QVariant printerGetOption(const QString &name,
-                                         const QString &option) override;
-    virtual QMap<QString, QVariant> printerGetOptions(
-        const QString &name, const QStringList &options
-    ) override;
-    virtual QList<ColorModel> printerGetSupportedColorModels(
-        const QString &name) const override;
-    virtual QList<PrintQuality> printerGetSupportedQualities(
-        const QString &name) const override;
-    virtual cups_dest_t* makeDest(const QString &name,
-                                  const PrinterJob *options) override;
-
-    virtual int printFileToDest(const QString &filepath,
-                                const QString &title,
-                                const cups_dest_t *dest) override;
-private:
-    QString getPrinterName(const QString &name) const;
-    QString getPrinterInstance(const QString &name) const;
-    QStringList parsePpdColorModel(const QString &colorModel);
-    const QStringList m_knownQualityOptions = QStringList({
-        "Quality", "PrintQuality", "HPPrintQuality", "StpQuality",
-        "OutputMode",
-    });
-    CupsPkHelper helper;
-};
-
-#endif // USC_PRINTERS_CUPSFACADE_IMPL_H

=== modified file 'plugins/Ubuntu/Settings/Printers/models/printermodel.cpp'
--- plugins/Ubuntu/Settings/Printers/models/printermodel.cpp	2017-01-19 21:02:07 +0000
+++ plugins/Ubuntu/Settings/Printers/models/printermodel.cpp	2017-01-23 14:09:24 +0000
@@ -16,47 +16,32 @@
 
 #include "utils.h"
 
-#include "cups/cupsfacade_impl.h"
+#include "backend/backend_cups.h"
+#include "cups/cupsfacade.h"
 #include "models/printermodel.h"
-#include "models/printermodel_p.h"
-#include "printer/printerinfo_allimpl.h"
 
 #include <QDebug>
 
-PrinterModel::PrinterModel(int timerMsec, QObject *parent)
-    : QAbstractListModel(parent)
-    , d_ptr(new PrinterModelPrivate(this))
-{
-    update();
-    startUpdateTimer(timerMsec);
-}
-
-PrinterModel::PrinterModel(PrinterInfo *info, CupsFacade *cups, int timerMsec, QObject *parent)
-    : QAbstractListModel(parent)
-    , d_ptr(new PrinterModelPrivate(this, info, cups))
-{
-    update();
-    startUpdateTimer(timerMsec);
-}
-
-PrinterModelPrivate::PrinterModelPrivate(PrinterModel *q)
-{
-    this->info = new PrinterInfoAllImpl;
-    this->cups = new CupsFacadeImpl;
-}
-
-PrinterModelPrivate::PrinterModelPrivate(PrinterModel *q, PrinterInfo *info, CupsFacade *cups)
-{
-    this->info = info;
-    this->cups = cups;
+PrinterModel::PrinterModel(const int updateIntervalMSecs, QObject *parent)
+    : PrinterModel(new PrinterCupsBackend, updateIntervalMSecs, parent)
+{
+}
+
+PrinterModel::PrinterModel(PrinterBackend *backend,
+                           const int updateIntervalMSecs,
+                           QObject *parent)
+    : QAbstractListModel(parent)
+    , m_backend(backend)
+{
+    update();
+    startUpdateTimer(updateIntervalMSecs);
 }
 
 PrinterModel::~PrinterModel()
 {
-
 }
 
-void PrinterModel::startUpdateTimer(int msecs)
+void PrinterModel::startUpdateTimer(const int &msecs)
 {
     // Start a timer to poll for changes in the printers
     m_update_timer.setParent(this);
@@ -66,19 +51,22 @@
 
 void PrinterModel::update()
 {
-    Q_D(PrinterModel);
-
     // Store the old count and get the new printers
-    int oldCount = d->printers.size();
-    QList<PrinterInfo *> newPrinters = d->info->availablePrinters();
+    int oldCount = m_printers.size();
+    QList<Printer*> newPrinters = m_backend->availablePrinters();
+
+    /* If any printers returned from the backend are irrelevant, we delete
+    them. This a list of indices that corresponds to printers scheduled for
+    deletion in newPrinters. */
+    QList<uint> forDeletion;
 
     // Go through the old model
-    for (int i=0; i < d->printers.count(); i++) {
+    for (int i=0; i < m_printers.count(); i++) {
         // Determine if the old printer exists in the new model
         bool exists = false;
 
-        Q_FOREACH(PrinterInfo *p, newPrinters) {
-            if (p->printerName() == d->printers.at(i)->name()) {
+        Q_FOREACH(Printer *p, newPrinters) {
+            if (p->name() == m_printers.at(i)->name()) {
                 exists = true;
                 break;
             }
@@ -87,7 +75,8 @@
         // If it doesn't exist then remove it from the old model
         if (!exists) {
             beginRemoveRows(QModelIndex(), i, i);
-            d->printers.removeAt(i);
+            Printer *p = m_printers.takeAt(i);
+            p->deleteLater();
             endRemoveRows();
 
             i--;  // as we have removed an item decrement
@@ -100,9 +89,10 @@
         bool exists = false;
         int j;
 
-        for (j=0; j < d->printers.count(); j++) {
-            if (d->printers.at(j)->name() == newPrinters.at(i)->printerName()) {
+        for (j=0; j < m_printers.count(); j++) {
+            if (m_printers.at(j)->name() == newPrinters.at(i)->name()) {
                 exists = true;
+                forDeletion << i;
                 break;
             }
         }
@@ -113,21 +103,25 @@
             } else {
                 // New printer does exist but needs to be moved in old model
                 beginMoveRows(QModelIndex(), j, 1, QModelIndex(), i);
-                d->printers.move(j, i);
+                m_printers.move(j, i);
                 endMoveRows();
             }
+
+            // We can safely delete the newPrinter as it already exists.
+            forDeletion << i;
         } else {
             // New printer does not exist insert into model
             beginInsertRows(QModelIndex(), i, i);
-            QSharedPointer<Printer> printer = QSharedPointer<Printer>(
-                new Printer(newPrinters.at(i), d->cups)
-            );
-            d->printers.insert(i, printer);
+            m_printers.insert(i, newPrinters.at(i));
             endInsertRows();
         }
     }
 
-    if (oldCount != d->printers.size()) {
+    Q_FOREACH(const int &index, forDeletion) {
+        newPrinters.at(index)->deleteLater();
+    }
+
+    if (oldCount != m_printers.size()) {
         Q_EMIT countChanged();
     }
 }
@@ -135,8 +129,7 @@
 int PrinterModel::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
-    Q_D(const PrinterModel);
-    return d->printers.size();
+    return m_printers.size();
 }
 
 int PrinterModel::count() const
@@ -146,12 +139,11 @@
 
 QVariant PrinterModel::data(const QModelIndex &index, int role) const
 {
-    Q_D(const PrinterModel);
     QVariant ret;
 
-    if ((0<=index.row()) && (index.row()<d->printers.size())) {
+    if ((0<=index.row()) && (index.row()<m_printers.size())) {
 
-        auto printer = d->printers[index.row()];
+        auto printer = m_printers[index.row()];
 
         switch (role) {
         case NameRole:
@@ -229,8 +221,7 @@
         //     ret = printer->state();
         //     break;
         case PrinterRole:
-            // TODO: figure out how crazy this is...
-            ret = QVariant::fromValue(printer.data());
+            ret = QVariant::fromValue(printer);
             break;
         case IsPdfRole:
             ret = printer->isPdf();
@@ -244,13 +235,12 @@
     return ret;
 }
 
-bool PrinterModel::setData(const QModelIndex &index, const QVariant &value, int role)
+bool PrinterModel::setData(const QModelIndex &index,
+                           const QVariant &value, int role)
 {
-    Q_D(const PrinterModel);
-
-    if ((0<=index.row()) && (index.row()<d->printers.size())) {
-
-        auto printer = d->printers[index.row()];
+    if ((0<=index.row()) && (index.row()<m_printers.size())) {
+
+        auto printer = m_printers[index.row()];
 
         switch (role) {
         case ColorModelRole: {
@@ -341,10 +331,10 @@
     return result;
 }
 
-QSharedPointer<Printer> PrinterModel::getPrinterFromName(const QString &name)
+Printer* PrinterModel::getPrinterFromName(const QString &name)
 {
     Q_UNUSED(name);
-    return QSharedPointer<Printer>(nullptr);
+    return Q_NULLPTR;
 }
 
 PrinterFilter::PrinterFilter(QObject *parent) : QSortFilterProxyModel(parent)

=== modified file 'plugins/Ubuntu/Settings/Printers/models/printermodel.h'
--- plugins/Ubuntu/Settings/Printers/models/printermodel.h	2017-01-19 21:02:07 +0000
+++ plugins/Ubuntu/Settings/Printers/models/printermodel.h	2017-01-23 14:09:24 +0000
@@ -29,15 +29,14 @@
 #include <QTimer>
 #include <QVariant>
 
-class PrinterModelPrivate;
 class PRINTERS_DECL_EXPORT PrinterModel : public QAbstractListModel
 {
     Q_OBJECT
-    Q_DECLARE_PRIVATE(PrinterModel)
     Q_PROPERTY(int count READ count NOTIFY countChanged)
 public:
-    explicit PrinterModel(int timerMsec=5000, QObject *parent = 0);
-    explicit PrinterModel(PrinterInfo *info, CupsFacade *cups, int timerMsec=5000, QObject *parent = 0);
+    explicit PrinterModel(const int updateIntervalMSecs=5000, QObject *parent = Q_NULLPTR);
+    explicit PrinterModel(PrinterBackend *backend, const int updateIntervalMSecs=5000,
+                          QObject *parent = Q_NULLPTR);
     ~PrinterModel();
 
     enum Roles
@@ -75,15 +74,19 @@
 
     int count() const;
 
-    QSharedPointer<Printer> getPrinterFromName(const QString &name);
+    Printer* getPrinterFromName(const QString &name);
 
     Q_INVOKABLE QVariantMap get(const int row) const;
 private:
-    QScopedPointer<PrinterModelPrivate> const d_ptr;
     QTimer m_update_timer;
+    PrinterBackend *m_backend;
+
+    /* FIXME: there's currently no need to share the Printer obj with QML, so
+    this should be normal pointers that are deletedLater. */
+    QList<Printer*> m_printers;
 
 private Q_SLOTS:
-    void startUpdateTimer(int msecs);
+    void startUpdateTimer(const int &msecs);
     void update();
 
 Q_SIGNALS:

=== removed file 'plugins/Ubuntu/Settings/Printers/models/printermodel_p.h'
--- plugins/Ubuntu/Settings/Printers/models/printermodel_p.h	2017-01-18 16:18:40 +0000
+++ plugins/Ubuntu/Settings/Printers/models/printermodel_p.h	1970-01-01 00:00:00 +0000
@@ -1,35 +0,0 @@
-/*
- * Copyright (C) 2017 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef USC_PRINTERS_PRINTERMODELPRIVATE_H
-#define USC_PRINTERS_PRINTERMODELPRIVATE_H
-
-struct PrinterModelPrivate
-{
-    Q_DISABLE_COPY(PrinterModelPrivate)
-    Q_DECLARE_PUBLIC(PrinterModel)
-    explicit PrinterModelPrivate(PrinterModel *q);
-    explicit PrinterModelPrivate(PrinterModel *q, PrinterInfo *info, CupsFacade *cups);
-    CupsFacade *cups;
-    PrinterModel *q_ptr;
-    PrinterInfo *info;
-
-    /* FIXME: there's currently no need to share the Printer obj with QML, so
-    this should be normal pointers that are deletedLater. */
-    QList<QSharedPointer<Printer>> printers;
-};
-
-#endif // USC_PRINTERS_PRINTERMODELPRIVATE_H

=== modified file 'plugins/Ubuntu/Settings/Printers/printer/printer.cpp'
--- plugins/Ubuntu/Settings/Printers/printer/printer.cpp	2017-01-20 12:08:00 +0000
+++ plugins/Ubuntu/Settings/Printers/printer/printer.cpp	2017-01-23 14:09:24 +0000
@@ -17,83 +17,43 @@
 #include "utils.h"
 
 #include "printer.h"
-#include "printer_p.h"
 
 #include <QDebug>
 
 Printer::Printer(QObject *parent)
     : QObject(parent)
-    , d_ptr(new PrinterPrivate(this))
 {
+    // TODO: remove this constructor.
 }
 
-Printer::Printer(PrinterInfo *info, CupsFacade *cups, QObject *parent)
+Printer::Printer(PrinterBackend *backend, QObject *parent)
     : QObject(parent)
-    , d_ptr(new PrinterPrivate(this, info, cups))
+    , m_backend(backend)
 {
+    loadColorModel();
+    loadPrintQualities();
 }
 
 Printer::~Printer()
 {
-
-}
-
-PrinterPrivate::PrinterPrivate(Printer *q)
-{
-    loadColorModel();
-    loadPrintQualities();
-}
-
-PrinterPrivate::PrinterPrivate(Printer *q, PrinterInfo *info, CupsFacade *cups)
-{
-    this->info = info;
-    this->cups = cups;
-
-    loadColorModel();
-    loadPrintQualities();
-}
-
-PrinterPrivate::~PrinterPrivate()
-{
-    delete this->info;
-}
-
-void PrinterPrivate::loadColorModel()
-{
-    if (!this->info->isPdf()) {
-        QStringList opts({"DefaultColorModel"});
-        auto name = this->info->printerName();
-        auto vals = this->cups->printerGetOptions(name, opts);
-        m_defaultColorModel = vals["DefaultColorModel"].value<ColorModel>();
-
-        m_supportedColorModels = this->cups->printerGetSupportedColorModels(name);
-
-        if (m_supportedColorModels.size() == 0) {
-            m_supportedColorModels.append(m_defaultColorModel);
-        }
-    } else {
-        ColorModel rgb;
-        rgb.colorType = PrinterEnum::ColorModelType::ColorType;
-        rgb.name = "RGB";
-        rgb.text = "Color";
-
-        m_defaultColorModel = rgb;
-        m_supportedColorModels = QList<ColorModel>{rgb};
-    }
-}
-
-void PrinterPrivate::loadPrintQualities()
-{
-    if (!this->info->isPdf()) {
-        QString name = this->info->printerName();
-        m_defaultPrintQuality = this->cups->printerGetOption(
-            name, "DefaultPrintQuality").value<PrintQuality>();
-        m_supportedPrintQualities = this->cups->printerGetSupportedQualities(name);
-    } else {
-        PrintQuality quality;
-        m_defaultPrintQuality = quality;
-        m_supportedPrintQualities = QList<PrintQuality>({quality});
-    }
+    m_backend->deleteLater();
+}
+
+void Printer::loadColorModel()
+{
+    m_supportedColorModels = m_backend->printerGetSupportedColorModels(name());
+    m_defaultColorModel = m_backend->printerGetDefaultColorModel(name());
+
+    if (m_supportedColorModels.size() == 0) {
+        m_supportedColorModels.append(m_defaultColorModel);
+    }
+}
+
+void Printer::loadPrintQualities()
+{
+    m_supportedPrintQualities = m_backend->printerGetSupportedQualities(name());
+    m_defaultPrintQuality = m_backend->printerGetDefaultQuality(name());
+
     if (m_supportedPrintQualities.size() == 0) {
         m_supportedPrintQualities.append(m_defaultPrintQuality);
     }
@@ -101,37 +61,31 @@
 
 ColorModel Printer::defaultColorModel() const
 {
-    Q_D(const Printer);
-    return d->m_defaultColorModel;
+    return m_defaultColorModel;
 }
 
 QList<ColorModel> Printer::supportedColorModels() const
 {
-    Q_D(const Printer);
-    return d->m_supportedColorModels;
+    return m_supportedColorModels;
 }
 
 PrintQuality Printer::defaultPrintQuality() const
 {
-    Q_D(const Printer);
-    return d->m_defaultPrintQuality;
+    return m_defaultPrintQuality;
 }
 
 QList<PrintQuality> Printer::supportedPrintQualities() const
 {
-    Q_D(const Printer);
-    return d->m_supportedPrintQualities;
+    return m_supportedPrintQualities;
 }
 
 QList<PrinterEnum::DuplexMode> Printer::supportedDuplexModes() const
 {
-    Q_D(const Printer);
-    return d->info->supportedDuplexModes();
+    return m_backend->supportedDuplexModes();
 }
 
 QStringList Printer::supportedDuplexStrings() const
 {
-    Q_D(const Printer);
     QStringList list;
     Q_FOREACH(const PrinterEnum::DuplexMode &mode, supportedDuplexModes()) {
         list << Utils::duplexModeToUIString(mode);
@@ -141,8 +95,7 @@
 
 PrinterEnum::DuplexMode Printer::defaultDuplexMode() const
 {
-    Q_D(const Printer);
-    return d->info->defaultDuplexMode();
+    return m_backend->defaultDuplexMode();
 }
 
 PrinterJob *Printer::job()
@@ -152,36 +105,30 @@
 
 int Printer::printFile(const QString &filepath, const PrinterJob *options)
 {
-    Q_D(const Printer);
-
-    auto dest = d->cups->makeDest(this->name(), options);  // options could be QMap<QString, QString> ?
+    auto dest = m_backend->makeDest(name(), options);  // options could be QMap<QString, QString> ?
 
     qDebug() << "Going to print:" << filepath << options->title();
-    return d->cups->printFileToDest(filepath, options->title(), dest);
+    return m_backend->printFileToDest(filepath, options->title(), dest);
 }
 
 QString Printer::name() const
 {
-    Q_D(const Printer);
-    return d->info->printerName();
+    return m_backend->printerName();
 }
 
 QString Printer::description() const
 {
-    Q_D(const Printer);
-    return d->info->description();
+    return m_backend->description();
 }
 
 QPageSize Printer::defaultPageSize() const
 {
-    Q_D(const Printer);
-    return d->info->defaultPageSize();
+    return m_backend->defaultPageSize();
 }
 
 QList<QPageSize> Printer::supportedPageSizes() const
 {
-    Q_D(const Printer);
-    return d->info->supportedPageSizes();
+    return m_backend->supportedPageSizes();
 }
 
 PrinterEnum::AccessControl Printer::accessControl() const
@@ -216,20 +163,16 @@
 
 bool Printer::isDefault()
 {
-    Q_D(Printer);
-    return name() == d->info->defaultPrinterName();
+    return name() == m_backend->defaultPrinterName();
 }
 
 bool Printer::isPdf()
 {
-    Q_D(Printer);
-    return d->info->isPdf();
+    return m_backend->backendType() == PrinterBackend::BackendType::PdfType;
 }
 
 void Printer::setDefaultColorModel(const ColorModel &colorModel)
 {
-    Q_D(Printer);
-
     if (defaultColorModel() == colorModel) {
         return;
     }
@@ -240,10 +183,10 @@
     }
 
     QStringList vals({colorModel.name});
-    QString reply = d->cups->printerAddOption(name(), "ColorModel", vals);
+    QString reply = m_backend->printerAddOption(name(), "ColorModel", vals);
     Q_UNUSED(reply);
 
-    d->loadColorModel();
+    loadColorModel();
     Q_EMIT defaultColorModelChanged();
 }
 
@@ -254,30 +197,27 @@
 
 void Printer::setDescription(const QString &description)
 {
-    Q_D(const Printer);
-    QString answer = d->cups->printerSetInfo(d->info->printerName(), description);
+    QString answer = m_backend->printerSetInfo(name(), description);
 
-    d->info->refresh();
+    m_backend->refresh();
     Q_EMIT descriptionChanged();
 }
 
 void Printer::setDefaultDuplexMode(const PrinterEnum::DuplexMode &duplexMode)
 {
-    Q_D(Printer);
-
     if (defaultDuplexMode() == duplexMode) {
         return;
     }
 
-    if (!d->info->supportedDuplexModes().contains(duplexMode)) {
+    if (!m_backend->supportedDuplexModes().contains(duplexMode)) {
         qWarning() << Q_FUNC_INFO << "duplex mode not supported";
         return;
     }
 
     QStringList vals({Utils::duplexModeToPpdChoice(duplexMode)});
-    QString reply = d->cups->printerAddOption(name(), "Duplex", vals);
+    QString reply = m_backend->printerAddOption(name(), "Duplex", vals);
 
-    d->info->refresh();
+    m_backend->refresh();
     Q_EMIT defaultDuplexModeChanged();
 }
 
@@ -298,8 +238,6 @@
 
 void Printer::setDefaultPrintQuality(const PrintQuality &quality)
 {
-    Q_D(Printer);
-
     if (defaultPrintQuality() == quality) {
         return;
     }
@@ -310,19 +248,17 @@
     }
 
     QStringList vals({quality.name});
-    QString reply = d->cups->printerAddOption(name(), quality.originalOption, vals);
-    d->loadPrintQualities();
+    QString reply = m_backend->printerAddOption(name(), quality.originalOption, vals);
+    loadPrintQualities();
 }
 
 void Printer::setDefaultPageSize(const QPageSize &pageSize)
 {
-    Q_D(Printer);
-
     if (defaultPageSize() == pageSize) {
         return;
     }
 
-    if (!d->info->supportedPageSizes().contains(pageSize)) {
+    if (!m_backend->supportedPageSizes().contains(pageSize)) {
         qWarning() << Q_FUNC_INFO << "pagesize not supported.";
         return;
     }
@@ -333,9 +269,9 @@
     }
 
     QStringList vals({pageSize.key()});
-    QString reply = d->cups->printerAddOption(name(), "PageSize", vals);
+    QString reply = m_backend->printerAddOption(name(), "PageSize", vals);
 
-    d->info->refresh();
+    m_backend->refresh();
     Q_EMIT defaultPageSizeChanged();
 }
 

=== modified file 'plugins/Ubuntu/Settings/Printers/printer/printer.h'
--- plugins/Ubuntu/Settings/Printers/printer/printer.h	2017-01-19 21:02:07 +0000
+++ plugins/Ubuntu/Settings/Printers/printer/printer.h	2017-01-23 14:09:24 +0000
@@ -19,9 +19,8 @@
 
 #include "printers_global.h"
 
-#include "cups/cupsfacade.h"
+#include "backend/backend.h"
 #include "enums.h"
-#include "printer/printerinfo.h"
 #include "printer/printerjob.h"
 #include "structs.h"
 
@@ -32,32 +31,14 @@
 #include <QString>
 #include <QStringList>
 
-class CupsFacade;
+class PrinterBackend;
 class PrinterJob;
-
-class PrinterPrivate;
 class PRINTERS_DECL_EXPORT Printer : public QObject
 {
     Q_OBJECT
-    Q_DECLARE_PRIVATE(Printer)
-    Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
-    Q_PROPERTY(ColorModel defaultColorModel READ defaultColorModel WRITE setDefaultColorModel NOTIFY defaultColorModelChanged)
-    Q_PROPERTY(QStringList supportedDuplexStrings READ supportedDuplexStrings CONSTANT)
-    Q_PROPERTY(PrinterEnum::DuplexMode defaultDuplexMode READ defaultDuplexMode WRITE setDefaultDuplexMode NOTIFY defaultDuplexModeChanged)
-    Q_PROPERTY(QString name READ name NOTIFY nameChanged)
-    Q_PROPERTY(QString description READ description WRITE setDescription NOTIFY descriptionChanged)
-    Q_PROPERTY(QPageSize defaultPageSize READ defaultPageSize WRITE setDefaultPageSize NOTIFY defaultPageSizeChanged)
-    Q_PROPERTY(QList<QPageSize> supportedPageSizes READ supportedPageSizes CONSTANT)
-    Q_PROPERTY(PrinterEnum::AccessControl accessControl READ accessControl WRITE setAccessControl NOTIFY accessControlChanged)
-    Q_PROPERTY(PrinterEnum::ErrorPolicy errorPolicy READ errorPolicy WRITE setErrorPolicy NOTIFY errorPolicyChanged)
-    Q_PROPERTY(QStringList users READ users NOTIFY usersChanged)
-    Q_PROPERTY(PrinterEnum::State state READ state NOTIFY stateChanged)
-    Q_PROPERTY(QString lastStateMessage READ lastStateMessage NOTIFY lastStateMessageChanged)
-
-    QScopedPointer<PrinterPrivate> const d_ptr;
 public:
     explicit Printer(QObject *parent = nullptr);
-    explicit Printer(PrinterInfo *info, CupsFacade *cups, QObject *parent = nullptr);
+    explicit Printer(PrinterBackend *backend, QObject *parent = nullptr);
     ~Printer();
 
     bool enabled() const;
@@ -124,6 +105,16 @@
 
     // Signals that some printer setting was changed.
     void printerChanged();
+
+private:
+    void loadColorModel();
+    void loadPrintQualities();
+
+    PrinterBackend *m_backend;
+    ColorModel m_defaultColorModel;
+    QList<ColorModel> m_supportedColorModels;
+    PrintQuality m_defaultPrintQuality;
+    QList<PrintQuality> m_supportedPrintQualities;
 };
 
 // FIXME: not necessary outside tests

=== removed file 'plugins/Ubuntu/Settings/Printers/printer/printer_p.h'
--- plugins/Ubuntu/Settings/Printers/printer/printer_p.h	2017-01-19 21:00:28 +0000
+++ plugins/Ubuntu/Settings/Printers/printer/printer_p.h	1970-01-01 00:00:00 +0000
@@ -1,41 +0,0 @@
-/*
- * Copyright (C) 2017 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef USC_PRINTERS_PRINTERPRIVATE_H
-#define USC_PRINTERS_PRINTERPRIVATE_H
-
-struct PrinterPrivate
-{
-    Q_DISABLE_COPY(PrinterPrivate)
-    Q_DECLARE_PUBLIC(Printer)
-    explicit PrinterPrivate(Printer *q);
-    explicit PrinterPrivate(Printer *q, PrinterInfo *info, CupsFacade *cups);
-    ~PrinterPrivate();
-    void loadColorModel();
-    void loadPrintQualities();
-
-    CupsFacade *cups;
-    Printer *q_ptr;
-    PrinterInfo *info;
-
-    ColorModel m_defaultColorModel;
-    QList<ColorModel> m_supportedColorModels;
-
-    PrintQuality m_defaultPrintQuality;
-    QList<PrintQuality> m_supportedPrintQualities;
-};
-
-#endif // USC_PRINTERS_PRINTERPRIVATE_H

=== removed file 'plugins/Ubuntu/Settings/Printers/printer/printerinfo.h'
--- plugins/Ubuntu/Settings/Printers/printer/printerinfo.h	2017-01-19 17:59:17 +0000
+++ plugins/Ubuntu/Settings/Printers/printer/printerinfo.h	1970-01-01 00:00:00 +0000
@@ -1,67 +0,0 @@
-/*
- * Copyright (C) 2017 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef USC_PRINTERS_PRINTERINFO_H
-#define USC_PRINTERS_PRINTERINFO_H
-
-#include "enums.h"
-
-#include <QPageSize>
-#include <QList>
-#include <QString>
-#include <QStringList>
-
-class PrinterInfo
-{
-public:
-    explicit PrinterInfo(const QString &name = QString::null)
-        : m_printerName(name) {};
-    virtual ~PrinterInfo() {};
-
-    virtual bool holdsDefinition() const = 0;
-
-    virtual QString printerName() const = 0;
-    virtual QString description() const = 0;
-    virtual QString location() const = 0;
-    virtual QString makeAndModel() const = 0;
-
-    virtual PrinterEnum::State state() const = 0;
-    virtual QList<QPageSize> supportedPageSizes() const = 0;
-    virtual QPageSize defaultPageSize() const = 0;
-    virtual bool supportsCustomPageSizes() const = 0;
-
-    virtual QPageSize minimumPhysicalPageSize() const = 0;
-    virtual QPageSize maximumPhysicalPageSize() const = 0;
-    virtual QList<int> supportedResolutions() const = 0;
-    virtual PrinterEnum::DuplexMode defaultDuplexMode() const = 0;
-    virtual QList<PrinterEnum::DuplexMode> supportedDuplexModes() const = 0;
-
-    virtual QList<PrinterInfo*> availablePrinters() = 0;
-    virtual QStringList availablePrinterNames() = 0;
-    virtual PrinterInfo* printerInfo(const QString &printerName) = 0;
-    virtual QString defaultPrinterName() = 0;
-
-    virtual bool isPdf() const = 0;
-
-    virtual void refresh() = 0;
-protected:
-    const QString m_printerName;
-
-};
-
-Q_DECLARE_TYPEINFO(PrinterInfo, Q_MOVABLE_TYPE);
-
-#endif // USC_PRINTERS_PRINTERINFO_H

=== removed file 'plugins/Ubuntu/Settings/Printers/printer/printerinfo_allimpl.cpp'
--- plugins/Ubuntu/Settings/Printers/printer/printerinfo_allimpl.cpp	2017-01-19 17:59:17 +0000
+++ plugins/Ubuntu/Settings/Printers/printer/printerinfo_allimpl.cpp	1970-01-01 00:00:00 +0000
@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2017 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "printer/printerinfo_allimpl.h"
-
-#include "printer/printerinfo_impl.h"
-#include "printer/printerinfo_pdfimpl.h"
-
-PrinterInfoAllImpl::PrinterInfoAllImpl(const QString &name) : PrinterInfo(name)
-{
-    m_pdf_printers = new PrinterInfoPdfImpl();
-    m_qt_printers = new PrinterInfoImpl();
-}
-
-PrinterInfoAllImpl::~PrinterInfoAllImpl()
-{
-
-}
-
-QList<PrinterInfo*> PrinterInfoAllImpl::availablePrinters()
-{
-    QList<PrinterInfo*> list;
-    list += m_pdf_printers->availablePrinters();
-    list += m_qt_printers->availablePrinters();
-    return list;
-}

=== removed file 'plugins/Ubuntu/Settings/Printers/printer/printerinfo_allimpl.h'
--- plugins/Ubuntu/Settings/Printers/printer/printerinfo_allimpl.h	2017-01-19 17:59:17 +0000
+++ plugins/Ubuntu/Settings/Printers/printer/printerinfo_allimpl.h	1970-01-01 00:00:00 +0000
@@ -1,58 +0,0 @@
-/*
- * Copyright (C) 2017 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef USC_PRINTERS_PRINTERINFO_ALLIMPL_H
-#define USC_PRINTERS_PRINTERINFO_ALLIMPL_H
-
-#include "printer/printerinfo.h"
-
-class PrinterInfoAllImpl : public PrinterInfo
-{
-public:
-    explicit PrinterInfoAllImpl(const QString &name = QString::null);
-    virtual ~PrinterInfoAllImpl() override;
-
-    virtual bool holdsDefinition() const override {}
-
-    virtual QString printerName() const override {}
-    virtual QString description() const override {}
-    virtual QString location() const override {}
-    virtual QString makeAndModel() const override {}
-
-    virtual PrinterEnum::State state() const override {}
-    virtual QList<QPageSize> supportedPageSizes() const override {}
-    virtual QPageSize defaultPageSize() const override {}
-    virtual bool supportsCustomPageSizes() const override {}
-
-    virtual QPageSize minimumPhysicalPageSize() const override {}
-    virtual QPageSize maximumPhysicalPageSize() const override {}
-    virtual QList<int> supportedResolutions() const override {}
-    virtual PrinterEnum::DuplexMode defaultDuplexMode() const override {}
-    virtual QList<PrinterEnum::DuplexMode> supportedDuplexModes() const override {}
-    virtual QList<PrinterInfo*> availablePrinters() override;
-    virtual QStringList availablePrinterNames() override {}
-    virtual PrinterInfo* printerInfo(const QString &printerName) override {}
-    virtual QString defaultPrinterName() override {}
-
-    virtual bool isPdf() const override {}
-
-    virtual void refresh() override {}
-private:
-    PrinterInfo *m_pdf_printers;
-    PrinterInfo *m_qt_printers;
-};
-
-#endif // USC_PRINTERS_PRINTERINFO_ALLIMPL_H

=== removed file 'plugins/Ubuntu/Settings/Printers/printer/printerinfo_impl.cpp'
--- plugins/Ubuntu/Settings/Printers/printer/printerinfo_impl.cpp	2017-01-19 17:59:17 +0000
+++ plugins/Ubuntu/Settings/Printers/printer/printerinfo_impl.cpp	1970-01-01 00:00:00 +0000
@@ -1,152 +0,0 @@
-/*
- * Copyright (C) 2017 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "utils.h"
-
-#include "printer/printerinfo_impl.h"
-
-#include <QDebug>
-#include <QPrinter>
-
-PrinterInfoImpl::PrinterInfoImpl(const QString &name) : PrinterInfo(name)
-{
-    refresh();
-}
-
-PrinterInfoImpl::PrinterInfoImpl(QPrinterInfo info)
-    : PrinterInfo(info.isNull() ? QString::null : info.printerName())
-    , m_info(info)
-{
-}
-
-PrinterInfoImpl::~PrinterInfoImpl()
-{
-
-}
-
-bool PrinterInfoImpl::holdsDefinition() const
-{
-    return !m_info.isNull();
-}
-
-QString PrinterInfoImpl::printerName() const
-{
-    return m_info.printerName();
-}
-
-QString PrinterInfoImpl::description() const
-{
-    return m_info.description();
-}
-
-QString PrinterInfoImpl::location() const
-{
-
-}
-
-QString PrinterInfoImpl::makeAndModel() const
-{
-
-}
-
-PrinterEnum::State PrinterInfoImpl::state() const
-{
-
-}
-
-QList<QPageSize> PrinterInfoImpl::supportedPageSizes() const
-{
-    return m_info.supportedPageSizes();
-}
-
-QPageSize PrinterInfoImpl::defaultPageSize() const
-{
-    return m_info.defaultPageSize();
-}
-
-bool PrinterInfoImpl::supportsCustomPageSizes() const
-{
-
-}
-
-QPageSize PrinterInfoImpl::minimumPhysicalPageSize() const
-{
-
-}
-
-QPageSize PrinterInfoImpl::maximumPhysicalPageSize() const
-{
-
-}
-
-QList<int> PrinterInfoImpl::supportedResolutions() const
-{
-
-}
-
-PrinterEnum::DuplexMode PrinterInfoImpl::defaultDuplexMode() const
-{
-    return Utils::qDuplexModeToDuplexMode(m_info.defaultDuplexMode());
-}
-
-QList<PrinterEnum::DuplexMode> PrinterInfoImpl::supportedDuplexModes() const
-{
-    QList<PrinterEnum::DuplexMode> list;
-    Q_FOREACH(const QPrinter::DuplexMode mode, m_info.supportedDuplexModes()) {
-        if (mode != QPrinter::DuplexAuto) {
-            list.append(Utils::qDuplexModeToDuplexMode(mode));
-        }
-    }
-    return list;
-}
-
-QList<PrinterInfo*> PrinterInfoImpl::availablePrinters()
-{
-    QList<PrinterInfo*> list;
-    Q_FOREACH(QPrinterInfo info, QPrinterInfo::availablePrinters()) {
-        list.append(new PrinterInfoImpl(info));
-    }
-    return list;
-}
-
-QStringList PrinterInfoImpl::availablePrinterNames()
-{
-
-}
-
-PrinterInfo* PrinterInfoImpl::printerInfo(const QString &printerName)
-{
-
-}
-
-QString PrinterInfoImpl::defaultPrinterName()
-{
-    return QPrinterInfo::defaultPrinterName();
-}
-
-bool PrinterInfoImpl::isPdf() const
-{
-    return false;
-}
-
-void PrinterInfoImpl::refresh()
-{
-    if (m_printerName.isEmpty()) {
-        m_info = QPrinterInfo();
-    } else {
-        m_info = QPrinterInfo::printerInfo(m_printerName);
-    }
-}

=== removed file 'plugins/Ubuntu/Settings/Printers/printer/printerinfo_impl.h'
--- plugins/Ubuntu/Settings/Printers/printer/printerinfo_impl.h	2017-01-19 17:59:17 +0000
+++ plugins/Ubuntu/Settings/Printers/printer/printerinfo_impl.h	1970-01-01 00:00:00 +0000
@@ -1,62 +0,0 @@
-/*
- * Copyright (C) 2017 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef USC_PRINTERS_PRINTERINFO_IMPL_H
-#define USC_PRINTERS_PRINTERINFO_IMPL_H
-
-#include "cups/cupsfacade.h"
-#include "printer/printerinfo.h"
-
-#include <QPrinterInfo>
-
-class PrinterInfoImpl : public PrinterInfo
-{
-public:
-    explicit PrinterInfoImpl(const QString &name = QString::null);
-    explicit PrinterInfoImpl(QPrinterInfo info);
-    virtual ~PrinterInfoImpl() override;
-
-    virtual bool holdsDefinition() const override;
-
-    virtual QString printerName() const override;
-    virtual QString description() const override;
-    virtual QString location() const override;
-    virtual QString makeAndModel() const override;
-
-    virtual PrinterEnum::State state() const override;
-    virtual QList<QPageSize> supportedPageSizes() const override;
-    virtual QPageSize defaultPageSize() const override;
-    virtual bool supportsCustomPageSizes() const override;
-
-    virtual QPageSize minimumPhysicalPageSize() const override;
-    virtual QPageSize maximumPhysicalPageSize() const override;
-    virtual QList<int> supportedResolutions() const override;
-    virtual PrinterEnum::DuplexMode defaultDuplexMode() const override;
-    virtual QList<PrinterEnum::DuplexMode> supportedDuplexModes() const override;
-    virtual QList<PrinterInfo*> availablePrinters() override;
-    virtual QStringList availablePrinterNames() override;
-    virtual PrinterInfo* printerInfo(const QString &printerName) override;
-    virtual QString defaultPrinterName() override;
-
-    virtual bool isPdf() const override;
-
-    virtual void refresh() override;
-
-private:
-    QPrinterInfo m_info;
-};
-
-#endif // USC_PRINTERS_PRINTERINFO_IMPL_H

=== removed file 'plugins/Ubuntu/Settings/Printers/printer/printerinfo_pdfimpl.cpp'
--- plugins/Ubuntu/Settings/Printers/printer/printerinfo_pdfimpl.cpp	2017-01-19 17:59:17 +0000
+++ plugins/Ubuntu/Settings/Printers/printer/printerinfo_pdfimpl.cpp	1970-01-01 00:00:00 +0000
@@ -1,91 +0,0 @@
-/*
- * Copyright (C) 2017 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "printer/printerinfo_pdfimpl.h"
-
-#include <QPageSize>
-
-PrinterInfoPdfImpl::PrinterInfoPdfImpl(const QString &name) : PrinterInfo(name)
-{
-
-}
-
-PrinterInfoPdfImpl::~PrinterInfoPdfImpl()
-{
-
-}
-
-QList<PrinterInfo*> PrinterInfoPdfImpl::availablePrinters()
-{
-    QList<PrinterInfo*> list;
-    list.append(new PrinterInfoPdfImpl("Create PDF"));
-    return list;
-}
-
-PrinterEnum::DuplexMode PrinterInfoPdfImpl::defaultDuplexMode() const
-{
-    return PrinterEnum::DuplexMode::DuplexNone;
-}
-
-QPageSize PrinterInfoPdfImpl::defaultPageSize() const
-{
-    return QPageSize(QPageSize::A4);
-}
-
-QString PrinterInfoPdfImpl::defaultPrinterName()
-{
-    return "";
-}
-
-QString PrinterInfoPdfImpl::description() const
-{
-    return QStringLiteral("");
-}
-
-bool PrinterInfoPdfImpl::holdsDefinition() const
-{
-    return true;
-}
-
-bool PrinterInfoPdfImpl::isPdf() const
-{
-    return true;
-}
-
-QString PrinterInfoPdfImpl::location() const
-{
-    return QStringLiteral("");
-}
-
-QString PrinterInfoPdfImpl::makeAndModel() const
-{
-    return QStringLiteral("");
-}
-
-QString PrinterInfoPdfImpl::printerName() const
-{
-    return m_printerName;
-}
-
-QList<PrinterEnum::DuplexMode> PrinterInfoPdfImpl::supportedDuplexModes() const
-{
-    return QList<PrinterEnum::DuplexMode>{PrinterEnum::DuplexMode::DuplexNone};
-}
-
-QList<QPageSize> PrinterInfoPdfImpl::supportedPageSizes() const
-{
-    return QList<QPageSize>{QPageSize(QPageSize::A4)};
-}

=== removed file 'plugins/Ubuntu/Settings/Printers/printer/printerinfo_pdfimpl.h'
--- plugins/Ubuntu/Settings/Printers/printer/printerinfo_pdfimpl.h	2017-01-19 17:59:17 +0000
+++ plugins/Ubuntu/Settings/Printers/printer/printerinfo_pdfimpl.h	1970-01-01 00:00:00 +0000
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2017 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef USC_PRINTERS_PRINTERINFO_PDFIMPL_H
-#define USC_PRINTERS_PRINTERINFO_PDFIMPL_H
-
-#include "printer/printerinfo.h"
-
-class PrinterInfoPdfImpl : public PrinterInfo
-{
-public:
-    explicit PrinterInfoPdfImpl(const QString &name = QString::null);
-    virtual ~PrinterInfoPdfImpl() override;
-
-    virtual bool holdsDefinition() const override;
-
-    virtual QString printerName() const override;
-    virtual QString description() const override;
-    virtual QString location() const override;
-    virtual QString makeAndModel() const override;
-
-    virtual PrinterEnum::State state() const override {}
-    virtual QList<QPageSize> supportedPageSizes() const override;
-    virtual QPageSize defaultPageSize() const override;
-    virtual bool supportsCustomPageSizes() const override {}
-
-    virtual QPageSize minimumPhysicalPageSize() const override {}
-    virtual QPageSize maximumPhysicalPageSize() const override {}
-    virtual QList<int> supportedResolutions() const override {}
-    virtual PrinterEnum::DuplexMode defaultDuplexMode() const override;
-    virtual QList<PrinterEnum::DuplexMode> supportedDuplexModes() const override;
-    virtual QList<PrinterInfo*> availablePrinters() override;
-    virtual QStringList availablePrinterNames() override {}
-    virtual PrinterInfo* printerInfo(const QString &printerName) override {}
-    virtual QString defaultPrinterName() override;
-
-    virtual bool isPdf() const override;
-
-    virtual void refresh() override {}
-};
-
-#endif // USC_PRINTERS_PRINTERINFO_PDFIMPL_H

=== modified file 'plugins/Ubuntu/Settings/Printers/printer/printerjob.cpp'
--- plugins/Ubuntu/Settings/Printers/printer/printerjob.cpp	2017-01-19 21:18:36 +0000
+++ plugins/Ubuntu/Settings/Printers/printer/printerjob.cpp	2017-01-23 14:09:24 +0000
@@ -16,46 +16,39 @@
 
 #include <QtCore/QDebug>
 
-#include "cups/cupsfacade_impl.h"
+#include "backend/backend_cups.h"
 #include "models/printermodel.h"
 #include "printer/printerjob.h"
-#include "printer/printerinfo_allimpl.h"
 
 PrinterJob::PrinterJob(QObject *parent)
+    : PrinterJob(Q_NULLPTR, parent)
+{
+}
+
+PrinterJob::PrinterJob(Printer *printer, QObject *parent)
+    : PrinterJob(printer, new PrinterCupsBackend, parent)
+{
+}
+
+PrinterJob::PrinterJob(Printer *printer, PrinterBackend *backend,
+                       QObject *parent)
     : QObject(parent)
     , m_color_model(0)
     , m_copies(1)
-    , m_cups(new CupsFacadeImpl())
+    , m_backend(backend)
     , m_duplex_mode(0)
-    , m_printer(Q_NULLPTR)
+    , m_printer(printer)
     , m_printer_name(QStringLiteral(""))
     , m_print_range(QStringLiteral(""))
     , m_print_range_mode(PrinterEnum::PrintRange::AllPages)
     , m_quality(0)
-    // TODO: Do we need a separate Job state?
-    // NotStarted, InQueue, Processing, Complete, Error ?
-    , m_state(PrinterEnum::State::IdleState)
-    , m_title(QStringLiteral(""))
-{
-
-}
-
-PrinterJob::PrinterJob(Printer *printer, QObject *parent)
-    : QObject(parent)
-    , m_copies(1)
-    , m_cups(new CupsFacadeImpl())
-    , m_printer(printer)
-    , m_printer_name(QStringLiteral(""))
-    , m_print_range(QStringLiteral(""))
-    , m_print_range_mode(PrinterEnum::PrintRange::AllPages)
-    // TODO: Do we need a separate Job state?
-    // NotStarted, InQueue, Processing, Complete, Error ?
     , m_state(PrinterEnum::State::IdleState)
     , m_title(QStringLiteral(""))
 {
     loadDefaults();
 }
 
+
 PrinterJob::~PrinterJob()
 {
 
@@ -88,11 +81,11 @@
 
 ColorModel PrinterJob::getColorModel() const
 {
-    ColorModel ret;
     if (m_printer && colorModel() > -1 && colorModel() < m_printer->supportedColorModels().count()) {
-        ret = m_printer->supportedColorModels().at(colorModel());
+        return m_printer->supportedColorModels().at(colorModel());
+    } else {
+        return ColorModel();
     }
-    return ret;
 }
 
 PrintQuality PrinterJob::getPrintQuality() const
@@ -230,25 +223,19 @@
 
 void PrinterJob::setPrinterName(const QString &printerName)
 {
+    // Please note the return inside the foreach.
     if (m_printer_name != printerName) {
-        PrinterInfo *printers = new PrinterInfoAllImpl();
-        PrinterInfo *info = Q_NULLPTR;
-
-        Q_FOREACH(PrinterInfo *printer, printers->availablePrinters()) {
-            if (printer->printerName() == printerName) {
-                info = printer;
+        Q_FOREACH(Printer *printer, m_backend->availablePrinters()) {
+            if (printer->name() == printerName) {
+                m_printer_name = printerName;
+                m_printer = printer;
+                loadDefaults();
+                Q_EMIT printerNameChanged();
+                return;
             }
         }
 
-        if (info && info->holdsDefinition()) {
-            m_printer_name = printerName;
-            m_printer = new Printer(info, m_cups);
-            loadDefaults();
-
-            Q_EMIT printerNameChanged();
-        } else {
-            qWarning() << "Unknown printer:" << printerName;
-        }
+        qWarning() << "Unknown printer:" << printerName;
     }
 }
 

=== modified file 'plugins/Ubuntu/Settings/Printers/printer/printerjob.h'
--- plugins/Ubuntu/Settings/Printers/printer/printerjob.h	2017-01-19 21:18:36 +0000
+++ plugins/Ubuntu/Settings/Printers/printer/printerjob.h	2017-01-23 14:09:24 +0000
@@ -22,13 +22,13 @@
 #include "enums.h"
 #include "structs.h"
 
-#include "cups/cupsfacade.h"
+#include "backend/backend.h"
 #include "printer/printer.h"
 
 #include <QtCore/QObject>
 
-class CupsFacade;
 class Printer;
+class PrinterBackend;
 
 class PRINTERS_DECL_EXPORT PrinterJob : public QObject
 {
@@ -49,6 +49,8 @@
 public:
     explicit PrinterJob(QObject *parent=Q_NULLPTR);
     explicit PrinterJob(Printer *printer, QObject *parent=Q_NULLPTR);
+    explicit PrinterJob(Printer *printer, PrinterBackend *backend,
+                        QObject *parent=Q_NULLPTR);
     ~PrinterJob();
 
     int colorModel() const;
@@ -98,7 +100,7 @@
 private:
     int m_color_model;
     int m_copies;
-    CupsFacade *m_cups;
+    PrinterBackend *m_backend; // TODO: Maybe use the printer's backend?
     int m_duplex_mode;
     bool m_landscape;
     Printer *m_printer;

=== modified file 'plugins/Ubuntu/Settings/Printers/printers/printers.cpp'
--- plugins/Ubuntu/Settings/Printers/printers/printers.cpp	2017-01-19 20:05:56 +0000
+++ plugins/Ubuntu/Settings/Printers/printers/printers.cpp	2017-01-23 14:09:24 +0000
@@ -14,72 +14,49 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "cups/cupsfacade_impl.h"
-#include "printer/printerinfo_allimpl.h"
+#include "backend/backend_cups.h"
 #include "printers/printers.h"
-#include "printers/printers_p.h"
 
 #include <QQmlEngine>
 
 Printers::Printers(int printerUpdateIntervalMSecs, QObject *parent)
-    : QObject(parent)
-    , d_ptr(new PrintersPrivate(this, printerUpdateIntervalMSecs))
+    : Printers(new PrinterCupsBackend, printerUpdateIntervalMSecs, parent)
 {
 }
 
-Printers::Printers(PrinterInfo *info, CupsFacade *cups,
-                   int printerUpdateIntervalMSecs, QObject *parent)
+Printers::Printers(PrinterBackend *backend, int printerUpdateIntervalMSecs,
+                   QObject *parent)
     : QObject(parent)
-    , d_ptr(new PrintersPrivate(this, info, cups, printerUpdateIntervalMSecs))
+    , m_backend(backend)
+    , m_model(backend, printerUpdateIntervalMSecs)
 {
+    m_allPrinters.setSourceModel(&m_model);
+    m_allPrinters.setSortRole(PrinterModel::Roles::DefaultPrinterRole);
+    m_allPrinters.filterOnPdf(false);
+    m_allPrinters.sort(0, Qt::DescendingOrder);
+
+    m_allPrintersWithPdf.setSourceModel(&m_model);
+    m_allPrintersWithPdf.setSortRole(PrinterModel::Roles::DefaultPrinterRole);
+    m_allPrintersWithPdf.sort(0, Qt::DescendingOrder);
+
+    // Let Qt be in charge of RAII.
+    m_backend->setParent(this);
 }
 
 Printers::~Printers()
 {
 }
 
-PrintersPrivate::PrintersPrivate(Printers *q, int printerUpdateIntervalMSecs)
-    : PrintersPrivate(q, new PrinterInfoAllImpl, new CupsFacadeImpl,
-                      printerUpdateIntervalMSecs)
-{
-}
-
-PrintersPrivate::PrintersPrivate(Printers *q, PrinterInfo *info,
-                                 CupsFacade *cups,
-                                 int printerUpdateIntervalMSecs)
-    : model(info, cups, printerUpdateIntervalMSecs)
-{
-    this->info = info;
-    this->cups = cups;
-
-    allPrinters.setSourceModel(&model);
-    allPrinters.setSortRole(PrinterModel::Roles::DefaultPrinterRole);
-    allPrinters.filterOnPdf(false);
-    allPrinters.sort(0, Qt::DescendingOrder);
-
-    allPrintersWithPdf.setSourceModel(&model);
-    allPrintersWithPdf.setSortRole(PrinterModel::Roles::DefaultPrinterRole);
-    allPrintersWithPdf.sort(0, Qt::DescendingOrder);
-}
-
-PrintersPrivate::~PrintersPrivate()
-{
-    delete cups;
-    delete info;
-}
-
 QAbstractItemModel* Printers::allPrinters()
 {
-    Q_D(Printers);
-    auto ret = &d->allPrinters;
+    auto ret = &m_allPrinters;
     QQmlEngine::setObjectOwnership(ret, QQmlEngine::CppOwnership);
     return ret;
 }
 
 QAbstractItemModel* Printers::allPrintersWithPdf()
 {
-    Q_D(Printers);
-    auto ret = &d->allPrintersWithPdf;
+    auto ret = &m_allPrintersWithPdf;
     QQmlEngine::setObjectOwnership(ret, QQmlEngine::CppOwnership);
     return ret;
 }

=== modified file 'plugins/Ubuntu/Settings/Printers/printers/printers.h'
--- plugins/Ubuntu/Settings/Printers/printers/printers.h	2017-01-19 17:59:17 +0000
+++ plugins/Ubuntu/Settings/Printers/printers/printers.h	2017-01-23 14:09:24 +0000
@@ -22,7 +22,6 @@
 #include "cups/cupsfacade.h"
 #include "models/printermodel.h"
 #include "printer/printer.h"
-#include "printer/printerinfo.h"
 
 #include <QAbstractItemModel>
 #include <QObject>
@@ -31,24 +30,20 @@
 #include <QString>
 #include <QUrl>
 
-class PrintersPrivate;
 class PRINTERS_DECL_EXPORT Printers : public QObject
 {
     Q_OBJECT
-    Q_DECLARE_PRIVATE(Printers)
     Q_PROPERTY(QAbstractItemModel* allPrinters READ allPrinters CONSTANT)
     Q_PROPERTY(QAbstractItemModel* allPrintersWithPdf READ allPrintersWithPdf CONSTANT)
     Q_PROPERTY(QAbstractItemModel* recentPrinters READ recentPrinters CONSTANT)
     Q_PROPERTY(QAbstractItemModel* printJobs READ printJobs CONSTANT)
     Q_PROPERTY(QString defaultPrinterName READ defaultPrinterName WRITE setDefaultPrinterName NOTIFY defaultPrinterNameChanged)
 
-    QScopedPointer<PrintersPrivate> const d_ptr;
-
 public:
     explicit Printers(int printerUpdateIntervalMSecs = 5000, QObject *parent = nullptr);
 
-    // Printers takes ownership of info and cups objects.
-    explicit Printers(PrinterInfo *info, CupsFacade *cups,
+    // Note: Printers takes ownership of backend.
+    explicit Printers(PrinterBackend *backend,
                       int printerUpdateIntervalMSecs = 5000,
                       QObject *parent = nullptr);
     ~Printers();
@@ -80,6 +75,13 @@
 
 Q_SIGNALS:
     void defaultPrinterNameChanged();
+
+private:
+    PrinterBackend *m_backend;
+    PrinterModel m_model;
+    PrinterFilter m_allPrinters;
+    PrinterFilter m_allPrintersWithPdf;
+    PrinterFilter m_recentPrinters;
 };
 
 #endif // USC_PRINTERS_H

=== removed file 'plugins/Ubuntu/Settings/Printers/printers/printers_p.h'
--- plugins/Ubuntu/Settings/Printers/printers/printers_p.h	2017-01-19 17:59:17 +0000
+++ plugins/Ubuntu/Settings/Printers/printers/printers_p.h	1970-01-01 00:00:00 +0000
@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2017 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef USC_PRINTERS_PRIVATE_H
-#define USC_PRINTERS_PRIVATE_H
-
-#include "models/printermodel.h"
-
-struct PrintersPrivate
-{
-    Q_DISABLE_COPY(PrintersPrivate)
-    Q_DECLARE_PUBLIC(Printers)
-    explicit PrintersPrivate(Printers *q, int printerUpdateIntervalMSecs);
-    explicit PrintersPrivate(Printers *q, PrinterInfo *info, CupsFacade *cups,
-                             int printerUpdateIntervalMSecs);
-    ~PrintersPrivate();
-    CupsFacade *cups;
-    Printers *q_ptr;
-    PrinterInfo *info;
-    PrinterModel model;
-    PrinterFilter allPrinters;
-    PrinterFilter allPrintersWithPdf;
-    PrinterFilter recentPrinters;
-};
-
-#endif // USC_PRINTERS_PRIVATE_H

=== modified file 'tests/unittests/Printers/CMakeLists.txt'
--- tests/unittests/Printers/CMakeLists.txt	2017-01-19 11:16:13 +0000
+++ tests/unittests/Printers/CMakeLists.txt	2017-01-23 14:09:24 +0000
@@ -6,8 +6,7 @@
 find_package(Qt5Test REQUIRED)
 
 set(MOCK_SOURCES
-    mockcupsfacade.h
-    mockprinterinfo.h
+    mockbackend.h
 )
 
 add_executable(testPrintersPrinter tst_printer.cpp ${MOCK_SOURCES})

=== added file 'tests/unittests/Printers/mockbackend.h'
--- tests/unittests/Printers/mockbackend.h	1970-01-01 00:00:00 +0000
+++ tests/unittests/Printers/mockbackend.h	2017-01-23 14:09:24 +0000
@@ -0,0 +1,375 @@
+/*
+ * Copyright (C) 2017 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef USC_PRINTERS_MOCK_BACKEND_H
+#define USC_PRINTERS_MOCK_BACKEND_H
+
+#include "backend/backend.h"
+
+class MockPrinterBackend : public PrinterBackend
+{
+    Q_OBJECT
+public:
+    explicit MockPrinterBackend(QObject *parent = Q_NULLPTR) : PrinterBackend(parent) {};
+    explicit MockPrinterBackend(const QString &printerName,
+                                QObject *parent = Q_NULLPTR)
+      : PrinterBackend(printerName, parent) {};
+    virtual ~MockPrinterBackend() {};
+
+    virtual bool holdsDefinition() const override
+    {
+
+    }
+
+    virtual QString printerAdd(const QString &name,
+                               const QUrl &uri,
+                               const QUrl &ppdFile,
+                               const QString &info,
+                               const QString &location) override
+    {
+        Q_UNUSED(name);
+        Q_UNUSED(uri);
+        Q_UNUSED(ppdFile);
+        Q_UNUSED(info);
+        Q_UNUSED(location);
+        return returnValue;
+    }
+
+    virtual QString printerAddWithPpd(const QString &name,
+                                      const QUrl &uri,
+                                      const QString &ppdFileName,
+                                      const QString &info,
+                                      const QString &location) override
+    {
+        Q_UNUSED(name);
+        Q_UNUSED(uri);
+        Q_UNUSED(ppdFileName);
+        Q_UNUSED(info);
+        Q_UNUSED(location);
+        return returnValue;
+    }
+
+    virtual QString printerDelete(const QString &name) override
+    {
+        Q_UNUSED(name);
+        return returnValue;
+    }
+
+    virtual QString printerSetEnabled(const QString &name,
+                                      const bool enabled) override
+    {
+        enableds.insert(name, enabled);
+        return returnValue;
+    }
+
+    virtual QString printerSetAcceptJobs(
+        const QString &name,
+        const bool enabled,
+        const QString &reason = QString::null) override
+    {
+        Q_UNUSED(name);
+        return returnValue;
+    }
+
+    virtual QString printerSetInfo(const QString &name,
+                                   const QString &info) override
+    {
+        infos.insert(name, info);
+        return returnValue;
+    }
+
+    virtual QString printerSetLocation(const QString &name,
+                                       const QString &location) override
+    {
+        locations.insert(name, location);
+        return returnValue;
+    }
+
+    virtual QString printerSetShared(const QString &name,
+                                     const bool shared) override
+    {
+        shareds.insert(name, shared);
+        return returnValue;
+    }
+
+    virtual QString printerSetJobSheets(const QString &name,
+                                        const QString &start,
+                                        const QString &end) override
+    {
+        Q_UNUSED(name);
+        Q_UNUSED(start);
+        Q_UNUSED(end);
+        return returnValue;
+    }
+
+    virtual QString printerSetErrorPolicy(const QString &name,
+                                          const PrinterEnum::ErrorPolicy &policy) override
+    {
+        errorPolicies.insert(name, policy);
+        return returnValue;
+    }
+
+
+    virtual QString printerSetOpPolicy(const QString &name,
+                                       const PrinterEnum::OperationPolicy &policy) override
+    {
+        operationPolicies.insert(name, policy);
+        return returnValue;
+    }
+
+    virtual QString printerSetUsersAllowed(const QString &name,
+                                           const QStringList &users) override
+    {
+        printerOptions[name].insert("users-allowed", QVariant::fromValue(users));
+        return returnValue;
+    }
+
+    virtual QString printerSetUsersDenied(const QString &name,
+                                          const QStringList &users) override
+    {
+        printerOptions[name].insert("users-denied", QVariant::fromValue(users));
+        return returnValue;
+    }
+
+    virtual QString printerAddOptionDefault(const QString &name,
+                                            const QString &option,
+                                            const QStringList &values) override
+    {
+        Q_UNUSED(name);
+        Q_UNUSED(option);
+        Q_UNUSED(values);
+        return returnValue;
+    }
+
+    virtual QString printerDeleteOptionDefault(const QString &name,
+                                               const QString &value) override
+    {
+        Q_UNUSED(name);
+        Q_UNUSED(value);
+        return returnValue;
+    }
+
+    virtual QString printerAddOption(const QString &name,
+                                     const QString &option,
+                                     const QStringList &values) override
+    {
+        printerOptions[name].insert(option, values);
+        return returnValue;
+    }
+
+
+    // TODO: const for both these getters (if possible)!
+    virtual QVariant printerGetOption(const QString &name,
+                                      const QString &option) const override
+    {
+        // FIXME: if we're to return a variant, check that it can be converted
+        return printerOptions[name].value(option);
+    }
+
+    virtual QMap<QString, QVariant> printerGetOptions(
+        const QString &name, const QStringList &options
+    ) override
+    {
+        QMap<QString, QVariant> opts;
+        Q_FOREACH(const QString &option, options) {
+            opts[option] = printerGetOption(name, option);
+        }
+        return opts;
+    }
+
+    // FIXME: maybe have a PrinterDest iface that has a CupsDest impl?
+    virtual cups_dest_t* makeDest(const QString &name,
+                                  const PrinterJob *options) override
+    {
+
+    }
+
+
+    virtual QList<ColorModel> printerGetSupportedColorModels(
+        const QString &name) const override
+    {
+        return printerOptions[name].value("ColorModels").value<QList<ColorModel>>();
+    }
+
+    virtual QList<PrintQuality> printerGetSupportedQualities(
+        const QString &name) const override
+    {
+        return printerOptions[name].value("PrintQualities").value<QList<PrintQuality>>();
+    }
+
+    virtual int printFileToDest(const QString &filepath,
+                                const QString &title,
+                                const cups_dest_t *dest) override
+    {
+
+    }
+
+
+    virtual QString printerName() const override
+    {
+        return m_printerName;
+    }
+
+    virtual QString description() const override
+    {
+        return m_description;
+    }
+
+    virtual QString location() const override
+    {
+        return m_location;
+    }
+
+    virtual QString makeAndModel() const override
+    {
+        return m_makeAndModel;
+    }
+
+    virtual PrinterEnum::State state() const override
+    {
+        return m_state;
+    }
+
+    virtual QList<QPageSize> supportedPageSizes() const override
+    {
+        return m_supportedPageSizes;
+    }
+
+    virtual QPageSize defaultPageSize() const override
+    {
+        return m_defaultPageSize;
+    }
+
+    virtual bool supportsCustomPageSizes() const override
+    {
+
+    }
+
+
+    virtual QPageSize minimumPhysicalPageSize() const override
+    {
+
+    }
+
+    virtual QPageSize maximumPhysicalPageSize() const override
+    {
+
+    }
+
+    virtual QList<int> supportedResolutions() const override
+    {
+
+    }
+
+    virtual PrinterEnum::DuplexMode defaultDuplexMode() const override
+    {
+        return m_defaultDuplexMode;
+    }
+
+    virtual QList<PrinterEnum::DuplexMode> supportedDuplexModes() const override
+    {
+        return m_supportedDuplexModes;
+    }
+
+    virtual QList<Printer*> availablePrinters() override
+    {
+        return m_availablePrinters;
+    }
+
+    virtual QStringList availablePrinterNames() override
+    {
+        return m_availablePrinterNames;
+    }
+
+    virtual Printer* getPrinter(const QString &printerName) override
+    {
+        Q_FOREACH(Printer* p, m_availablePrinters) {
+            if (p->name() == printerName) {
+                return p;
+            }
+        }
+        return Q_NULLPTR;
+    }
+
+    virtual QString defaultPrinterName() override
+    {
+        return m_defaultPrinterName;
+    }
+
+    virtual BackendType backendType() const override
+    {
+        return m_backendType;
+    }
+
+
+    void mockPrinterAdded(const QString &name)
+    {
+        Q_EMIT printerAdded(name);
+    }
+
+    void mockPrinterModified(const QString &name, const bool ppdChanged)
+    {
+        Q_EMIT printerModified(name, ppdChanged);
+    }
+
+    void mockPrinterDeleted(const QString &name)
+    {
+        Q_EMIT printerDeleted(name);
+    }
+
+    void mockPrinterStateChanged(const QString &name)
+    {
+        Q_EMIT printerStateChanged(name);
+    }
+
+public Q_SLOT:
+    virtual void refresh() override
+    {
+
+    }
+
+    QString returnValue = QString::null;
+
+    // Map from printer to key/val.
+    QMap<QString, QMap<QString, QVariant>> printerOptions;
+
+    QMap<QString, bool> enableds;
+    QMap<QString, bool> shareds;
+    QMap<QString, QString> infos;
+    QMap<QString, QString> locations;
+    QMap<QString, PrinterEnum::ErrorPolicy> errorPolicies;
+    QMap<QString, PrinterEnum::OperationPolicy> operationPolicies;
+
+    QString m_description = QString::null;
+    QString m_location = QString::null;
+    QString m_makeAndModel = QString::null;
+    QString m_defaultPrinterName = QString::null;
+
+    PrinterEnum::State m_state = PrinterEnum::State::IdleState;
+
+    QPageSize m_defaultPageSize;
+    QList<QPageSize> m_supportedPageSizes;
+
+    QList<PrinterEnum::DuplexMode> m_supportedDuplexModes;
+    PrinterEnum::DuplexMode m_defaultDuplexMode;
+
+    QStringList m_availablePrinterNames;
+    QList<Printer*> m_availablePrinters;
+    PrinterBackend::BackendType m_backendType;
+
+};
+
+#endif // USC_PRINTERS_MOCK_BACKEND_H

=== modified file 'tests/unittests/Printers/tst_printer.cpp'
--- tests/unittests/Printers/tst_printer.cpp	2017-01-19 21:12:23 +0000
+++ tests/unittests/Printers/tst_printer.cpp	2017-01-23 14:09:24 +0000
@@ -16,10 +16,10 @@
 
 #include "utils.h"
 
-#include "mockcupsfacade.h"
-#include "mockprinterinfo.h"
+#include "mockbackend.h"
 
-#include "cups/cupsfacade.h"
+#include "backend/backend.h"
+#include "backend/backend_pdf.h"
 #include "printer/printer.h"
 
 #include <QDebug>
@@ -35,31 +35,30 @@
 private Q_SLOTS:
     void init()
     {
-        m_mockcups = new MockCupsFacade;
-        m_mockinfo = new MockPrinterInfo(m_printerName);
-        m_instance = new Printer(m_mockinfo, m_mockcups);
+        m_backend = new MockPrinterBackend(m_printerName);
+        m_instance = new Printer(m_backend);
     }
     void cleanup()
     {
         QSignalSpy destroyedSpy(m_instance, SIGNAL(destroyed(QObject*)));
         m_instance->deleteLater();
         QTRY_COMPARE(destroyedSpy.count(), 1);
-        delete m_mockcups;
+        delete m_backend;
     }
     void testName()
     {
-        QCOMPARE(m_mockinfo->printerName(), m_instance->name());
+        QCOMPARE(m_backend->printerName(), m_instance->name());
     }
     void testDescription()
     {
-        ((MockPrinterInfo*) m_mockinfo)->m_description = "some description";
-        QCOMPARE(m_mockinfo->description(), m_instance->description());
+        getBackend()->m_description = "some description";
+        QCOMPARE(m_backend->description(), m_instance->description());
     }
     void testSetDescription()
     {
         QString desc("another description");
         m_instance->setDescription(desc);
-        QCOMPARE(((MockCupsFacade*) m_mockcups)->infos.value(m_printerName), desc);
+        QCOMPARE(getBackend()->infos.value(m_printerName), desc);
     }
     void testSupportedDuplexModes_data()
     {
@@ -80,48 +79,36 @@
     {
         QFETCH(QList<PrinterEnum::DuplexMode>, modes);
         QFETCH(QStringList, strings);
-        ((MockPrinterInfo*) m_mockinfo)->m_supportedDuplexModes = modes;
+        getBackend()->m_supportedDuplexModes = modes;
         QCOMPARE(m_instance->supportedDuplexModes(), modes);
         QCOMPARE(m_instance->supportedDuplexStrings(), strings);
     }
     void testDefaultDuplexMode()
     {
-        ((MockPrinterInfo*) m_mockinfo)->m_defaultDuplexMode = PrinterEnum::DuplexMode::DuplexLongSide;
+        getBackend()->m_defaultDuplexMode = PrinterEnum::DuplexMode::DuplexLongSide;
         QCOMPARE(m_instance->defaultDuplexMode(), PrinterEnum::DuplexMode::DuplexLongSide);
-        ((MockPrinterInfo*) m_mockinfo)->m_defaultDuplexMode = PrinterEnum::DuplexMode::DuplexNone;
+        getBackend()->m_defaultDuplexMode = PrinterEnum::DuplexMode::DuplexNone;
         QCOMPARE(m_instance->defaultDuplexMode(), PrinterEnum::DuplexMode::DuplexNone);
-        ((MockPrinterInfo*) m_mockinfo)->m_defaultDuplexMode = PrinterEnum::DuplexMode::DuplexShortSide;
+        getBackend()->m_defaultDuplexMode = PrinterEnum::DuplexMode::DuplexShortSide;
         QCOMPARE(m_instance->defaultDuplexMode(), PrinterEnum::DuplexMode::DuplexShortSide);
     }
     void testSetDefaultDuplexMode()
     {
-        ((MockPrinterInfo*) m_mockinfo)->m_defaultDuplexMode = PrinterEnum::DuplexMode::DuplexNone;
+        getBackend()->m_defaultDuplexMode = PrinterEnum::DuplexMode::DuplexNone;
 
         // Add support
         QList<PrinterEnum::DuplexMode> modes({PrinterEnum::DuplexMode::DuplexNone, PrinterEnum::DuplexMode::DuplexLongSide});
-        ((MockPrinterInfo*) m_mockinfo)->m_supportedDuplexModes = modes;
+        getBackend()->m_supportedDuplexModes = modes;
 
         m_instance->setDefaultDuplexMode(PrinterEnum::DuplexMode::DuplexLongSide);
 
-        QVariant duplexVar = ((MockCupsFacade*) m_mockcups)->printerOptions[m_printerName].value("Duplex");
+        QVariant duplexVar = getBackend()->printerOptions[m_printerName].value("Duplex");
         QStringList duplexVals = duplexVar.toStringList();
          QCOMPARE(
             duplexVals.at(0),
             (QString) Utils::duplexModeToPpdChoice(PrinterEnum::DuplexMode::DuplexLongSide)
         );
     }
-    void testDefaultPageSize()
-    {
-        auto targetSize = QPageSize(QPageSize::A4);
-        ((MockPrinterInfo*) m_mockinfo)->m_defaultPageSize = targetSize;
-        QCOMPARE(m_instance->defaultPageSize(), targetSize);
-    }
-    void testSupportedPageSizes_data()
-    {
-        auto supported = QList<QPageSize>({QPageSize(QPageSize::A4), QPageSize(QPageSize::Letter)});
-        ((MockPrinterInfo*) m_mockinfo)->m_supportedPageSizes = supported;
-        QCOMPARE(m_instance->supportedPageSizes(), supported);
-    }
     void testSetDefaultPageSize_data()
     {
         QTest::addColumn<QList<QPageSize>>("sizes");
@@ -144,17 +131,29 @@
             QTest::newRow("supported, but non-ppd size") << sizes << custom << false << "";
         }
     }
+    void testDefaultPageSize()
+    {
+        auto targetSize = QPageSize(QPageSize::A4);
+        getBackend()->m_defaultPageSize = targetSize;
+        QCOMPARE(m_instance->defaultPageSize(), targetSize);
+    }
+    void testSupportedPageSizes_data()
+    {
+        auto supported = QList<QPageSize>({QPageSize(QPageSize::A4), QPageSize(QPageSize::Letter)});
+        getBackend()->m_supportedPageSizes = supported;
+        QCOMPARE(m_instance->supportedPageSizes(), supported);
+    }
     void testSetDefaultPageSize()
     {
         QFETCH(QList<QPageSize>, sizes);
         QFETCH(QPageSize, size);
         QFETCH(bool, expectCupsCommunication);
         QFETCH(QString, expectedValue);
-        ((MockPrinterInfo*) m_mockinfo)->m_supportedPageSizes = sizes;
+        getBackend()->m_supportedPageSizes = sizes;
 
         m_instance->setDefaultPageSize(size);
 
-        QVariant pageSizeVar = ((MockCupsFacade*) m_mockcups)->printerOptions[m_printerName].value("PageSize");
+        QVariant pageSizeVar = getBackend()->printerOptions[m_printerName].value("PageSize");
         QStringList pageSizeVals = pageSizeVar.toStringList();
 
         if (expectCupsCommunication) {
@@ -175,11 +174,10 @@
         b.text = "RBG";
         QList<ColorModel> models({a, b});
 
-        PrinterInfo *info = new MockPrinterInfo(m_printerName);
-        CupsFacade *cups = new MockCupsFacade;
-        ((MockCupsFacade*) cups)->printerOptions[m_printerName].insert(
+        PrinterBackend *backend = new MockPrinterBackend(m_printerName);
+        ((MockPrinterBackend*) backend)->printerOptions[m_printerName].insert(
             "ColorModels", QVariant::fromValue(models));
-        Printer p(info, cups);
+        Printer p(backend);
         QCOMPARE(p.supportedColorModels(), models);
     }
     void testDefaultPrintQuality()
@@ -196,11 +194,10 @@
         b.name = "Worse";
         QList<PrintQuality> qualities({a, b});
 
-        PrinterInfo *info = new MockPrinterInfo(m_printerName);
-        CupsFacade *cups = new MockCupsFacade;
-        ((MockCupsFacade*) cups)->printerOptions[m_printerName].insert(
+        PrinterBackend *backend = new MockPrinterBackend(m_printerName);
+        ((MockPrinterBackend*) backend)->printerOptions[m_printerName].insert(
             "PrintQualities", QVariant::fromValue(qualities));
-        Printer p(info, cups);
+        Printer p(backend);
         QCOMPARE(p.supportedPrintQualities(), qualities);
     }
     void testIsDefault_data()
@@ -212,14 +209,26 @@
     void testIsDefault()
     {
         QFETCH(bool, isDefault);
-        ((MockPrinterInfo*) m_mockinfo)->m_defaultPrinterName = isDefault ? m_printerName : "some-other";
+        getBackend()->m_defaultPrinterName = isDefault ? m_printerName : "some-other";
         QCOMPARE(m_instance->isDefault(), isDefault);
     }
+    void testPdfPrinter()
+    {
+        PrinterBackend *backend = new PrinterPdfBackend(m_printerName);
+        Printer p(backend);
+        QCOMPARE(p.defaultColorModel().name, QString("RGB"));
+        QCOMPARE(p.defaultPageSize(), QPageSize(QPageSize::A4));
+        QCOMPARE(p.defaultDuplexMode(), PrinterEnum::DuplexMode::DuplexNone);
+        QCOMPARE(p.isPdf(), true);
+
+    }
 private:
     QString m_printerName = "my-printer";
-    CupsFacade *m_mockcups = nullptr;
+    PrinterBackend *m_backend = nullptr;
     Printer *m_instance = nullptr;
-    PrinterInfo *m_mockinfo = nullptr;
+    MockPrinterBackend* getBackend() {
+        return (MockPrinterBackend*) m_backend;
+    }
 };
 
 QTEST_GUILESS_MAIN(TestPrinter)

=== modified file 'tests/unittests/Printers/tst_printerfilter.cpp'
--- tests/unittests/Printers/tst_printerfilter.cpp	2017-01-19 11:16:13 +0000
+++ tests/unittests/Printers/tst_printerfilter.cpp	2017-01-23 14:09:24 +0000
@@ -14,8 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "mockcupsfacade.h"
-#include "mockprinterinfo.h"
+#include "mockbackend.h"
 
 #include "models/printermodel.h"
 
@@ -24,8 +23,7 @@
 #include <QScopedPointer>
 #include <QTest>
 
-Q_DECLARE_METATYPE(CupsFacade*)
-Q_DECLARE_METATYPE(PrinterInfo*)
+Q_DECLARE_METATYPE(PrinterBackend*)
 Q_DECLARE_METATYPE(PrinterJob*)
 
 class TestPrinterFilter : public QObject
@@ -34,9 +32,8 @@
 private Q_SLOTS:
     void testEmptyCount()
     {
-        QScopedPointer<CupsFacade> cups(new MockCupsFacade);
-        QScopedPointer<PrinterInfo> info(new MockPrinterInfo);
-        PrinterModel model(info.data(), cups.data(), 100);
+        QScopedPointer<PrinterBackend> backend(new MockPrinterBackend);
+        PrinterModel model(backend.data(), 100);
 
         PrinterFilter filter;
         filter.setSourceModel(&model);
@@ -44,14 +41,15 @@
     }
     void testNonEmptyCount()
     {
-        QScopedPointer<CupsFacade> cups(new MockCupsFacade);
-        QScopedPointer<PrinterInfo> info(new MockPrinterInfo);
-        PrinterModel model(info.data(), cups.data(), 100);
-
-        PrinterInfo* printerA = new MockPrinterInfo("a-printer");
-        PrinterInfo* printerB = new MockPrinterInfo("b-printer");
-
-        ((MockPrinterInfo*) info.data())->m_availablePrinters << printerA << printerB;
+        QScopedPointer<PrinterBackend> backend(new MockPrinterBackend);
+        PrinterModel model(backend.data(), 100);
+
+        PrinterBackend* printerABackend = new MockPrinterBackend("a-printer");
+        PrinterBackend* printerBBackend = new MockPrinterBackend("b-printer");
+        Printer printerA(printerABackend);
+        Printer printerB(printerBBackend);
+
+        ((MockPrinterBackend*) backend.data())->m_availablePrinters << &printerA << &printerB;
 
         PrinterFilter filter;
         filter.setSourceModel(&model);
@@ -60,14 +58,15 @@
     }
     void testCountChanged()
     {
-        QScopedPointer<CupsFacade> cups(new MockCupsFacade);
-        QScopedPointer<PrinterInfo> info(new MockPrinterInfo);
-        PrinterModel model(info.data(), cups.data(), 100);
-
-        PrinterInfo* printerA = new MockPrinterInfo("a-printer");
-        PrinterInfo* printerB = new MockPrinterInfo("b-printer");
-
-        ((MockPrinterInfo*) info.data())->m_availablePrinters << printerA << printerB;
+        QScopedPointer<PrinterBackend> backend(new MockPrinterBackend);
+        PrinterModel model(backend.data(), 100);
+
+        PrinterBackend* printerABackend = new MockPrinterBackend("a-printer");
+        PrinterBackend* printerBBackend = new MockPrinterBackend("b-printer");
+        Printer printerA(printerABackend);
+        Printer printerB(printerBBackend);
+
+        ((MockPrinterBackend*) backend.data())->m_availablePrinters << &printerA << &printerB;
 
         PrinterFilter filter;
         filter.setSourceModel(&model);

=== modified file 'tests/unittests/Printers/tst_printerjob.cpp'
--- tests/unittests/Printers/tst_printerjob.cpp	2017-01-18 14:35:30 +0000
+++ tests/unittests/Printers/tst_printerjob.cpp	2017-01-23 14:09:24 +0000
@@ -16,10 +16,9 @@
 
 #include "utils.h"
 
-#include "mockcupsfacade.h"
-#include "mockprinterinfo.h"
+#include "mockbackend.h"
 
-#include "cups/cupsfacade.h"
+#include "backend/backend.h"
 #include "printer/printer.h"
 #include "printer/printerjob.h"
 
@@ -36,10 +35,9 @@
 private Q_SLOTS:
     void init()
     {
-        m_mock_cups = new MockCupsFacade;
-        m_mock_info = new MockPrinterInfo(m_printer_name);
-        m_mock_printer = new Printer(m_mock_info, m_mock_cups);
-        m_instance = new PrinterJob(m_mock_printer);
+        m_backend = new MockPrinterBackend(m_printer_name);
+        m_mock_printer = new Printer(m_backend);
+        m_instance = new PrinterJob(m_mock_printer, m_backend);
     }
     void cleanup()
     {
@@ -51,7 +49,7 @@
         m_mock_printer->deleteLater();
         QTRY_COMPARE(destroyedSpy.count(), 1);
 
-        delete m_mock_cups;
+        delete m_backend;
     }
     void refreshInstance()
     {
@@ -59,7 +57,7 @@
         m_instance->deleteLater();
         QTRY_COMPARE(destroyedSpy.count(), 1);
 
-        m_instance = new PrinterJob(m_mock_printer);
+        m_instance = new PrinterJob(m_mock_printer, m_backend);
     }
 
     void testCancel()
@@ -109,9 +107,9 @@
                 PrinterEnum::DuplexMode::DuplexLongSide,
                 PrinterEnum::DuplexMode::DuplexShortSide
         };
-        ((MockPrinterInfo *) m_mock_info)->m_supportedDuplexModes = modes;
+        ((MockPrinterBackend *) m_backend)->m_supportedDuplexModes = modes;
 
-        ((MockPrinterInfo *) m_mock_info)->m_defaultDuplexMode = PrinterEnum::DuplexMode::DuplexNone;
+        ((MockPrinterBackend *) m_backend)->m_defaultDuplexMode = PrinterEnum::DuplexMode::DuplexNone;
         refreshInstance();
         QCOMPARE(m_instance->duplexMode(), modes.indexOf(PrinterEnum::DuplexMode::DuplexNone));
         QCOMPARE(m_instance->getDuplexMode(), PrinterEnum::DuplexMode::DuplexNone);
@@ -120,7 +118,7 @@
         QCOMPARE(m_instance->duplexMode(), modes.indexOf(PrinterEnum::DuplexMode::DuplexLongSide));
         QCOMPARE(m_instance->getDuplexMode(), PrinterEnum::DuplexMode::DuplexLongSide);
 
-        ((MockPrinterInfo *) m_mock_info)->m_defaultDuplexMode = PrinterEnum::DuplexMode::DuplexShortSide;
+        ((MockPrinterBackend *) m_backend)->m_defaultDuplexMode = PrinterEnum::DuplexMode::DuplexShortSide;
         refreshInstance();
         QCOMPARE(m_instance->duplexMode(), modes.indexOf(PrinterEnum::DuplexMode::DuplexShortSide));
         QCOMPARE(m_instance->getDuplexMode(), PrinterEnum::DuplexMode::DuplexShortSide);
@@ -160,8 +158,7 @@
     }
 private:
     PrinterJob *m_instance = nullptr;
-    CupsFacade *m_mock_cups = nullptr;
-    PrinterInfo *m_mock_info = nullptr;
+    PrinterBackend *m_backend = nullptr;
     Printer *m_mock_printer = nullptr;
     QString m_printer_name = "my-printer";
 };

=== modified file 'tests/unittests/Printers/tst_printermodel.cpp'
--- tests/unittests/Printers/tst_printermodel.cpp	2017-01-19 11:42:11 +0000
+++ tests/unittests/Printers/tst_printermodel.cpp	2017-01-23 14:09:24 +0000
@@ -14,10 +14,9 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "mockcupsfacade.h"
-#include "mockprinterinfo.h"
+#include "mockbackend.h"
 
-#include "cups/cupsfacade.h"
+#include "backend/backend.h"
 #include "models/printermodel.h"
 #include "printer/printer.h"
 #include "printer/printerjob.h"
@@ -27,8 +26,7 @@
 #include <QSignalSpy>
 #include <QTest>
 
-Q_DECLARE_METATYPE(CupsFacade*)
-Q_DECLARE_METATYPE(PrinterInfo*)
+Q_DECLARE_METATYPE(PrinterBackend*)
 Q_DECLARE_METATYPE(PrinterJob*)
 
 class TestPrinterModel : public QObject
@@ -37,49 +35,42 @@
 private Q_SLOTS:
     void init()
     {
-        m_mock_cups = new MockCupsFacade;
-        m_mock_info = new MockPrinterInfo;
-        m_model = new PrinterModel(m_mock_info, m_mock_cups, 100);
+        m_backend = new MockPrinterBackend;
+        m_model = new PrinterModel(m_backend, 100);
     }
     void cleanup()
     {
         QSignalSpy destroyedSpy(m_model, SIGNAL(destroyed(QObject*)));
         m_model->deleteLater();
         QTRY_COMPARE(destroyedSpy.count(), 1);
-
-        delete m_mock_info;
-        delete m_mock_cups;
+        delete m_backend;
     }
     void testInstantiation_data()
     {
-        QTest::addColumn<CupsFacade*>("cups");
-        QTest::addColumn<PrinterInfo*>("info");
+        QTest::addColumn<PrinterBackend*>("backend");
         QTest::addColumn<int>("targetCount");
 
         {
-            CupsFacade* cups = new MockCupsFacade;
-            PrinterInfo* info = new MockPrinterInfo;
-            QTest::newRow("no printers") << cups << info << 0;
+            PrinterBackend* backend = new MockPrinterBackend;
+            QTest::newRow("no printers") << backend  << 0;
         }
         {
-            CupsFacade* cups = new MockCupsFacade;
-            PrinterInfo* info = new MockPrinterInfo;
-
-            PrinterInfo* printerA = new MockPrinterInfo("a-printer");
-            PrinterInfo* printerB = new MockPrinterInfo("b-printer");
-
-            ((MockPrinterInfo*) info)->m_availablePrinters << printerA;
-
-            QTest::newRow("some printers") << cups << info << 1;
+            PrinterBackend* backend = new MockPrinterBackend;
+
+            PrinterBackend *printerABackend = new MockPrinterBackend("a-printer");
+            Printer* printerA = new Printer(printerABackend);
+
+            ((MockPrinterBackend*) backend)->m_availablePrinters << printerA;
+
+            QTest::newRow("some printers") << backend << 1;
         }
     }
     void testInstantiation()
     {
-        QFETCH(CupsFacade*, cups);
-        QFETCH(PrinterInfo*, info);
+        QFETCH(PrinterBackend*, backend);
         QFETCH(int, targetCount);
 
-        PrinterModel model(info, cups);
+        PrinterModel model(backend);
         QCOMPARE(model.count(), targetCount);
     }
     void testUpdateInsert()
@@ -87,8 +78,9 @@
         QSignalSpy countSpy(m_model, SIGNAL(countChanged()));
         QSignalSpy insertSpy(m_model, SIGNAL(rowsInserted(const QModelIndex&, int, int)));
 
-        PrinterInfo* printerA = new MockPrinterInfo("a-printer");
-        ((MockPrinterInfo*) m_mock_info)->m_availablePrinters << printerA;
+        PrinterBackend* printerABackend = new MockPrinterBackend("a-printer");
+        Printer* printerA = new Printer(printerABackend);
+        ((MockPrinterBackend*) m_backend)->m_availablePrinters << printerA;
 
         QTRY_COMPARE_WITH_TIMEOUT(m_model->count(), 1, 500);
         QCOMPARE(countSpy.count(), 1);
@@ -102,16 +94,18 @@
     void testUpdateMove()
     {
         // Setup two printers
-        PrinterInfo* printerA = new MockPrinterInfo("a-printer");
-        PrinterInfo* printerB = new MockPrinterInfo("b-printer");
-        ((MockPrinterInfo*) m_mock_info)->m_availablePrinters << printerA << printerB;
+        PrinterBackend* printerABackend = new MockPrinterBackend("a-printer");
+        Printer* printerA = new Printer(printerABackend);
+        PrinterBackend* printerBBackend = new MockPrinterBackend("b-printer");
+        Printer* printerB = new Printer(printerBBackend);
+        ((MockPrinterBackend*) m_backend)->m_availablePrinters << printerA << printerB;
 
         QTRY_COMPARE_WITH_TIMEOUT(m_model->count(), 2, 500);
 
         // Setup spy and move a printer
         int from = 1;
         int to = 0;
-        ((MockPrinterInfo*) m_mock_info)->m_availablePrinters.move(from, to);
+        ((MockPrinterBackend*) m_backend)->m_availablePrinters.move(from, to);
 
         // Check signals were fired
         QSignalSpy moveSpy(m_model, SIGNAL(rowsMoved(const QModelIndex&, int, int, const QModelIndex&, int)));
@@ -127,16 +121,18 @@
     void testUpdateRemove()
     {
         // Setup two printers
-        PrinterInfo* printerA = new MockPrinterInfo("a-printer");
-        PrinterInfo* printerB = new MockPrinterInfo("b-printer");
-        ((MockPrinterInfo*) m_mock_info)->m_availablePrinters << printerA << printerB;
+        PrinterBackend *printerABackend = new MockPrinterBackend("a-printer");
+        Printer* printerA = new Printer(printerABackend);
+        PrinterBackend *printerBBackend = new MockPrinterBackend("b-printer");
+        Printer* printerB = new Printer(printerBBackend);
+        ((MockPrinterBackend*) m_backend)->m_availablePrinters << printerA << printerB;
 
         QTRY_COMPARE_WITH_TIMEOUT(m_model->count(), 2, 500);
 
         // Setup spy and remove a printer
         QSignalSpy countSpy(m_model, SIGNAL(countChanged()));
         QSignalSpy removeSpy(m_model, SIGNAL(rowsRemoved(const QModelIndex&, int, int)));
-        ((MockPrinterInfo*) m_mock_info)->m_availablePrinters.removeLast();
+        ((MockPrinterBackend*) m_backend)->m_availablePrinters.removeLast();
 
         QTRY_COMPARE_WITH_TIMEOUT(m_model->count(), 1, 500);
         QCOMPARE(countSpy.count(), 1);
@@ -150,19 +146,23 @@
     void testUpdateRemoveMulti()
     {
         // Setup four printers
-        PrinterInfo* printerA = new MockPrinterInfo("a-printer");
-        PrinterInfo* printerB = new MockPrinterInfo("b-printer");
-        PrinterInfo* printerC = new MockPrinterInfo("c-printer");
-        PrinterInfo* printerD = new MockPrinterInfo("d-printer");
-        ((MockPrinterInfo*) m_mock_info)->m_availablePrinters << printerA << printerB << printerC << printerD;
+        MockPrinterBackend *printerABackend = new MockPrinterBackend("a-printer");
+        Printer* printerA = new Printer(printerABackend);
+        MockPrinterBackend *printerBBackend = new MockPrinterBackend("b-printer");
+        Printer* printerB = new Printer(printerBBackend);
+        MockPrinterBackend *printerCBackend = new MockPrinterBackend("c-printer");
+        Printer* printerC = new Printer(printerCBackend);
+        MockPrinterBackend *printerDBackend = new MockPrinterBackend("d-printer");
+        Printer* printerD = new Printer(printerDBackend);
+        ((MockPrinterBackend*) m_backend)->m_availablePrinters << printerA << printerB << printerC << printerD;
 
         QTRY_COMPARE_WITH_TIMEOUT(m_model->count(), 4, 500);
 
         // Setup spy and remove middle two printers
         QSignalSpy countSpy(m_model, SIGNAL(countChanged()));
         QSignalSpy removeSpy(m_model, SIGNAL(rowsRemoved(const QModelIndex&, int, int)));
-        ((MockPrinterInfo*) m_mock_info)->m_availablePrinters.removeAt(2);
-        ((MockPrinterInfo*) m_mock_info)->m_availablePrinters.removeAt(1);
+        ((MockPrinterBackend*) m_backend)->m_availablePrinters.removeAt(2);
+        ((MockPrinterBackend*) m_backend)->m_availablePrinters.removeAt(1);
 
         // Wait until one count signal has been fired
         // (to ensure this is only one iteration of update)
@@ -181,8 +181,7 @@
         QCOMPARE(args.at(2).toInt(), 1);
     }
 private:
-    CupsFacade *m_mock_cups;
-    PrinterInfo *m_mock_info;
+    PrinterBackend *m_backend;
     PrinterModel *m_model;
 };
 

=== modified file 'tests/unittests/Printers/tst_printers.cpp'
--- tests/unittests/Printers/tst_printers.cpp	2017-01-18 16:32:23 +0000
+++ tests/unittests/Printers/tst_printers.cpp	2017-01-23 14:09:24 +0000
@@ -14,10 +14,9 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "mockcupsfacade.h"
-#include "mockprinterinfo.h"
+#include "mockbackend.h"
 
-#include "cups/cupsfacade.h"
+#include "backend/backend.h"
 #include "printers/printers.h"
 
 #include <QDebug>
@@ -25,9 +24,8 @@
 #include <QSignalSpy>
 #include <QTest>
 
-Q_DECLARE_METATYPE(CupsFacade*)
-Q_DECLARE_METATYPE(PrinterInfo*)
-Q_DECLARE_METATYPE(QList<PrinterInfo*>)
+Q_DECLARE_METATYPE(PrinterBackend*)
+Q_DECLARE_METATYPE(QList<Printer*>)
 
 class TestPrinters : public QObject
 {
@@ -35,33 +33,31 @@
 private Q_SLOTS:
     void testInstantiation_data()
     {
-        QTest::addColumn<CupsFacade*>("cups");
-        QTest::addColumn<PrinterInfo*>("info");
+        QTest::addColumn<PrinterBackend*>("backend");
 
         {
-            CupsFacade* cups = new MockCupsFacade;
-            PrinterInfo* info = new MockPrinterInfo;
-            QTest::newRow("no printers") << cups << info;
+            PrinterBackend* backend = new MockPrinterBackend;
+            QTest::newRow("no printers") << backend;
         }
     }
     void testInstantiation()
     {
-        QFETCH(CupsFacade*, cups);
-        QFETCH(PrinterInfo*, info);
-
-        Printers printers(info, cups);
+        QFETCH(PrinterBackend*, backend);
+        Printers printers(backend);
     }
     void testAllPrintersFilter_data()
     {
-        QTest::addColumn<QList<PrinterInfo*>>("in");
-        QTest::addColumn<QList<PrinterInfo*>>("out");
+        QTest::addColumn<QList<Printer*>>("in");
+        QTest::addColumn<QList<Printer*>>("out");
 
         {
-            auto in = QList<PrinterInfo*>();
-            auto out = QList<PrinterInfo*>();
+            auto in = QList<Printer*>();
+            auto out = QList<Printer*>();
 
-            auto a = new MockPrinterInfo("printer-a");
-            auto b = new MockPrinterInfo("printer-b");
+            auto aBackend = new MockPrinterBackend("printer-a");
+            auto a = new Printer(aBackend);
+            auto bBackend = new MockPrinterBackend("printer-b");
+            auto b = new Printer(bBackend);
 
             in << a << b;
             out << a << b;
@@ -69,12 +65,14 @@
             QTest::newRow("no defaults") << in << out;
         }
         {
-            auto in = QList<PrinterInfo*>();
-            auto out = QList<PrinterInfo*>();
+            auto in = QList<Printer*>();
+            auto out = QList<Printer*>();
 
-            auto a = new MockPrinterInfo("printer-a");
-            auto b = new MockPrinterInfo("printer-b");
-            b->m_defaultPrinterName = "printer-b";
+            auto aBackend = new MockPrinterBackend("printer-a");
+            auto a = new Printer(aBackend);
+            auto bBackend = new MockPrinterBackend("printer-b");
+            auto b = new Printer(bBackend);
+            bBackend->m_defaultPrinterName = "printer-b";
 
             in << a << b;
             out << b << a;
@@ -84,22 +82,20 @@
     }
     void testAllPrintersFilter()
     {
-        QFETCH(QList<PrinterInfo*>, in);
-        QFETCH(QList<PrinterInfo*>, out);
-
-        CupsFacade* cups = new MockCupsFacade;
-        PrinterInfo* info = new MockPrinterInfo;
-
-        ((MockPrinterInfo*) info)->m_availablePrinters = in;
-
-        Printers printers(info, cups, 100);
+        QFETCH(QList<Printer*>, in);
+        QFETCH(QList<Printer*>, out);
+
+        PrinterBackend* backend = new MockPrinterBackend;
+        ((MockPrinterBackend*) backend)->m_availablePrinters = in;
+
+        Printers printers(backend, 100);
         auto all = printers.allPrinters();
 
         QTRY_COMPARE_WITH_TIMEOUT(all->rowCount(), out.size(), 101);
         for (int i = 0; i < all->rowCount(); i++) {
             QCOMPARE(
                  all->data(all->index(i, 0)).toString(),
-                 out.at(i)->printerName()
+                 out.at(i)->name()
             );
         }
     }