Merge lp:~thomas-voss/miracast-service/fix-trunk-build into lp:miracast-service

[Thomas Voß]

Fix trunk build. Note to self: *ALWAYS* test in a clean chroot.
Vendorize missing header files.

Fix trunk build. Note to self: *ALWAYS* test in a clean chroot.
Vendorize missing header files.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:104
http://jenkins.qa.ubuntu.com/job/miracast-service-ci/12/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/miracast-service-vivid-amd64-ci/12
    SUCCESS: http://jenkins.qa.ubuntu.com/job/miracast-service-vivid-armhf-ci/12
        deb: http://jenkins.qa.ubuntu.com/job/miracast-service-vivid-armhf-ci/12/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/miracast-service-vivid-i386-ci/12

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/miracast-service-ci/12/rebuild

review: Approve (continuous-integration)

=== modified file 'debian/control'
--- debian/control	2015-12-03 12:23:27 +0000
+++ debian/control	2015-12-03 20:54:23 +0000
@@ -8,6 +8,7 @@
                google-mock,
                libboost-dev,
                libboost-filesystem-dev,
+               libboost-iostreams-dev,
                libboost-system-dev,
                libglib2.0-dev,
                libgstreamer1.0-dev,

=== added file 'tests/3rd_party/process-cpp-minimal/include/core/connection.h'
--- tests/3rd_party/process-cpp-minimal/include/core/connection.h	1970-01-01 00:00:00 +0000
+++ tests/3rd_party/process-cpp-minimal/include/core/connection.h	2015-12-03 20:54:23 +0000
@@ -0,0 +1,190 @@
+/*
+ * Copyright © 2013 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 version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+#ifndef COM_UBUNTU_CONNECTION_H_
+#define COM_UBUNTU_CONNECTION_H_
+
+#include <functional>
+#include <memory>
+#include <mutex>
+
+namespace core
+{
+class ScopedConnection;
+/**
+ * @brief The Connection class models a signal-slot connection.
+ */
+class Connection
+{
+public:    
+    typedef std::function<void(const std::function<void()>&)> Dispatcher;
+
+    /**
+     * @brief Checks if this instance corresponds to an active signal-slot connection.
+     * @return true iff the instance corresponds to an active signal-slot connection.
+     */
+    inline bool is_connected() const
+    {
+        if (!d)
+            return false;
+
+        return (d->disconnector ? true : false);
+    }
+
+    /**
+     * @brief End a signal-slot connection.
+     */
+    inline void disconnect()
+    {
+        if (d)
+            d->disconnect();
+    }
+
+    /**
+     * @brief Installs a dispatcher for this signal-slot connection.
+     * @param dispatcher The dispatcher to be used for signal emissions.
+     */
+    inline void dispatch_via(const Dispatcher& dispatcher)
+    {
+        if (d && d->dispatcher_installer)
+            d->dispatcher_installer(dispatcher);
+    }
+
+private:
+    friend class ScopedConnection;
+
+    typedef std::function<void()> Disconnector;
+    typedef std::function<void(const Dispatcher&)> DispatcherInstaller;
+
+    template<typename ... Arguments> friend class Signal;
+
+    inline Connection(const Disconnector& disconnector,
+                      const DispatcherInstaller& installer)
+        : d(std::make_shared<Private>(disconnector, installer))
+    {
+    }
+
+    inline bool operator<(const Connection& rhs) const
+    {
+        return d < rhs.d;
+    }
+
+    inline void reset()
+    {
+        if (d)
+            d->reset();
+    }
+
+    struct Private
+    {
+        Private(const Connection::Disconnector& disconnector,
+                const Connection::DispatcherInstaller& dispatcher_installer)
+            : disconnector(disconnector),
+              dispatcher_installer(dispatcher_installer)
+        {
+        }
+
+        inline void reset()
+        {
+            std::lock_guard<std::mutex> lg(guard);
+            reset_locked();
+        }
+
+        inline void reset_locked()
+        {
+            static const Connection::Disconnector empty_disconnector{};
+            static const Connection::DispatcherInstaller empty_dispatcher_installer{};
+
+            disconnector = empty_disconnector;
+            dispatcher_installer = empty_dispatcher_installer;
+        }
+
+        inline void disconnect()
+        {
+            static const Connection::Disconnector empty_disconnector{};
+
+            std::lock_guard<std::mutex> lg(guard);
+
+            if (disconnector)
+                disconnector();
+
+            reset_locked();
+        }
+
+        std::mutex guard;
+        Connection::Disconnector disconnector;
+        Connection::DispatcherInstaller dispatcher_installer;
+    };
+
+    // The whole class is implicitly shared and we thus forward our complete
+    // shared state to a private structure that is lifetime-managed by a shared_ptr.
+    std::shared_ptr<Private> d;
+};
+
+/**
+ * @brief Scoped helper class to map signal-slot connection mgmt. to RAII.
+ */
+class ScopedConnection
+{
+public:
+    /**
+     * @brief Constructs an instance for an existing signal-slot connection.
+     * @param c The existing signal-slot connection.
+     */
+    inline ScopedConnection(const Connection& c) : connection(c)
+    {
+    }
+
+    inline ScopedConnection(ScopedConnection&& rhs) : connection(std::move(rhs.connection))
+    {
+    }
+
+    ScopedConnection(const ScopedConnection&) = delete;
+
+    /**
+     * @brief Disconnects the signal-slot connection.
+     */
+    inline ~ScopedConnection() noexcept(true)
+    {
+        try
+        {
+            connection.disconnect();
+        } catch(...)
+        {
+        }
+    }
+
+    inline ScopedConnection& operator=(ScopedConnection&& rhs)
+    {
+        connection = std::move(rhs.connection);
+        return *this;
+    }
+
+    ScopedConnection& operator=(const ScopedConnection&) = delete;
+    bool operator==(const ScopedConnection&) = delete;
+
+    inline bool operator<(const ScopedConnection& rhs) const
+    {
+        return connection < rhs.connection;
+    }
+
+private:
+    Connection connection;
+};
+}
+
+#endif // COM_UBUNTU_CONNECTION_H_

=== added file 'tests/3rd_party/process-cpp-minimal/include/core/signal.h'
--- tests/3rd_party/process-cpp-minimal/include/core/signal.h	1970-01-01 00:00:00 +0000
+++ tests/3rd_party/process-cpp-minimal/include/core/signal.h	2015-12-03 20:54:23 +0000
@@ -0,0 +1,297 @@
+/*
+ * Copyright © 2013 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 version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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/>.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ */
+#ifndef COM_UBUNTU_SIGNAL_H_
+#define COM_UBUNTU_SIGNAL_H_
+
+#include <core/connection.h>
+
+#include <functional>
+#include <iostream>
+#include <list>
+#include <mutex>
+#include <set>
+
+namespace core
+{
+/**
+ * @brief A signal class that observers can subscribe to.
+ * @tparam Arguments List of argument types passed on to observers when the signal is emitted.
+ */
+template<typename ...Arguments>
+class Signal
+{
+public:
+    /**
+     * @brief Slot is the function type that observers have to provide to connect to this signal.
+     */
+    typedef std::function<void(Arguments...)> Slot;
+
+private:
+    struct SlotWrapper
+    {
+        void operator()(Arguments... args)
+        {
+            dispatcher(std::bind(slot, args...));
+        }
+
+        Slot slot;
+        Connection::Dispatcher dispatcher;
+        Connection connection;
+    };
+
+public:
+    /**
+     * @brief Signal constructs a new instance. Never throws.
+     */
+    inline Signal() noexcept(true) : d(new Private())
+    {
+    }
+
+    inline ~Signal()
+    {
+        std::lock_guard<std::mutex> lg(d->guard);
+        for (auto slot : d->slot_list)
+            slot.connection.reset();
+    }
+
+    // Copy construction, assignment and equality comparison are disabled.
+    Signal(const Signal&) = delete;
+    Signal& operator=(const Signal&) = delete;
+    bool operator==(const Signal&) const = delete;
+
+    /**
+     * @brief Connects the provided slot to this signal instance.
+     *
+     * Calling this method is thread-safe and synchronized with any
+     * other connect, signal emission or disconnect calls.
+     *
+     * @param slot The function to be called when the signal is emitted.
+     * @return A connection object corresponding to the signal-slot connection.
+     */
+    inline Connection connect(const Slot& slot) const
+    {
+        // Helpers to initialize an invalid connection.
+        static const Connection::Disconnector empty_disconnector{};
+        static const Connection::DispatcherInstaller empty_dispatcher_installer{};
+
+        // The default dispatcher immediately executes the function object
+        // provided as argument on whatever thread is currently running.
+        static const Connection::Dispatcher default_dispatcher
+                = [](const std::function<void()>& handler) { handler(); };
+
+        Connection conn{empty_disconnector, empty_dispatcher_installer};
+
+        std::lock_guard<std::mutex> lg(d->guard);
+
+        auto result = d->slot_list.insert(
+                    d->slot_list.end(),
+                    SlotWrapper{slot, default_dispatcher, conn});
+
+        // We implicitly share our internal state with the connection here
+        // by passing in our private bits contained in 'd' to the std::bind call.
+        // This admittedly uncommon approach allows us to cleanly manage connection
+        // and signal lifetimes without the need to mark everything as mutable.
+        conn.d->disconnector = std::bind(
+                    &Private::disconnect_slot_for_iterator,
+                    d,
+                    result);
+        conn.d->dispatcher_installer = std::bind(
+                    &Private::install_dispatcher_for_iterator,
+                    d,
+                    std::placeholders::_1,
+                    result);
+
+        return conn;
+    }
+
+    /**
+     * @brief operator () emits the signal with the provided parameters.
+     *
+     * Please note that signal emissions might not be delivered immediately to
+     * registered slots, depending on whether the respective connection is dispatched
+     * via a queueing dispatcher. For that reason, the lifetime of the arguments has to
+     * exceed the scope of the call to this operator and its surrounding scope.
+     *
+     * @param args The arguments to be passed on to registered slots.
+     */
+    inline void operator()(Arguments... args)
+    {
+        std::lock_guard<std::mutex> lg(d->guard);
+        for(auto slot : d->slot_list)
+        {
+            slot(args...);
+        }
+    }
+
+private:
+    struct Private
+    {
+        typedef std::list<SlotWrapper> SlotList;
+
+        inline void disconnect_slot_for_iterator(typename SlotList::iterator it)
+        {
+            std::lock_guard<std::mutex> lg(guard);
+            slot_list.erase(it);
+        }
+
+        inline void install_dispatcher_for_iterator(const Connection::Dispatcher& dispatcher,
+                                                    typename SlotList::iterator it)
+        {
+            std::lock_guard<std::mutex> lg(guard);
+            it->dispatcher = dispatcher;
+        }
+
+        std::mutex guard;
+        SlotList slot_list;
+    };
+    std::shared_ptr<Private> d;
+};
+
+/**
+ * @brief A signal class that observers can subscribe to,
+ * template specialization for signals without arguments.
+ */
+template<>
+class Signal<void>
+{
+public:
+    /**
+     * @brief Slot is the function type that observers have to provide to connect to this signal.
+     */
+    typedef std::function<void()> Slot;
+
+private:
+    struct SlotWrapper
+    {
+        void operator()()
+        {
+            dispatcher(slot);
+        }
+
+        Slot slot;
+        Connection::Dispatcher dispatcher;
+        Connection connection;
+    };
+
+public:
+    /**
+     * @brief Signal constructs a new instance. Never throws.
+     */
+    inline Signal() noexcept(true) : d(new Private())
+    {
+    }
+
+    inline ~Signal()
+    {
+        std::lock_guard<std::mutex> lg(d->guard);
+        for (auto slot : d->slot_list)
+            slot.connection.reset();
+    }
+
+    // Copy construction, assignment and equality comparison are disabled.
+    Signal(const Signal&) = delete;
+    Signal& operator=(const Signal&) = delete;
+    bool operator==(const Signal&) const = delete;
+
+    /**
+     * @brief Connects the provided slot to this signal instance.
+     *
+     * Calling this method is thread-safe and synchronized with any
+     * other connect, signal emission or disconnect calls.
+     *
+     * @param slot The function to be called when the signal is emitted.
+     * @return A connection object corresponding to the signal-slot connection.
+     */
+    inline Connection connect(const Slot& slot) const
+    {
+        // Helpers to initialize an invalid connection.
+        static const Connection::Disconnector empty_disconnector{};
+        static const Connection::DispatcherInstaller empty_dispatcher_installer{};
+
+        // The default dispatcher immediately executes the function object
+        // provided as argument on whatever thread is currently running.
+        static const Connection::Dispatcher default_dispatcher
+                = [](const std::function<void()>& handler) { handler(); };
+
+        Connection conn{empty_disconnector, empty_dispatcher_installer};
+
+        std::lock_guard<std::mutex> lg(d->guard);
+
+        auto result = d->slot_list.insert(
+                    d->slot_list.end(),
+                    SlotWrapper{slot, default_dispatcher, conn});
+
+        // We implicitly share our internal state with the connection here
+        // by passing in our private bits contained in 'd' to the std::bind call.
+        // This admittedly uncommon approach allows us to cleanly manage connection
+        // and signal lifetimes without the need to mark everything as mutable.
+        conn.d->disconnector = std::bind(
+                    &Private::disconnect_slot_for_iterator,
+                    d,
+                    result);
+        conn.d->dispatcher_installer = std::bind(
+                    &Private::install_dispatcher_for_iterator,
+                    d,
+                    std::placeholders::_1,
+                    result);
+
+        return conn;
+    }
+
+    /**
+     * @brief operator () emits the signal.
+     *
+     * Please note that signal emissions might not be delivered immediately to
+     * registered slots, depending on whether the respective connection is dispatched
+     * via a queueing dispatcher.
+     */
+    inline void operator()()
+    {
+        std::lock_guard<std::mutex> lg(d->guard);
+        for(auto slot : d->slot_list)
+        {
+            slot();
+        }
+    }
+
+private:
+    struct Private
+    {
+        typedef std::list<SlotWrapper> SlotList;
+
+        inline void disconnect_slot_for_iterator(typename SlotList::iterator it)
+        {
+            std::lock_guard<std::mutex> lg(guard);
+            slot_list.erase(it);
+        }
+
+        inline void install_dispatcher_for_iterator(const Connection::Dispatcher& dispatcher,
+                                                    typename SlotList::iterator it)
+        {
+            std::lock_guard<std::mutex> lg(guard);
+            it->dispatcher = dispatcher;
+        }
+
+        std::mutex guard;
+        SlotList slot_list;
+    };
+    std::shared_ptr<Private> d;
+};
+}
+
+#endif // COM_UBUNTU_SIGNAL_H_

=== modified file 'tests/mcs/acceptance_tests/CMakeLists.txt'
--- tests/mcs/acceptance_tests/CMakeLists.txt	2015-12-02 09:36:09 +0000
+++ tests/mcs/acceptance_tests/CMakeLists.txt	2015-12-03 20:54:23 +0000
@@ -1,3 +1,5 @@
+include_directories(${CMAKE_SOURCE_DIR}/tests/3rd_party/process-cpp-minimal/include)
+
 add_executable(miracast_service_tests miracast_service_tests.cpp did_exit_cleanly.cpp)
 target_link_libraries(miracast_service_tests miracast gtest gtest_main process-cpp)
 add_test(miracast_service_tests miracast_service_tests)