Merge lp:~alan-griffiths/mir/message-passing-api into lp:mir

[Alan Griffiths]

client API, shell: introduce functions for passing "opaque" messages

client API, shell: introduce functions for passing "opaque" messages

[lp:~alan-griffiths/mir/message-passing-api]

1285. By Alan Griffiths on 2013-12-12

Basic skeleton of running server in test process

1286. By Alan Griffiths on 2013-12-12

Tidier code

1287. By Alan Griffiths on 2013-12-12

Tidier code and connection creation

1288. By Alan Griffiths on 2013-12-12

Stubbed first MessagePassing test

1289. By Alan Griffiths on 2013-12-12

merge lp:~mir-team/mir/development-branch

Unmerged revisions

1289. By Alan Griffiths on 2013-12-12

merge lp:~mir-team/mir/development-branch

1288. By Alan Griffiths on 2013-12-12

Stubbed first MessagePassing test

1287. By Alan Griffiths on 2013-12-12

Tidier code and connection creation

1286. By Alan Griffiths on 2013-12-12

Tidier code

1285. By Alan Griffiths on 2013-12-12

Basic skeleton of running server in test process

1284. By Alan Griffiths on 2013-12-10

Add tentative MessageTarget interface

1283. By Alan Griffiths on 2013-12-10

Add handle_message(...) to frontend::Session interface

1282. By Alan Griffiths on 2013-12-09

Minimal messaging API

=== modified file 'include/client/mir_toolkit/mir_client_library.h'
--- include/client/mir_toolkit/mir_client_library.h	2013-12-02 16:48:04 +0000
+++ include/client/mir_toolkit/mir_client_library.h	2013-12-12 17:14:21 +0000
@@ -205,6 +205,105 @@
     MirSurfaceParameters const *params);
 
 /**
+ * Request a new unrealized Mir surface on the supplied connection with the
+ * supplied parameters. The returned handle remains valid until the surface
+ * has been released.
+ *   \warning callback could be called from another thread. You must do any
+ *            locking appropriate to protect your data accessed in the
+ *            callback.
+ *   \param [in] connection          The connection
+ *   \param [in] surface_parameters  Request surface parameters
+ *   \param [in] surface_callback    Callback function to be invoked when
+ *                                   request completes
+ *   \param [in,out] surface_context User data passed to the surface_callback
+ *                                   function
+ *   \param [in] message_callback    Callback function when surface receives
+ *                                   messages
+ *   \param [in,out] message_context User data passed to the message_callback
+ *                                   function
+ *   \return                         A handle that can be passed to
+ *                                   mir_wait_for
+ */
+MirWaitHandle *mir_connection_create_unrealized_surface(
+    MirConnection *connection,
+    MirSurfaceParameters const *surface_parameters,
+    mir_surface_callback surface_callback,
+    void *surface_context,
+    mir_surface_message_callback message_callback,
+    void *message_context);
+
+/**
+ * Create a surface like in mir_connection_create_unrealized_surface(), but
+ * also wait for creation to complete and return the resulting surface.
+ *   \param [in] connection  The connection
+ *   \param [in] params      Parameters describing the desired surface
+ *   \param [in] message_callback    Callback function when surface receives
+ *                                   messages
+ *   \param [in,out] message_context User data passed to the message_callback
+ *                                   function
+ *   \return                 The resulting surface
+ */
+MirSurface *mir_connection_create_unrealized_surface_sync(
+    MirConnection *connection,
+    MirSurfaceParameters const *params,
+    mir_surface_message_callback message_callback,
+    void *message_context);
+
+/**
+ * Realize an unrealized Mir surface. The returned handle remains valid until
+ * the surface has been released.
+ *   \warning callback could be called from another thread. You must do any
+ *            locking appropriate to protect your data accessed in the
+ *            callback.
+ *   \param [in] surface             The surface
+ *   \param [in] surface_callback    Callback function to be invoked when
+ *                                   request completes
+ *   \param [in,out] surface_context User data passed to the surface_callback
+ *                                   function
+ *   \return                         A handle that can be passed to
+ *                                   mir_wait_for
+ */
+MirWaitHandle *mir_surface_realize(
+    MirSurface *surface,
+    mir_surface_callback surface_callback,
+    void *surface_context);
+
+/**
+ * Realize an unrealized Mir surface.
+ *   \param [in] surface             The surface
+ */
+void mir_surface_realize_sync(MirSurface *surface);
+
+/**
+ * Send a message from the surface.
+ *   \param [in] surface             The surface
+ *   \param [in] size                number of bytes to send
+ *   \param [in] data                buffer containing bytes to send
+ */
+void mir_surface_send_message(
+    MirSurface *surface,
+    size_t size,
+    void const *data);
+
+/**
+ * Set the message handler to be called when messages arrive for a surface.
+ *   \warning event_handler could be called from another thread. You must do
+ *            any locking appropriate to protect your data accessed in the
+ *            callback. There is also a chance that different messages will be
+ *            called back in different threads, for the same surface,
+ *            simultaneously.
+ *   \param [in] surface             The surface
+ *   \param [in] message_callback    Callback function when surface receives
+ *                                   messages
+ *   \param [in,out] message_context User data passed to the message_callback
+ *                                   function
+ */
+void mir_surface_set_message_handler(
+    MirSurface *surface,
+    mir_surface_message_callback message_callback,
+    void *message_context);
+
+/**
  * Set the event handler to be called when events arrive for a surface.
  *   \warning event_handler could be called from another thread. You must do
  *            any locking appropriate to protect your data accessed in the

=== modified file 'include/server/mir/frontend/session.h'
--- include/server/mir/frontend/session.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/frontend/session.h	2013-12-12 17:14:21 +0000
@@ -60,6 +60,8 @@
     virtual void send_display_config(graphics::DisplayConfiguration const&) = 0;
     virtual int configure_surface(SurfaceId id, MirSurfaceAttrib attrib, int value) = 0;
 
+    virtual void handle_message(SurfaceId id, std::size_t size, void const* data) = 0;
+
 protected:
     Session() = default;
     Session(Session const&) = delete;

=== modified file 'include/server/mir/shell/surface.h'
--- include/server/mir/shell/surface.h	2013-12-04 09:57:35 +0000
+++ include/server/mir/shell/surface.h	2013-12-12 17:14:21 +0000
@@ -34,7 +34,20 @@
 {
 class InputTargeter;
 
-class Surface : public frontend::Surface, public shell::SurfaceBufferAccess
+class MessageTarget
+{
+public:
+    MessageTarget() = default;
+    virtual ~MessageTarget() = default;
+
+    virtual void send_message(size_t size, void const* data) = 0;
+
+private:
+    MessageTarget(MessageTarget const&) = delete;
+    MessageTarget& operator=(MessageTarget const&) = delete;
+};
+
+class Surface : public frontend::Surface, public shell::SurfaceBufferAccess, public MessageTarget
 {
 public:
     virtual std::string name() const = 0;

=== modified file 'include/shared/mir_toolkit/client_types.h'
--- include/shared/mir_toolkit/client_types.h	2013-12-02 16:48:04 +0000
+++ include/shared/mir_toolkit/client_types.h	2013-12-12 17:14:21 +0000
@@ -73,6 +73,17 @@
 typedef void (*mir_surface_callback)(MirSurface *surface, void *client_context);
 
 /**
+ * Callback for handling surface messages
+ *   \param [in] surface             the surface being updated
+ *   \param [in,out] client_context  context provided by client in calling
+ *                                   mir_connect
+ *   \param [in] size                number of bytes received
+ *   \param [in] data                buffer containing bytes received
+ */
+typedef void (*mir_surface_message_callback)(MirSurface *surface,
+    void *client_context, size_t size, void const *data);
+
+/**
  * Callback member of MirEventDelegate for handling of events.
  *   \param [in] surface     The surface on which an event has occurred
  *   \param [in] event       The event to be handled

=== modified file 'include/test/mir_test_doubles/mock_shell_session.h'
--- include/test/mir_test_doubles/mock_shell_session.h	2013-12-02 16:48:04 +0000
+++ include/test/mir_test_doubles/mock_shell_session.h	2013-12-12 17:14:21 +0000
@@ -51,6 +51,9 @@
     MOCK_METHOD3(configure_surface, int(frontend::SurfaceId, MirSurfaceAttrib, int));
 
     MOCK_METHOD1(set_lifecycle_state, void(MirLifecycleState state));
+    void handle_message(frontend::SurfaceId /*id*/, std::size_t /*size*/, void const* /*data*/) override
+    {
+    }
 };
 
 }

=== modified file 'include/test/mir_test_doubles/stub_session.h'
--- include/test/mir_test_doubles/stub_session.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/stub_session.h	2013-12-12 17:14:21 +0000
@@ -65,6 +65,9 @@
     void send_display_config(graphics::DisplayConfiguration const&)
     {
     }
+    void handle_message(frontend::SurfaceId /*id*/, std::size_t /*size*/, void const* /*data*/) override
+    {
+    }
 };
 
 }

=== modified file 'include/test/mir_test_doubles/stub_shell_session.h'
--- include/test/mir_test_doubles/stub_shell_session.h	2013-12-02 16:48:04 +0000
+++ include/test/mir_test_doubles/stub_shell_session.h	2013-12-12 17:14:21 +0000
@@ -75,6 +75,10 @@
     void set_lifecycle_state(MirLifecycleState /*state*/)
     {
     }
+
+    void handle_message(frontend::SurfaceId /*id*/, std::size_t /*size*/, void const* /*data*/) override
+    {
+    }
 };
 
 }

=== modified file 'src/server/scene/application_session.cpp'
--- src/server/scene/application_session.cpp	2013-12-02 16:48:04 +0000
+++ src/server/scene/application_session.cpp	2013-12-12 17:14:21 +0000
@@ -171,3 +171,8 @@
 {
     event_sink->handle_lifecycle_event(state);
 }
+
+void ms::ApplicationSession::handle_message(mf::SurfaceId /*id*/, std::size_t /*size*/, void const* /*data*/)
+{
+    // TODO
+}

=== modified file 'src/server/scene/application_session.h'
--- src/server/scene/application_session.h	2013-12-02 16:48:04 +0000
+++ src/server/scene/application_session.h	2013-12-12 17:14:21 +0000
@@ -71,6 +71,8 @@
 
     void set_lifecycle_state(MirLifecycleState state);
 
+    void handle_message(frontend::SurfaceId id, std::size_t size, void const* data);
+
 protected:
     ApplicationSession(ApplicationSession const&) = delete;
     ApplicationSession& operator=(ApplicationSession const&) = delete;

=== modified file 'src/server/scene/surface_impl.cpp'
--- src/server/scene/surface_impl.cpp	2013-12-06 13:32:41 +0000
+++ src/server/scene/surface_impl.cpp	2013-12-12 17:14:21 +0000
@@ -266,3 +266,8 @@
 {
     surface->set_alpha(alpha);
 }
+
+void ms::SurfaceImpl::send_message(size_t /*size*/, void const* /*data*/)
+{
+    // TODO - implement
+}

=== modified file 'src/server/scene/surface_impl.h'
--- src/server/scene/surface_impl.h	2013-12-06 13:32:41 +0000
+++ src/server/scene/surface_impl.h	2013-12-12 17:14:21 +0000
@@ -91,6 +91,8 @@
     virtual void set_rotation(float degrees, glm::vec3 const& axis);
     virtual void set_alpha(float alpha);
 
+    virtual void send_message(size_t size, void const* data);
+
 private:
     bool set_type(MirSurfaceType t);  // Use configure() to make public changes
     bool set_state(MirSurfaceState s);

=== modified file 'tests/acceptance-tests/CMakeLists.txt'
--- tests/acceptance-tests/CMakeLists.txt	2013-12-02 16:48:04 +0000
+++ tests/acceptance-tests/CMakeLists.txt	2013-12-12 17:14:21 +0000
@@ -6,6 +6,7 @@
   SOURCES
 
   test_client_library.cpp
+  test_message_passing.cpp
   test_surfaceloop.cpp
   test_test_framework.cpp
   test_focus_selection.cpp

=== added file 'tests/acceptance-tests/test_message_passing.cpp'
--- tests/acceptance-tests/test_message_passing.cpp	1970-01-01 00:00:00 +0000
+++ tests/acceptance-tests/test_message_passing.cpp	2013-12-12 17:14:21 +0000
@@ -0,0 +1,177 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alan Griffiths <[e-mail]>
+ */
+
+#include "mir_toolkit/mir_client_library.h"
+
+#include "mir/frontend/connector.h"
+#include "mir/display_server.h"
+#include "mir/run_mir.h"
+
+#include "mir_test_framework/testing_server_configuration.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+
+namespace
+{
+// TODO we're only using part of TestingServerConfiguration - so that ought to be factored out
+struct TestMessagePassingServerConfiguration : mir_test_framework::TestingServerConfiguration
+{
+private:
+    using mir_test_framework::TestingServerConfiguration::exec;
+    using mir_test_framework::TestingServerConfiguration::on_exit;
+};
+
+struct MessagePassing : testing::Test
+{
+    MessagePassing();
+    ~MessagePassing();
+
+    void SetUp();
+    void TearDown();
+
+    TestMessagePassingServerConfiguration server_config;
+    std::string new_connection();
+
+private:
+    mir::DisplayServer* start_mir_server();
+
+    std::thread server_thread;
+    mir::DisplayServer* const display_server;
+};
+
+MessagePassing::MessagePassing() :
+    server_config(),
+    display_server{start_mir_server()}
+{
+}
+
+void MessagePassing::SetUp()
+{
+    ASSERT_TRUE(display_server);
+}
+
+std::string MessagePassing::new_connection()
+{
+    char endpoint[128] = {0};
+    sprintf(endpoint, "fd://%d", server_config.the_connector()->client_socket_fd());
+
+    return endpoint;
+}
+
+void MessagePassing::TearDown()
+{
+    display_server->stop();
+}
+
+MessagePassing::~MessagePassing()
+{
+    if (server_thread.joinable()) server_thread.join();
+}
+
+mir::DisplayServer* MessagePassing::start_mir_server()
+{
+    std::mutex mutex;
+    std::condition_variable cv;
+    mir::DisplayServer* display_server{nullptr};
+
+    server_thread = std::thread([&]
+    {
+        try
+        {
+            mir::run_mir(server_config, [&](mir::DisplayServer& ds)
+            {
+                std::unique_lock<std::mutex> lock(mutex);
+                display_server = &ds;
+                cv.notify_one();
+            });
+        }
+        catch (std::exception const& e)
+        {
+            FAIL() << e.what();
+        }
+    });
+
+    using namespace std::chrono;
+    auto const time_limit = system_clock::now() + seconds(2);
+
+    std::unique_lock<std::mutex> lock(mutex);
+
+    while (!display_server && time_limit > system_clock::now())
+        cv.wait_until(lock, time_limit);
+
+    return display_server;
+}
+
+void test_surface_message_callback(
+    MirSurface* /*surface*/,
+    void* /*client_context*/,
+    size_t /*size*/,
+    void const* /*data*/)
+{
+
+}
+}
+
+MirSurface *mir_connection_create_unrealized_surface_sync(
+    MirConnection */*connection*/,
+    MirSurfaceParameters const */*params*/,
+    mir_surface_message_callback /*message_callback*/,
+    void */*message_context*/)
+{
+    // TODO implement and put in right place
+    return nullptr;
+}
+
+void mir_surface_realize_sync(MirSurface */*surface*/)
+{
+    // TODO implement and put in right place
+}
+
+
+
+TEST_F(MessagePassing, create_and_realize_surface)
+{
+    auto const connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
+    ASSERT_TRUE(mir_connection_is_valid(connection));
+
+    MirSurfaceParameters params;
+
+    auto const surface = mir_connection_create_unrealized_surface_sync(
+        connection,
+        &params,
+        test_surface_message_callback,
+        this);
+
+    // TODO what *should* this return for an unrealized surface?
+//    EXPECT_TRUE(mir_surface_is_valid(surface));
+
+    mir_surface_realize_sync(surface);
+
+    // TODO this should pass
+//    EXPECT_TRUE(mir_surface_is_valid(surface));
+
+    // TODO code
+//    mir_surface_release_sync(surface);
+
+    mir_connection_release(connection);
+}

=== modified file 'tests/unit-tests/frontend/test_session_mediator.cpp'
--- tests/unit-tests/frontend/test_session_mediator.cpp	2013-12-04 09:40:30 +0000
+++ tests/unit-tests/frontend/test_session_mediator.cpp	2013-12-12 17:14:21 +0000
@@ -137,6 +137,10 @@
         mock_surfaces.erase(surface);
     }
 
+    void handle_message(mf::SurfaceId /*id*/, std::size_t /*size*/, void const* /*data*/) override
+    {
+    }
+
     mtd::StubSurfaceBuilder surface_builder;
     std::shared_ptr<mtd::MockFrontendSurface> mock_surface;
     std::map<mf::SurfaceId, std::shared_ptr<mtd::MockFrontendSurface>> mock_surfaces;