Merge lp:~robertcarr/mir/fix-input-build-clang into lp:~mir-team/mir/trunk

[Robert Carr]

Fix input build in clang.

Fix droidinput build in clang. Removal of ASIO looper is discussed here:

https://code.launchpad.net/~robertcarr/mir/receive-input-in-client

[Alan Griffiths (alan-griffiths)]

excellent

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:552
http://jenkins.qa.ubuntu.com/job/mir-ci/281/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/234
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/117
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/285
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/285/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-ci/281/rebuild

review: Approve (continuous-integration)

=== modified file '3rd_party/android-deps/std/Looper.h'
--- 3rd_party/android-deps/std/Looper.h	2013-03-13 04:54:15 +0000
+++ 3rd_party/android-deps/std/Looper.h	2013-04-02 16:41:38 +0000
@@ -20,290 +20,6 @@
 #ifndef MIR_ANDROID_UBUNTU_LOOPER_H_
 #define MIR_ANDROID_UBUNTU_LOOPER_H_
 
-#include ANDROIDFW_UTILS(RefBase.h)
-
-#include <boost/asio.hpp>
-#include <boost/asio/posix/stream_descriptor.hpp>
-#include <boost/bind.hpp>
-#include <boost/exception/all.hpp>
-
-#include <algorithm>
-#include <atomic>
-#include <chrono>
-#include <mutex>
-#include <stdexcept>
-#include <thread>
-#include <vector>
-
-// This includes some cut & paste from android/looper.h (the enums) and
-// util/Looper.h (the android::Looper interface).
-
-namespace mir_input
-{
-/**
- * For callback-based event loops, this is the prototype of the function
- * that is called when a file descriptor event occurs.
- * It is given the file descriptor it is associated with,
- * a bitmask of the poll events that were triggered (typically ALOOPER_EVENT_INPUT),
- * and the data pointer that was originally supplied.
- *
- * Implementations should return 1 to continue receiving callbacks, or 0
- * to have this file descriptor and callback unregistered from the looper.
- */
-typedef int (*ALooper_callbackFunc)(int fd, int events, void* data);
-
-/**
- * Flags for file descriptor events that a looper can monitor.
- *
- * These flag bits can be combined to monitor multiple events at once.
- */
-enum {
-    /**
-     * The file descriptor is available for read operations.
-     */
-
-    ALOOPER_EVENT_INPUT = 1 << 0,
-
-    /**
-     * The file descriptor is available for write operations.
-     */
-    ALOOPER_EVENT_OUTPUT = 1 << 1,
-
-    /**
-     * The file descriptor has encountered an error condition.
-     *
-     * The looper always sends notifications about errors; it is not necessary
-     * to specify this event flag in the requested event set.
-     */
-    ALOOPER_EVENT_ERROR = 1 << 2,
-
-    /**
-     * The file descriptor was hung up.
-     * For example, indicates that the remote end of a pipe or socket was closed.
-     *
-     * The looper always sends notifications about hangups; it is not necessary
-     * to specify this event flag in the requested event set.
-     */
-    ALOOPER_EVENT_HANGUP = 1 << 3,
-
-    /**
-     * The file descriptor is invalid.
-     * For example, the file descriptor was closed prematurely.
-     *
-     * The looper always sends notifications about invalid file descriptors; it is not necessary
-     * to specify this event flag in the requested event set.
-     */
-    ALOOPER_EVENT_INVALID = 1 << 4
-};
-
-enum {
-    /**
-     * Result from ALooper_pollOnce() and ALooper_pollAll():
-     * The poll was awoken using wake() before the timeout expired
-     * and no callbacks were executed and no other file descriptors were ready.
-     */
-    ALOOPER_POLL_WAKE = -1,
-
-    /**
-     * Result from ALooper_pollOnce() and ALooper_pollAll():
-     * One or more callbacks were executed.
-     */
-    ALOOPER_POLL_CALLBACK = -2,
-
-    /**
-     * Result from ALooper_pollOnce() and ALooper_pollAll():
-     * The timeout expired.
-     */
-    ALOOPER_POLL_TIMEOUT = -3,
-
-    /**
-     * Result from ALooper_pollOnce() and ALooper_pollAll():
-     * An error occurred.
-     */
-    ALOOPER_POLL_ERROR = -4
-};
-
-/**
- * A polling loop that supports monitoring file descriptor events, optionally
- * using callbacks.
- *
- * A looper can be associated with a thread although there is no requirement that it must be.
- */
-class Looper : public ::android::RefBase {
-protected:
-    virtual ~Looper() { std::lock_guard<std::mutex> lock(mutex); io_service.stop(); files.clear(); }
-
-public:
-    /**
-     * Creates a looper.
-     *
-     * If allowNonCallbaks is true, the looper will allow file descriptors to be
-     * registered without associated callbacks.  This assumes that the caller of
-     * pollOnce() is prepared to handle callback-less events itself.
-     */
-    Looper(bool allowNonCallbacks) : woken(false)
-    { if (allowNonCallbacks) BOOST_THROW_EXCEPTION(std::logic_error("Callback-less events not allowed")); }
-
-    /**
-     * Waits for events to be available, with optional timeout in milliseconds.
-     * Invokes callbacks for all file descriptors on which an event occurred.
-     *
-     * If the timeout is zero, returns immediately without blocking.
-     * If the timeout is negative, waits indefinitely until an event appears.
-     *
-     * Returns ALOOPER_POLL_WAKE if the poll was awoken using wake() before
-     * the timeout expired and no callbacks were invoked and no other file
-     * descriptors were ready.
-     *
-     * Returns ALOOPER_POLL_CALLBACK if one or more callbacks were invoked.
-     *
-     * Returns ALOOPER_POLL_TIMEOUT if there was no data before the given
-     * timeout expired.
-     *
-     * Returns ALOOPER_POLL_ERROR if an error occurred.
-     *
-     * Returns a value >= 0 containing an identifier if its file descriptor has data
-     * and it has no callback function (requiring the caller here to handle it).
-     * In this (and only this) case outFd, outEvents and outData will contain the poll
-     * events and data associated with the fd, otherwise they will be set to NULL.
-     *
-     * This method does not return until it has finished invoking the appropriate callbacks
-     * for all file descriptors that were signalled.
-     */
-
-    inline int pollOnce(int timeoutMillis) {
-        bool callbacks{false};
-
-        // Outwit valgrind (otherwise AndroidInputManagerAndCursorListenerSetup.* test
-        // runs very erratically and slowly).
-        std::this_thread::yield();
-
-        boost::system::error_code ec;
-
-        if (timeoutMillis == 0)
-        {
-            callbacks |= io_service.poll(ec);
-        }
-        else if (timeoutMillis > 0)
-        {
-            boost::asio::deadline_timer timer(
-                io_service,
-                boost::posix_time::milliseconds(timeoutMillis));
-
-            callbacks |= io_service.run_one(ec);
-        }
-        else
-        {
-            callbacks |= io_service.run_one(ec);
-        }
-
-        if (ec)                return ALOOPER_POLL_ERROR;
-        else if (woken.load()) return ALOOPER_POLL_WAKE;
-        else if (callbacks)    return ALOOPER_POLL_CALLBACK;
-        else                   return ALOOPER_POLL_TIMEOUT;
-    }
-
-    /**
-     * Wakes the poll asynchronously.
-     *
-     * This method can be called on any thread.
-     * This method returns immediately.
-     */
-    void wake() { io_service.post([&] () {woken.store(true); }); }
-
-    /**
-     * Adds a new file descriptor to be polled by the looper.
-     * If the same file descriptor was previously added, it is replaced.
-     *
-     * "fd" is the file descriptor to be added.
-     * "ident" is an identifier for this event, which is returned from pollOnce().
-     * The identifier must be >= 0, or ALOOPER_POLL_CALLBACK if providing a non-NULL callback.
-     * "events" are the poll events to wake up on.  Typically this is ALOOPER_EVENT_INPUT.
-     * "callback" is the function to call when there is an event on the file descriptor.
-     * "data" is a private data pointer to supply to the callback.
-     *
-     * There are two main uses of this function:
-     *
-     * (1) If "callback" is non-NULL, then this function will be called when there is
-     * data on the file descriptor.  It should execute any events it has pending,
-     * appropriately reading from the file descriptor.  The 'ident' is ignored in this case.
-     *
-     * (2) If "callback" is NULL, the 'ident' will be returned by ALooper_pollOnce
-     * when its file descriptor has data available, requiring the caller to take
-     * care of processing it.
-     *
-     * Returns 1 if the file descriptor was added, 0 if the arguments were invalid.
-     *
-     * This method can be called on any thread.
-     * This method may block briefly if it needs to wake the poll.
-     *
-     * The callback may either be specified as a bare function pointer or as a smart
-     * pointer callback object.  The smart pointer should be preferred because it is
-     * easier to avoid races when the callback is removed from a different thread.
-     * See removeFd() for details.
-     */
-    int addFd(int fd, int ident, int events, ALooper_callbackFunc callback, void* data)
-    {   (void)ident;
-        std::lock_guard<std::mutex> lock(mutex);
-        files.emplace_back(io_service, fd);
-
-        if (events & ALOOPER_EVENT_INPUT)
-            boost::asio::async_read(files.back(), boost::asio::null_buffers(),
-                boost::bind(callback, fd, events, data));
-
-        return 1;
-    }
-
-    /**
-     * Removes a previously added file descriptor from the looper.
-     *
-     * When this method returns, it is safe to close the file descriptor since the looper
-     * will no longer have a reference to it.  However, it is possible for the callback to
-     * already be running or for it to run one last time if the file descriptor was already
-     * signalled.  Calling code is responsible for ensuring that this case is safely handled.
-     * For example, if the callback takes care of removing itself during its own execution either
-     * by returning 0 or by calling this method, then it can be guaranteed to not be invoked
-     * again at any later time unless registered anew.
-     *
-     * A simple way to avoid this problem is to use the version of addFd() that takes
-     * a sp<LooperCallback> instead of a bare function pointer.  The LooperCallback will
-     * be released at the appropriate time by the Looper.
-     *
-     * Returns 1 if the file descriptor was removed, 0 if none was previously registered.
-     *
-     * This method can be called on any thread.
-     * This method may block briefly if it needs to wake the poll.
-     */
-    int removeFd(int fd) {
-        std::lock_guard<std::mutex> lock(mutex);
-        auto erase_me = std::find_if(files.begin(), files.end(),
-            [=] (boost::asio::posix::stream_descriptor& ff){ return fd == ff.native(); });
-
-        if (erase_me == files.end()) return 0;
-        files.erase(erase_me);
-        return 1;
-    }
-
-private:
-    std::atomic<bool> woken;
-    boost::asio::io_service io_service;
-    std::mutex mutable mutex;
-    std::vector<boost::asio::posix::stream_descriptor> files;
-};
-}
-
-namespace android
-{
-using ::mir_input::ALooper_callbackFunc;
-using ::mir_input::ALOOPER_EVENT_INPUT;
-using ::mir_input::ALOOPER_EVENT_OUTPUT;
-using ::mir_input::ALOOPER_EVENT_ERROR;
-using ::mir_input::ALOOPER_EVENT_HANGUP;
-using ::mir_input::ALOOPER_EVENT_INVALID;
-using ::mir_input::ALOOPER_POLL_WAKE;
-using ::mir_input::ALOOPER_POLL_CALLBACK;
-using ::mir_input::ALOOPER_POLL_TIMEOUT;
-using ::mir_input::ALOOPER_POLL_ERROR;
-using ::mir_input::Looper;
-} // namespace android
+#include <utils/Looper.h>
+
 #endif /* MIR_ANDROID_UBUNTU_LOOPER_H_ */

=== modified file '3rd_party/android-deps/utils/RefBase.h'
--- 3rd_party/android-deps/utils/RefBase.h	2013-03-13 04:54:15 +0000
+++ 3rd_party/android-deps/utils/RefBase.h	2013-04-02 16:41:38 +0000
@@ -167,10 +167,10 @@
 {
 public:
     inline LightRefBase() : mCount(0) { }
-    inline void incStrong(const void* id) const {
+    inline void incStrong(const void* /* id */) const {
         android_atomic_inc(&mCount);
     }
-    inline void decStrong(const void* id) const {
+    inline void decStrong(const void* /* id */) const {
         if (android_atomic_dec(&mCount) == 1) {
             delete static_cast<const T*>(this);
         }
@@ -187,8 +187,8 @@
 
 private:
     friend class ReferenceMover;
-    inline static void moveReferences(void* d, void const* s, size_t n,
-            const ReferenceConverterBase& caster) { }
+    inline static void moveReferences(void* /* d */, void const* /* s */, size_t /* n */,
+            const ReferenceConverterBase& /* caster */) { }
 
 private:
     mutable android_atomic_int32_t mCount;

=== modified file 'include/test/mir_test_doubles/mock_event_filter.h'
--- include/test/mir_test_doubles/mock_event_filter.h	2013-03-13 04:54:15 +0000
+++ include/test/mir_test_doubles/mock_event_filter.h	2013-04-02 16:41:38 +0000
@@ -36,11 +36,7 @@
     MOCK_METHOD1(handles, bool(const MirEvent&));
 };
 }
-}
-}
 
-namespace
-{
 MATCHER_P(IsKeyEventWithKey, key, "")
 {
     if (arg.type != MIR_INPUT_EVENT_TYPE_KEY)
@@ -71,5 +67,6 @@
     return (coords->x == dx) && (coords->y == dy);
 }
 }
+}
 
 #endif // MIR_TEST_DOUBLES_MOCK_EVENT_FILTER_H_

=== modified file 'tests/integration-tests/input/android/test_android_input_manager.cpp'
--- tests/integration-tests/input/android/test_android_input_manager.cpp	2013-03-29 16:51:35 +0000
+++ tests/integration-tests/input/android/test_android_input_manager.cpp	2013-04-02 16:41:38 +0000
@@ -104,7 +104,7 @@
 
     EXPECT_CALL(
         event_filter,
-        handles(KeyDownEvent()))
+        handles(mt::KeyDownEvent()))
             .Times(1)
             .WillOnce(ReturnFalseAndWakeUp(&wait_condition));
 
@@ -125,7 +125,7 @@
 
     EXPECT_CALL(
         event_filter,
-        handles(ButtonDownEvent()))
+        handles(mt::ButtonDownEvent()))
             .Times(1)
             .WillOnce(ReturnFalseAndWakeUp(&wait_condition));
 
@@ -148,10 +148,10 @@
         InSequence seq;
 
         EXPECT_CALL(event_filter,
-                    handles(MotionEvent(100, 100)))
+                    handles(mt::MotionEvent(100, 100)))
             .WillOnce(Return(false));
         EXPECT_CALL(event_filter,
-                    handles(MotionEvent(200, 100)))
+                    handles(mt::MotionEvent(200, 100)))
             .WillOnce(ReturnFalseAndWakeUp(&wait_condition));
     }
 

=== modified file 'tests/integration-tests/input/android/test_fake_event_hub_to_event_filter.cpp'
--- tests/integration-tests/input/android/test_fake_event_hub_to_event_filter.cpp	2013-03-13 08:09:52 +0000
+++ tests/integration-tests/input/android/test_fake_event_hub_to_event_filter.cpp	2013-04-02 16:41:38 +0000
@@ -103,7 +103,7 @@
 
     mir::WaitCondition wait_condition;
 
-    EXPECT_CALL(event_filter, handles(KeyDownEvent())).Times(1)
+    EXPECT_CALL(event_filter, handles(mt::KeyDownEvent())).Times(1)
         .WillOnce(ReturnFalseAndWakeUp(&wait_condition));
 
     event_hub->synthesize_builtin_keyboard_added();

=== modified file 'tests/unit-tests/input/android/test_android_input_manager.cpp'
--- tests/unit-tests/input/android/test_android_input_manager.cpp	2013-03-29 16:51:35 +0000
+++ tests/unit-tests/input/android/test_android_input_manager.cpp	2013-04-02 16:41:38 +0000
@@ -40,6 +40,9 @@
 
 #include <initializer_list>
 
+#include <sys/types.h>
+#include <sys/socket.h>
+
 namespace droidinput = android;
 
 namespace mi = mir::input;