Merge lp:~dobey/pay-service/compile-fixes into lp:pay-service/15.04

[dobey]

Fix usage of warnings flags and the warnings resulting.
Use -fPIC instead of -fPIE where appropriate.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:51
http://jenkins.qa.ubuntu.com/job/pay-service-15.04-ci/5/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/pay-service-15.04-vivid-amd64-ci/5
    SUCCESS: http://jenkins.qa.ubuntu.com/job/pay-service-15.04-vivid-armhf-ci/5
        deb: http://jenkins.qa.ubuntu.com/job/pay-service-15.04-vivid-armhf-ci/5/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/pay-service-15.04-ci/5/rebuild

review: Approve (continuous-integration)

[Kyle Fazzari (kyrofa)]

Correction: "Use -fPIC instead of -fPIE where GCC5 seems to think it's appropriate." Looks good.

review: Approve

=== modified file 'common/CMakeLists.txt'
--- common/CMakeLists.txt	2015-07-06 16:52:08 +0000
+++ common/CMakeLists.txt	2015-09-03 14:42:58 +0000
@@ -1,6 +1,6 @@
 
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -g -fPIE ${GCOV_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_WARNING_ARGS} -std=c++11 -g -fPIC ${GCOV_FLAGS}")
 
 set(COMMON_SOURCES
     glib-thread.cpp

=== modified file 'common/glib-thread.cpp'
--- common/glib-thread.cpp	2015-04-03 15:55:21 +0000
+++ common/glib-thread.cpp	2015-09-03 14:42:58 +0000
@@ -23,9 +23,7 @@
 {
 
 
-ContextThread::ContextThread (std::function<void(void)> beforeLoop, std::function<void(void)> afterLoop)
-    : _context(nullptr)
-    , _loop(nullptr)
+ContextThread::ContextThread (std::function<void()> beforeLoop, std::function<void()> afterLoop)
 {
     _cancel = std::shared_ptr<GCancellable>(g_cancellable_new(), [](GCancellable * cancel)
     {
@@ -40,7 +38,7 @@
     /* NOTE: We copy afterLoop but reference beforeLoop. We're blocking so we
        know that beforeLoop will stay valid long enough, but we can't say the
        same for afterLoop */
-    _thread = std::thread([&context_promise, &beforeLoop, afterLoop, this](void) -> void
+    _thread = std::thread([&context_promise, &beforeLoop, afterLoop, this]()
     {
         /* Build up the context and loop for the async events and a place
            for GDBus to send its events back to */
@@ -79,21 +77,21 @@
     _context = context_value.first;
     _loop = context_value.second;
 
-    if (_context == nullptr || _loop == nullptr)
+    if (!_context || !_loop)
     {
         throw std::runtime_error("Unable to create GLib Thread");
     }
 }
 
-ContextThread::~ContextThread (void)
+ContextThread::~ContextThread ()
 {
     quit();
 }
 
-void ContextThread::quit (void)
+void ContextThread::quit ()
 {
     g_cancellable_cancel(_cancel.get()); /* Force the cancellation on ongoing tasks */
-    if (_loop != nullptr)
+    if (_loop)
     {
         g_main_loop_quit(_loop.get());    /* Quit the loop */
     }
@@ -109,17 +107,17 @@
     }
 }
 
-bool ContextThread::isCancelled (void)
+bool ContextThread::isCancelled ()
 {
     return g_cancellable_is_cancelled(_cancel.get()) == TRUE;
 }
 
-std::shared_ptr<GCancellable> ContextThread::getCancellable (void)
+std::shared_ptr<GCancellable> ContextThread::getCancellable ()
 {
     return _cancel;
 }
 
-void ContextThread::simpleSource (std::function<GSource * (void)> srcBuilder, std::function<void(void)> work)
+void ContextThread::simpleSource (std::function<GSource * ()> srcBuilder, std::function<void()> work)
 {
     if (isCancelled())
     {
@@ -129,7 +127,7 @@
     /* Copy the work so that we can reuse it */
     /* Lifecycle is handled with the source pointer when we attach
        it to the context. */
-    auto heapWork = new std::function<void(void)>(work);
+    auto heapWork = new std::function<void()>(work);
 
     auto source = std::shared_ptr<GSource>(srcBuilder(),
                                            [](GSource * src)
@@ -138,28 +136,28 @@
     }
                                           );
     g_source_set_callback(source.get(),
-                          [](gpointer data) -> gboolean
+                          [](gpointer data)
     {
-        std::function<void(void)>* heapWork = reinterpret_cast<std::function<void(void)> *>(data);
+        auto heapWork = static_cast<std::function<void()> *>(data);
         (*heapWork)();
         return G_SOURCE_REMOVE;
     }, heapWork,
     [](gpointer data)
     {
-        std::function<void(void)>* heapWork = reinterpret_cast<std::function<void(void)> *>(data);
+        auto heapWork = static_cast<std::function<void()> *>(data);
         delete heapWork;
     });
 
     g_source_attach(source.get(), _context.get());
 }
 
-void ContextThread::executeOnThread (std::function<void(void)> work)
+void ContextThread::executeOnThread (std::function<void()> work)
 {
     simpleSource(g_idle_source_new, work);
 }
 
 void ContextThread::timeout (const std::chrono::milliseconds& length,
-                             std::function<void(void)> work)
+                             std::function<void()> work)
 {
     simpleSource([length]()
     {
@@ -168,7 +166,7 @@
 }
 
 void ContextThread::timeoutSeconds (const std::chrono::seconds& length,
-                                    std::function<void(void)> work)
+                                    std::function<void()> work)
 {
     simpleSource([length]()
     {

=== modified file 'common/glib-thread.h'
--- common/glib-thread.h	2015-03-27 17:17:03 +0000
+++ common/glib-thread.h	2015-09-03 14:42:58 +0000
@@ -33,15 +33,15 @@
     std::shared_ptr<GCancellable> _cancel;
 
 public:
-    ContextThread (std::function<void(void)> beforeLoop = [] {}, std::function<void(void)> afterLoop = [] {});
-    ~ContextThread (void);
-
-    void quit (void);
-    bool isCancelled (void);
-    std::shared_ptr<GCancellable> getCancellable (void);
-
-    void executeOnThread (std::function<void(void)> work);
-    template<typename T> auto executeOnThread (std::function<T(void)> work) -> T
+    ContextThread (std::function<void()> beforeLoop = [] {}, std::function<void()> afterLoop = [] {});
+    ~ContextThread ();
+
+    void quit ();
+    bool isCancelled ();
+    std::shared_ptr<GCancellable> getCancellable ();
+
+    void executeOnThread (std::function<void()> work);
+    template<typename T> auto executeOnThread (std::function<T()> work) -> T
     {
         if (std::this_thread::get_id() == _thread.get_id())
         {
@@ -50,7 +50,7 @@
         }
 
         std::promise<T> promise;
-        std::function<void(void)> magicFunc = [&promise, &work] (void) -> void {
+        std::function<void()> magicFunc = [&promise, &work] () {
             promise.set_value(work());
         };
 
@@ -61,21 +61,21 @@
         return future.get();
     }
 
-    void timeout (const std::chrono::milliseconds& length, std::function<void(void)> work);
+    void timeout (const std::chrono::milliseconds& length, std::function<void()> work);
     template<class Rep, class Period> void timeout (const std::chrono::duration<Rep, Period>& length,
-                                                    std::function<void(void)> work)
+                                                    std::function<void()> work)
     {
         return timeout(std::chrono::duration_cast<std::chrono::milliseconds>(length), work);
     }
 
-    void timeoutSeconds (const std::chrono::seconds& length, std::function<void(void)> work);
+    void timeoutSeconds (const std::chrono::seconds& length, std::function<void()> work);
     template<class Rep, class Period> void timeoutSeconds (const std::chrono::duration<Rep, Period>& length,
-                                                           std::function<void(void)> work)
+                                                           std::function<void()> work)
     {
         return timeoutSeconds(std::chrono::duration_cast<std::chrono::seconds>(length), work);
     }
 
 private:
-    void simpleSource (std::function<GSource * (void)> srcBuilder, std::function<void(void)> work);
+    void simpleSource (std::function<GSource * ()> srcBuilder, std::function<void()> work);
 };
 }

=== modified file 'service/CMakeLists.txt'
--- service/CMakeLists.txt	2015-09-03 14:42:58 +0000
+++ service/CMakeLists.txt	2015-09-03 14:42:58 +0000
@@ -1,5 +1,5 @@
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -g -fPIE ${GCOV_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_WARNING_ARGS} -std=c++11 -g -fPIC ${GCOV_FLAGS}")
 include_directories(${CMAKE_CURRENT_BINARY_DIR} "${CMAKE_SOURCE_DIR}/common")
 
 

=== modified file 'service/click-purchases-api.cpp'
--- service/click-purchases-api.cpp	2015-07-01 17:43:55 +0000
+++ service/click-purchases-api.cpp	2015-09-03 14:42:58 +0000
@@ -26,7 +26,7 @@
 {
 public:
 
-    Impl(Factory::Ptr wfactory):
+    explicit Impl(Factory::Ptr wfactory):
         m_wfactory(wfactory)
     {
     }

=== modified file 'service/click-purchases-api.h'
--- service/click-purchases-api.h	2015-07-01 17:41:51 +0000
+++ service/click-purchases-api.h	2015-09-03 14:42:58 +0000
@@ -31,7 +31,7 @@
 class ClickPurchasesApi
 {
 public:
-    ClickPurchasesApi(Web::Factory::Ptr wfactory);
+    explicit ClickPurchasesApi(Web::Factory::Ptr wfactory);
     virtual ~ClickPurchasesApi();
     bool running();
 

=== modified file 'service/dbus-interface.cpp'
--- service/dbus-interface.cpp	2015-07-06 16:52:58 +0000
+++ service/dbus-interface.cpp	2015-09-03 14:42:58 +0000
@@ -33,26 +33,20 @@
     Item::Store::Ptr items;
     std::thread t;
     core::Signal<> connectionReady;
-    GQuark errorQuark;
+    const GQuark errorQuark = g_quark_from_static_string("dbus-interface-impl");
 
     /* Allocated on thread, and cleaned up there */
-    GMainLoop* loop;
-    proxyPay* serviceProxy;
-    proxyPayPackage* packageProxy;
-    GDBusConnection* bus;
-    GCancellable* cancel;
-    guint subtree_registration;
+    GMainLoop* loop = nullptr;
+    proxyPay* serviceProxy = nullptr;
+    proxyPayPackage* packageProxy = nullptr;
+    GDBusConnection* bus = nullptr;
+    GCancellable* cancel = nullptr;
+    guint subtree_registration = 0;
 
     /* Allocates a thread to do dbus work */
-    DBusInterfaceImpl (const Item::Store::Ptr& in_items) :
+    explicit DBusInterfaceImpl (const Item::Store::Ptr& in_items) :
         items(in_items),
-        cancel(g_cancellable_new()),
-        loop(nullptr),
-        bus(nullptr),
-        serviceProxy(nullptr),
-        packageProxy(nullptr),
-        errorQuark(g_quark_from_static_string("dbus-interface-impl")),
-        subtree_registration(0)
+        cancel(g_cancellable_new())
     { }
 
     void run ()
@@ -74,9 +68,7 @@
                     return;
                 }
 
-                std::string encodedpkg = DBusInterface::encodePath(pkg);
-                std::string path("/com/canonical/pay/");
-                path += encodedpkg;
+                const auto path = getPathFromPackage(pkg);
 
                 auto mitem = items->getItem(pkg, item);
                 const char* strstatus = Item::Item::statusString(status);
@@ -147,6 +139,24 @@
         }
     }
 
+    static constexpr char const * baseObjectPath{"/com/canonical/pay"};
+
+    static std::string getPathFromPackage(const std::string& pkg)
+    {
+        std::string path = baseObjectPath;
+        path += '/';
+        path += DBusInterface::encodePath(pkg);
+        return path;
+    }
+
+    static std::string getPackageFromPath(const std::string& path)
+    {
+        std::string pkg = path;
+        pkg.erase(0, strlen(baseObjectPath) + 1/*strlen("/")*/);
+        pkg = DBusInterface::decodePath(pkg);
+        return pkg;
+    }
+
     void busAcquired (GDBusConnection* bus);
 
     /* Signal up that we're ready on the interface side of things */
@@ -171,14 +181,10 @@
         g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
         g_variant_builder_open(&builder, G_VARIANT_TYPE("ao"));
 
-        for (auto package : packages)
+        for (const auto& pkg : packages)
         {
-            std::string prefix("/com/canonical/pay/");
-            std::string encoded = DBusInterface::encodePath(package);
-
-            prefix += encoded;
-
-            g_variant_builder_add_value(&builder, g_variant_new_object_path(prefix.c_str()));
+            const auto path = getPathFromPackage(pkg);
+            g_variant_builder_add_value(&builder, g_variant_new_object_path(path.c_str()));
         }
 
         g_variant_builder_close(&builder); // tuple
@@ -189,7 +195,7 @@
     /**************************************
      * Subtree Functions
      **************************************/
-    gchar** subtreeEnumerate (const gchar* path)
+    gchar** subtreeEnumerate (const gchar* /*path*/)
     {
         GArray* nodes = g_array_new(TRUE, FALSE, sizeof(gchar*));
         auto packages = items->listApplications();
@@ -203,7 +209,7 @@
         return reinterpret_cast<gchar**>(g_array_free(nodes, FALSE));
     }
 
-    GDBusInterfaceInfo** subtreeIntrospect (const gchar* path, const gchar* node)
+    GDBusInterfaceInfo** subtreeIntrospect (const gchar* /*path*/, const gchar* /*node*/)
     {
         GDBusInterfaceInfo* skelInfo = nullptr;
 
@@ -218,8 +224,7 @@
     void packageCall(const gchar* sender, const gchar* path, const gchar* method, GVariant* params,
                      GDBusMethodInvocation* invocation)
     {
-        const gchar* encoded_package = path + std::strlen("/com/canonical/pay/");
-        std::string package = DBusInterface::decodePath(std::string(encoded_package));
+        const auto package = getPackageFromPath(path);
 
         auto params_str = g_variant_print(params, true);
         g_debug("%s sender(%s) path(%s) method(%s) package(%s) params(%s)",
@@ -300,41 +305,41 @@
     /**************************************
      * Static Helpers, C language binding
      **************************************/
-    static void busAcquired_staticHelper (GDBusConnection* inbus, const gchar* name, gpointer user_data)
+    static void busAcquired_staticHelper (GDBusConnection* inbus, const gchar* /*name*/, gpointer user_data)
     {
-        DBusInterfaceImpl* notthis = static_cast<DBusInterfaceImpl*>(user_data);
+        auto notthis = static_cast<DBusInterfaceImpl*>(user_data);
         notthis->busAcquired(inbus);
     }
 
-    static void nameAcquired_staticHelper (GDBusConnection* bus, const gchar* name, gpointer user_data)
+    static void nameAcquired_staticHelper (GDBusConnection* /*bus*/, const gchar* /*name*/, gpointer user_data)
     {
-        DBusInterfaceImpl* notthis = static_cast<DBusInterfaceImpl*>(user_data);
+        auto notthis = static_cast<DBusInterfaceImpl*>(user_data);
         notthis->nameAcquired();
     }
 
-    static void nameLost_staticHelper (GDBusConnection* bus, const gchar* name, gpointer user_data)
+    static void nameLost_staticHelper (GDBusConnection* /*bus*/, const gchar* /*name*/, gpointer user_data)
     {
-        DBusInterfaceImpl* notthis = static_cast<DBusInterfaceImpl*>(user_data);
+        auto notthis = static_cast<DBusInterfaceImpl*>(user_data);
         notthis->nameLost();
     }
 
-    static gboolean listPackages_staticHelper (proxyPay* proxy, GDBusMethodInvocation* invocation, gpointer user_data)
+    static gboolean listPackages_staticHelper (proxyPay* /*proxy*/, GDBusMethodInvocation* invocation, gpointer user_data)
     {
-        DBusInterfaceImpl* notthis = static_cast<DBusInterfaceImpl*>(user_data);
+        auto notthis = static_cast<DBusInterfaceImpl*>(user_data);
         return notthis->listPackages(invocation);
     }
 
-    static gchar** subtreeEnumerate_staticHelper (GDBusConnection* bus, const gchar* sender, const gchar* object_path,
+    static gchar** subtreeEnumerate_staticHelper (GDBusConnection* /*bus*/, const gchar* /*sender*/, const gchar* object_path,
                                                   gpointer user_data)
     {
-        DBusInterfaceImpl* notthis = static_cast<DBusInterfaceImpl*>(user_data);
+        auto notthis = static_cast<DBusInterfaceImpl*>(user_data);
         return notthis->subtreeEnumerate(object_path);
     }
 
-    static GDBusInterfaceInfo** subtreeIntrospect_staticHelper (GDBusConnection* bus, const gchar* sender,
+    static GDBusInterfaceInfo** subtreeIntrospect_staticHelper (GDBusConnection* /*bus*/, const gchar* /*sender*/,
                                                                 const gchar* object_path, const gchar* node, gpointer user_data)
     {
-        DBusInterfaceImpl* notthis = static_cast<DBusInterfaceImpl*>(user_data);
+        auto notthis = static_cast<DBusInterfaceImpl*>(user_data);
         return notthis->subtreeIntrospect(object_path, node);
     }
 
@@ -346,19 +351,19 @@
                                                                      gpointer* out_user_data,
                                                                      gpointer user_data);
 
-    static void packageCall_staticHelper (GDBusConnection* connection, const gchar* sender, const gchar* path,
-                                          const gchar* interface, const gchar* method, GVariant* params, GDBusMethodInvocation* invocation, gpointer user_data)
+    static void packageCall_staticHelper (GDBusConnection* /*connection*/, const gchar* sender, const gchar* path,
+                                          const gchar* /*interface*/, const gchar* method, GVariant* params, GDBusMethodInvocation* invocation, gpointer user_data)
     {
-        DBusInterfaceImpl* notthis = static_cast<DBusInterfaceImpl*>(user_data);
+        auto notthis = static_cast<DBusInterfaceImpl*>(user_data);
         return notthis->packageCall(sender, path, method, params, invocation);
     }
 };
 
 static const GDBusSubtreeVTable subtreeVtable =
 {
-    .enumerate = DBusInterfaceImpl::subtreeEnumerate_staticHelper,
-    .introspect = DBusInterfaceImpl::subtreeIntrospect_staticHelper,
-    .dispatch= DBusInterfaceImpl::subtreeDispatch_staticHelper
+    DBusInterfaceImpl::subtreeEnumerate_staticHelper,
+    DBusInterfaceImpl::subtreeIntrospect_staticHelper,
+    DBusInterfaceImpl::subtreeDispatch_staticHelper
 };
 
 /* Export objects into the bus before we get a name */
@@ -381,11 +386,11 @@
 
     g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(serviceProxy),
                                      bus,
-                                     "/com/canonical/pay",
+                                     baseObjectPath,
                                      NULL);
 
     subtree_registration = g_dbus_connection_register_subtree(bus,
-                                                              "/com/canonical/pay",
+                                                              baseObjectPath,
                                                               &subtreeVtable,
                                                               G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES,
                                                               this,
@@ -395,16 +400,16 @@
 
 static const GDBusInterfaceVTable packageVtable =
 {
-    .method_call = DBusInterfaceImpl::packageCall_staticHelper,
-    .get_property = nullptr,
-    .set_property = nullptr
+    DBusInterfaceImpl::packageCall_staticHelper,
+    nullptr,
+    nullptr
 };
 
-const GDBusInterfaceVTable* DBusInterfaceImpl::subtreeDispatch_staticHelper (GDBusConnection* bus,
-                                                                             const gchar* sender,
-                                                                             const gchar* path,
+const GDBusInterfaceVTable* DBusInterfaceImpl::subtreeDispatch_staticHelper (GDBusConnection* /*bus*/,
+                                                                             const gchar* /*sender*/,
+                                                                             const gchar* /*path*/,
                                                                              const gchar* interface,
-                                                                             const gchar* node,
+                                                                             const gchar* /*node*/,
                                                                              gpointer* out_user_data,
                                                                              gpointer user_data)
 {
@@ -421,9 +426,9 @@
 
 
 
-DBusInterface::DBusInterface (const Item::Store::Ptr& in_items)
+DBusInterface::DBusInterface (const Item::Store::Ptr& in_items):
+    impl(std::make_shared<DBusInterfaceImpl>(in_items))
 {
-    impl = std::make_shared<DBusInterfaceImpl>(in_items);
     impl->connectionReady.connect([this]()
     {
         connectionReady();
@@ -432,12 +437,6 @@
     impl->run();
 }
 
-bool
-DBusInterface::busStatus ()
-{
-    return true;
-}
-
 std::string
 DBusInterface::encodePath (const std::string& input)
 {
@@ -475,7 +474,7 @@
 
     try
     {
-        for (int i = 0; i < input.size(); i++)
+        for (unsigned i = 0; i < input.size(); i++)
         {
             if (input[i] == '_')
             {

=== modified file 'service/dbus-interface.h'
--- service/dbus-interface.h	2014-06-13 18:43:47 +0000
+++ service/dbus-interface.h	2015-09-03 14:42:58 +0000
@@ -29,11 +29,9 @@
 class DBusInterface
 {
 public:
-    DBusInterface (const Item::Store::Ptr& in_items);
+    explicit DBusInterface (const Item::Store::Ptr& in_items);
     ~DBusInterface () { };
 
-    bool busStatus ();
-
     static std::string encodePath (const std::string& input);
     static std::string decodePath (const std::string& input);
 

=== modified file 'service/exec-tool.c'
--- service/exec-tool.c	2015-09-03 14:42:58 +0000
+++ service/exec-tool.c	2015-09-03 14:42:58 +0000
@@ -112,8 +112,6 @@
 int
 main (int argc, char * argv[])
 {
-    GError * error = NULL;
-
     /* Build up our exec */
     const gchar * appid = g_getenv("APP_ID");
     if (appid == NULL) {

=== modified file 'service/item-interface.h'
--- service/item-interface.h	2015-07-06 16:52:58 +0000
+++ service/item-interface.h	2015-09-03 14:42:58 +0000
@@ -66,7 +66,7 @@
         return "error";
     }
 
-    virtual std::string& getId (void) = 0;
+    virtual const std::string& getId (void) = 0;
     virtual Status getStatus (void) = 0;
     virtual uint64_t getRefundExpiry (void) = 0;
     virtual bool verify (void) = 0;
@@ -80,12 +80,12 @@
 {
 public:
     virtual std::list<std::string> listApplications (void) = 0;
-    virtual std::shared_ptr<std::map<std::string, Item::Ptr>> getItems (std::string& application) = 0;
-    virtual Item::Ptr getItem (std::string& application, std::string& item) = 0;
+    virtual std::shared_ptr<std::map<std::string, Item::Ptr>> getItems (const std::string& application) = 0;
+    virtual Item::Ptr getItem (const std::string& application, const std::string& item) = 0;
 
     typedef std::shared_ptr<Store> Ptr;
 
-    core::Signal<std::string&, std::string&, Item::Status, uint64_t> itemChanged;
+    core::Signal<const std::string&, const std::string&, Item::Status, uint64_t> itemChanged;
 };
 
 } // namespace Item

=== modified file 'service/item-memory.cpp'
--- service/item-memory.cpp	2015-07-06 16:52:58 +0000
+++ service/item-memory.cpp	2015-09-03 14:42:58 +0000
@@ -31,8 +31,8 @@
 class MemoryItem : public Item
 {
 public:
-    MemoryItem (std::string& in_app,
-                std::string& in_id,
+    MemoryItem (const std::string& in_app,
+                const std::string& in_id,
                 Verification::Factory::Ptr& in_vfactory,
                 Refund::Factory::Ptr& in_rfactory,
                 Purchase::Factory::Ptr& in_pfactory) :
@@ -40,22 +40,18 @@
         id(in_id),
         vfactory(in_vfactory),
         rfactory(in_rfactory),
-        pfactory(in_pfactory),
-        vitem(nullptr),
-        pitem(nullptr),
-        status(Item::Status::UNKNOWN),
-        refund_timeout(0)
+        pfactory(in_pfactory)
     {
         /* We init into the unknown state and then wait for someone
            to ask us to do something about it. */
     }
 
-    std::string& getApp (void)
+    const std::string& getApp (void)
     {
         return app;
     }
 
-    std::string& getId (void) override
+    const std::string& getId (void) override
     {
         return id;
     }
@@ -170,7 +166,7 @@
                 return false;
             }
 
-            pitem->purchaseComplete.connect([this](Purchase::Item::Status status)
+            pitem->purchaseComplete.connect([this](Purchase::Item::Status /*status*/)
             {
                 /* Verifying on each time the purchase UI runs right now because
                    we're not getting reliable status back from them. */
@@ -216,10 +212,10 @@
     }
 
     /***** Only set at init *********/
+    /* Application ID */
+    std::string app;
     /* Item ID */
     std::string id;
-    /* Application ID */
-    std::string app;
     Verification::Factory::Ptr vfactory;
     Refund::Factory::Ptr rfactory;
     Purchase::Factory::Ptr pfactory;
@@ -234,11 +230,11 @@
 
     /****** status is protected with it's own mutex *******/
     std::mutex status_mutex;
-    Item::Status status;
+    Item::Status status = Item::Status::UNKNOWN;
 
     /****** refund_timeout is protected with it's own mutex *******/
     std::mutex refund_mutex;
-    uint64_t refund_timeout;
+    uint64_t refund_timeout = 0;
 };
 
 std::list<std::string>
@@ -258,7 +254,7 @@
 }
 
 std::shared_ptr<std::map<std::string, Item::Ptr>>
-MemoryStore::getItems (std::string& application)
+MemoryStore::getItems (const std::string& application)
 {
     auto app = data[application];
 
@@ -272,7 +268,7 @@
 }
 
 Item::Ptr
-MemoryStore::getItem (std::string& application, std::string& itemid)
+MemoryStore::getItem (const std::string& application, const std::string& itemid)
 {
     if (verificationFactory == nullptr)
     {

=== modified file 'service/item-memory.h'
--- service/item-memory.h	2015-07-01 17:41:51 +0000
+++ service/item-memory.h	2015-09-03 14:42:58 +0000
@@ -43,9 +43,9 @@
             throw std::invalid_argument("factory");
         }
     }
-    std::list<std::string> listApplications (void);
-    std::shared_ptr<std::map<std::string, Item::Ptr>> getItems (std::string& application);
-    Item::Ptr getItem (std::string& application, std::string& itemid);
+    std::list<std::string> listApplications (void) override;
+    std::shared_ptr<std::map<std::string, Item::Ptr>> getItems (const std::string& application) override;
+    Item::Ptr getItem (const std::string& application, const std::string& itemid) override;
 
 private:
     std::map<std::string, std::shared_ptr<std::map<std::string, Item::Ptr>>> data;

=== modified file 'service/item-null.h'
--- service/item-null.h	2015-07-06 16:52:58 +0000
+++ service/item-null.h	2015-09-03 14:42:58 +0000
@@ -30,7 +30,7 @@
 public:
     NullItem (std::string id) : _id(id) {};
 
-    std::string& getId (void) override
+    const std::string& getId (void) override
     {
         return _id;
     }
@@ -64,17 +64,17 @@
 class NullStore : public Store
 {
 public:
-    std::list<std::string> listApplications (void)
+    std::list<std::string> listApplications (void) override
     {
         return std::list<std::string>();
     }
 
-    std::shared_ptr<std::map<std::string, Item::Ptr>> getItems (std::string& application)
+    std::shared_ptr<std::map<std::string, Item::Ptr>> getItems (const std::string& application) override
     {
         return std::make_shared<std::map<std::string, Item::Ptr>>();
     }
 
-    Item::Ptr getItem (std::string& application, std::string& itemid)
+    Item::Ptr getItem (const std::string& application, const std::string& itemid) override
     {
         auto retval = std::make_shared<NullItem>(itemid);
         return retval;

=== modified file 'service/purchase-ual.cpp'
--- service/purchase-ual.cpp	2015-09-03 14:42:58 +0000
+++ service/purchase-ual.cpp	2015-09-03 14:42:58 +0000
@@ -41,7 +41,6 @@
     typedef std::shared_ptr<Item> Ptr;
 
     UalItem (const std::string& in_appid, const std::string& in_itemid, const std::shared_ptr<MirConnection>& mir) :
-        status(Item::ERROR),
         appid(in_appid),
         itemid(in_itemid),
         connection(mir)
@@ -136,7 +135,7 @@
     std::string instanceid;
     std::shared_ptr<GLib::ContextThread> thread;
     std::shared_ptr<MirPromptSession> session;
-    Item::Status status;
+    Item::Status status = Item::ERROR;
 
     /* Given to us by our parents */
     std::shared_ptr<MirConnection> connection;
@@ -336,7 +335,7 @@
         }
     }
 
-    static void stateChanged (MirPromptSession* session, MirPromptSessionState state, void* user_data)
+    static void stateChanged (MirPromptSession* /*session*/, MirPromptSessionState state, void* /*user_data*/)
     {
         g_debug("Mir Prompt session is in state: %d", state);
     }
@@ -413,9 +412,9 @@
     return impl->purchaseItem(appid, itemid);
 }
 
-UalFactory::UalFactory ()
+UalFactory::UalFactory ():
+    impl(std::make_shared<Impl>())
 {
-    impl = std::make_shared<Impl>();
     if (!impl)
     {
         throw std::runtime_error("Unable to build implementation of UAL Factory");

=== modified file 'service/qtbridge.cpp'
--- service/qtbridge.cpp	2014-06-04 20:23:21 +0000
+++ service/qtbridge.cpp	2015-09-03 14:42:58 +0000
@@ -50,7 +50,7 @@
 class TaskEvent : public QEvent
 {
 public:
-    TaskEvent(const std::function<void()>& task)
+    explicit TaskEvent(const std::function<void()>& task)
         : QEvent(qt_core_world_task_event_type()),
           task(task)
     {
@@ -84,7 +84,7 @@
     Q_OBJECT
 
 public:
-    TaskHandler(QObject* parent) : QObject(parent)
+    explicit TaskHandler(QObject* parent) : QObject(parent)
     {
     }
 

=== modified file 'service/refund-http.h'
--- service/refund-http.h	2015-07-01 17:41:51 +0000
+++ service/refund-http.h	2015-09-03 14:42:58 +0000
@@ -28,7 +28,7 @@
 class HttpFactory : public Factory
 {
 public:
-    HttpFactory (Web::ClickPurchasesApi::Ptr cpa_in);
+    explicit HttpFactory (Web::ClickPurchasesApi::Ptr cpa_in);
     bool running () override;
     Item::Ptr refund (const std::string& appid, const std::string& itemid) override;
 

=== modified file 'service/refund-null.cpp'
--- service/refund-null.cpp	2015-07-01 17:41:51 +0000
+++ service/refund-null.cpp	2015-09-03 14:42:58 +0000
@@ -40,7 +40,7 @@
 }
 
 Item::Ptr
-NullFactory::refund (const std::string& appid, const std::string& itemid)
+NullFactory::refund (const std::string& /*appid*/, const std::string& /*itemid*/)
 {
     return std::make_shared<NullItem>();
 }

=== modified file 'service/token-grabber-u1.cpp'
--- service/token-grabber-u1.cpp	2014-08-07 15:17:21 +0000
+++ service/token-grabber-u1.cpp	2015-09-03 14:42:58 +0000
@@ -96,7 +96,7 @@
     service.getCredentials();
 }
 
-void TokenGrabberU1Qt::accountChanged(Accounts::AccountId id)
+void TokenGrabberU1Qt::accountChanged(Accounts::AccountId /*id*/)
 {
     /* We don't need to worry about @id here because there
        can only be one U1 account for the user at a time, so
@@ -135,16 +135,15 @@
     return retval;
 }
 
-TokenGrabberU1::TokenGrabberU1 (void) :
-    grabber(nullptr)
-{
+TokenGrabberU1::TokenGrabberU1 ():
     //qt = std::make_shared<TokenGrabberU1Qt>();
-    qtfuture = qt::core::world::enter_with_task_and_expect_result<std::shared_ptr<TokenGrabberU1Qt>>([]()
+    qtfuture(qt::core::world::enter_with_task_and_expect_result<std::shared_ptr<TokenGrabberU1Qt>>([]()
     {
         auto qtgrabber = std::make_shared<TokenGrabberU1Qt>();
         qtgrabber->run();
         return qtgrabber;
-    });
+    }))
+{
 }
 
 TokenGrabberU1::~TokenGrabberU1 (void)

=== modified file 'service/verification-http.h'
--- service/verification-http.h	2015-07-06 16:52:08 +0000
+++ service/verification-http.h	2015-09-03 14:42:58 +0000
@@ -29,7 +29,7 @@
 
 class HttpFactory : public Factory {
 public:
-    HttpFactory (Web::ClickPurchasesApi::Ptr cpa_in);
+    explicit HttpFactory (Web::ClickPurchasesApi::Ptr cpa_in);
     virtual bool running () override;
     virtual Item::Ptr verifyItem (const std::string& appid, const std::string& itemid) override;
 

=== modified file 'service/verification-null.cpp'
--- service/verification-null.cpp	2015-04-30 08:54:31 +0000
+++ service/verification-null.cpp	2015-09-03 14:42:58 +0000
@@ -47,7 +47,7 @@
 }
 
 Item::Ptr
-NullFactory::verifyItem (const std::string& appid, const std::string& itemid)
+NullFactory::verifyItem (const std::string& /*appid*/, const std::string& /*itemid*/)
 {
     return std::make_shared<NullItem>();
 }

=== modified file 'service/webclient-curl.cpp'
--- service/webclient-curl.cpp	2015-07-01 17:41:51 +0000
+++ service/webclient-curl.cpp	2015-09-03 14:42:58 +0000
@@ -101,11 +101,10 @@
            network socket. */
         exec = std::thread([this]()
         {
-            std::string authheader;
             CURL* handle = curl_easy_init();
 
             /* Helps with threads */
-            curl_easy_setopt(handle, CURLOPT_NOSIGNAL, 1);
+            curl_easy_setopt(handle, CURLOPT_NOSIGNAL, 1L);
             curl_easy_setopt(handle, CURLOPT_URL, _url.c_str());
             curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, curlWrite);
             curl_easy_setopt(handle, CURLOPT_WRITEDATA, this);

=== modified file 'service/webclient-curl.h'
--- service/webclient-curl.h	2015-07-06 16:52:08 +0000
+++ service/webclient-curl.h	2015-09-03 14:42:58 +0000
@@ -27,7 +27,7 @@
 
 class CurlFactory : public Factory {
 public:
-    CurlFactory (TokenGrabber::Ptr token);
+    explicit CurlFactory (TokenGrabber::Ptr token);
     ~CurlFactory ();
 
     virtual bool running () override;

=== modified file 'service/webclient-null.cpp'
--- service/webclient-null.cpp	2015-07-01 17:41:51 +0000
+++ service/webclient-null.cpp	2015-09-03 14:42:58 +0000
@@ -35,12 +35,12 @@
         return false;
     }
 
-    virtual void set_header (const std::string& key,
-                             const std::string& value) override
+    virtual void set_header (const std::string& /*key*/,
+                             const std::string& /*value*/) override
     {
     }
 
-    virtual void set_post (const std::vector<char>& body) override
+    virtual void set_post (const std::vector<char>& /*body*/) override
     {
     }
 };
@@ -53,8 +53,8 @@
 }
 
 Request::Ptr
-NullFactory::create_request (const std::string& url,
-                             bool sign)
+NullFactory::create_request (const std::string& /*url*/,
+                             bool /*sign*/)
 {
     return std::make_shared<NullRequest>();
 }

=== modified file 'tests/item-test.h'
--- tests/item-test.h	2015-07-06 16:52:58 +0000
+++ tests/item-test.h	2015-09-03 14:42:58 +0000
@@ -26,8 +26,8 @@
 
 class TestItem : public Item
 {
-    std::string _id;
-    std::string _app;
+    const std::string _id;
+    const std::string _app;
     uint64_t refund_timeout;
     Status status = Status::UNKNOWN;
     bool verifyResult = false;
@@ -35,18 +35,18 @@
     bool purchaseResult = false;
 
 public:
-    TestItem (std::string& app, std::string& id) :
+    TestItem (const std::string& app, const std::string& id) :
         _id(id),
         _app(app)
     {
     }
 
-    std::string& getId (void) override
+    const std::string& getId (void) override
     {
         return _id;
     }
 
-    std::string& getApp (void)
+    const std::string& getApp (void)
     {
         return _app;
     }
@@ -92,7 +92,7 @@
 {
     std::map<std::string, std::shared_ptr<std::map<std::string, Item::Ptr>>> data;
 public:
-    std::list<std::string> listApplications (void)
+    std::list<std::string> listApplications (void) override
     {
         std::list<std::string> apps;
 
@@ -107,7 +107,7 @@
         return apps;
     }
 
-    std::shared_ptr<std::map<std::string, Item::Ptr>> getItems (std::string& application)
+    std::shared_ptr<std::map<std::string, Item::Ptr>> getItems (const std::string& application) override
     {
         auto app = data[application];
 
@@ -120,7 +120,7 @@
         return app;
     }
 
-    Item::Ptr getItem (std::string& application, std::string& itemid)
+    Item::Ptr getItem (const std::string& application, const std::string& itemid) override
     {
         auto app = getItems(application);
         Item::Ptr item = (*app)[itemid];