Merge lp:~afrantzis/mir/abstract-host-connection into lp:mir

[Alexandros Frantzis]

nested: Abstract communication with host server

nested: Abstract communication with host server

Abstract communication with the host server to make it possible to write unit tests for the nested platform.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1564
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1356/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/1647
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/1645
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-trusty-touch/1220
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/1088
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/1088/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/1093
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/1093/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-trusty-armhf/1221
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-trusty-armhf/1221/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/1129
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/6166

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1356/rebuild

review: Approve (continuous-integration)

[Robert Carr (robertcarr)]

l883: Why not display config destroy?

review: Needs Information

[Kevin DuBois (kdub)]

okay overall, like the promise of tests :)

MirClientHostConnection:
perhaps NestedConnection?

review: Approve

[Alexandros Frantzis (afrantzis)]

> l883: Why not display config destroy?

We are populating the struct manually, so it's safer and more future proof to release it manually, too. If we use mir_display_config_destroy() we are making the assumption that the way we populate the struct matches what the client library does internally. This assumption is true at the moment, but that may change in the future.

[Alan Griffiths (alan-griffiths)]

Ill go along for now - but what I really want to see are the promised tests

review: Approve

[Robert Carr (robertcarr)]

Ok!

review: Approve

[Kevin DuBois (kdub)]

looks good to top-approve

=== modified file 'src/server/graphics/default_configuration.cpp'
--- src/server/graphics/default_configuration.cpp	2014-03-27 09:52:04 +0000
+++ src/server/graphics/default_configuration.cpp	2014-04-17 11:09:02 +0000
@@ -21,7 +21,7 @@
 #include "mir/options/option.h"
 
 #include "default_display_configuration_policy.h"
-#include "nested/host_connection.h"
+#include "nested/mir_client_host_connection.h"
 #include "nested/nested_platform.h"
 #include "offscreen/display.h"
 
@@ -145,7 +145,7 @@
                 options->get<std::string>(options::name_opt) :
                 "nested-mir@:" + server_socket;
 
-            return std::make_shared<graphics::nested::HostConnection>(
+            return std::make_shared<graphics::nested::MirClientHostConnection>(
                 host_socket,
                 my_name);
         });

=== modified file 'src/server/graphics/nested/CMakeLists.txt'
--- src/server/graphics/nested/CMakeLists.txt	2013-08-30 16:49:22 +0000
+++ src/server/graphics/nested/CMakeLists.txt	2014-04-17 11:09:02 +0000
@@ -9,7 +9,7 @@
   nested_display_configuration.cpp
   nested_output.cpp
   nested_platform.cpp
-  host_connection.cpp
+  mir_client_host_connection.cpp
 )
 
 target_link_libraries(

=== removed file 'src/server/graphics/nested/host_connection.cpp'
--- src/server/graphics/nested/host_connection.cpp	2014-03-06 06:05:17 +0000
+++ src/server/graphics/nested/host_connection.cpp	1970-01-01 00:00:00 +0000
@@ -1,32 +0,0 @@
-/*
- * 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: Eleni Maria Stea <[e-mail]>
- */
-
-#include "host_connection.h"
-#include "mir_toolkit/mir_client_library.h"
-
-namespace mgn = mir::graphics::nested;
-
-mgn::HostConnection::HostConnection(std::string const& host_socket, std::string const& name)
-    : connection{mir_connect_sync(host_socket.c_str(), name.c_str())}
-{
-}
-
-mgn::HostConnection::~HostConnection()
-{
-    mir_connection_release(connection);
-}

=== modified file 'src/server/graphics/nested/host_connection.h'
--- src/server/graphics/nested/host_connection.h	2014-03-06 06:05:17 +0000
+++ src/server/graphics/nested/host_connection.h	2014-04-17 11:09:02 +0000
@@ -19,9 +19,15 @@
 #ifndef MIR_GRAPHICS_NESTED_HOST_CONNECTION_H_
 #define MIR_GRAPHICS_NESTED_HOST_CONNECTION_H_
 
-#include <string>
-
-struct MirConnection;
+#include "mir_toolkit/client_types.h"
+
+#include <memory>
+#include <vector>
+#include <functional>
+
+#include <EGL/egl.h>
+
+struct gbm_device;
 
 namespace mir
 {
@@ -30,19 +36,39 @@
 namespace nested
 {
 
+class HostSurface
+{
+public:
+    virtual ~HostSurface() = default;
+
+    virtual EGLNativeWindowType egl_native_window() = 0;
+    virtual void set_event_handler(MirEventDelegate const* handler) = 0;
+
+protected:
+    HostSurface() = default;
+    HostSurface(HostSurface const&) = delete;
+    HostSurface& operator=(HostSurface const&) = delete;
+};
+
 class HostConnection
 {
 public:
-    HostConnection(std::string const& host_socket, std::string const& name);
-    ~HostConnection();
-
+    virtual ~HostConnection() = default;
+
+    virtual std::vector<int> platform_fd_items() = 0;
+    virtual EGLNativeDisplayType egl_native_display() = 0;
+    virtual std::shared_ptr<MirDisplayConfiguration> create_display_config() = 0;
+    virtual void set_display_config_change_callback(std::function<void()> const& cb) = 0;
+    virtual void apply_display_config(MirDisplayConfiguration&) = 0;
+    virtual std::shared_ptr<HostSurface> create_surface(MirSurfaceParameters const&) = 0;
+
+    virtual void drm_auth_magic(int magic) = 0;
+    virtual void drm_set_gbm_device(struct gbm_device* dev) = 0;
+
+protected:
+    HostConnection() = default;
     HostConnection(HostConnection const&) = delete;
-    HostConnection& operator=(HostConnection const& connection_handle) = delete;
-
-    operator MirConnection*() const {return (MirConnection*)connection;}
-
-private:
-    MirConnection* const connection;
+    HostConnection& operator=(HostConnection const&) = delete;
 };
 
 }

=== removed file 'src/server/graphics/nested/mir_api_wrappers.h'
--- src/server/graphics/nested/mir_api_wrappers.h	2013-08-22 11:22:12 +0000
+++ src/server/graphics/nested/mir_api_wrappers.h	1970-01-01 00:00:00 +0000
@@ -1,66 +0,0 @@
-/*
- * 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]>
- */
-
-
-#ifndef MIR_GRAPHICS_NESTED_MIR_API_WRAPPERS_H_
-#define MIR_GRAPHICS_NESTED_MIR_API_WRAPPERS_H_
-
-#include "mir_toolkit/mir_client_library.h"
-
-namespace mir
-{
-namespace graphics
-{
-namespace nested
-{
-/// Utilities for making the Mir "toolkit" API more C++ friendly
-namespace mir_api_wrappers
-{
-class MirDisplayConfigHandle
-{
-public:
-    explicit MirDisplayConfigHandle(MirDisplayConfiguration* display_config) :
-    display_config{display_config}
-    {
-    }
-
-    explicit MirDisplayConfigHandle(MirConnection* connection) :
-    MirDisplayConfigHandle{mir_connection_create_display_config(connection)}
-    {
-    }
-
-    ~MirDisplayConfigHandle() noexcept
-    {
-        mir_display_config_destroy(display_config);
-    }
-
-    MirDisplayConfiguration* operator->() const { return display_config; }
-    operator MirDisplayConfiguration*() const { return display_config; }
-
-private:
-    MirDisplayConfiguration* const display_config;
-
-    MirDisplayConfigHandle(MirDisplayConfigHandle const&) = delete;
-    MirDisplayConfigHandle operator=(MirDisplayConfigHandle const&) = delete;
-};
-}
-}
-}
-}
-
-#endif /* MIR_GRAPHICS_NESTED_MIR_API_WRAPPERS_H_ */

=== added file 'src/server/graphics/nested/mir_client_host_connection.cpp'
--- src/server/graphics/nested/mir_client_host_connection.cpp	1970-01-01 00:00:00 +0000
+++ src/server/graphics/nested/mir_client_host_connection.cpp	2014-04-17 11:09:02 +0000
@@ -0,0 +1,169 @@
+/*
+ * Copyright © 2014 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: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "mir_client_host_connection.h"
+#include "mir_toolkit/mir_client_library.h"
+#include "mir_toolkit/mir_client_library_drm.h"
+
+#include <boost/throw_exception.hpp>
+#include <boost/exception/errinfo_errno.hpp>
+#include <stdexcept>
+
+namespace mgn = mir::graphics::nested;
+
+namespace
+{
+
+void drm_auth_magic_callback(int status, void* context)
+{
+    int* status_ret = static_cast<int*>(context);
+    *status_ret = status;
+}
+
+void display_config_callback_thunk(MirConnection* /*connection*/, void* context)
+{
+    (*static_cast<std::function<void()>*>(context))();
+}
+
+class MirClientHostSurface : public mgn::HostSurface
+{
+public:
+    MirClientHostSurface(
+        MirConnection* mir_connection,
+        MirSurfaceParameters const& surface_parameters)
+        : mir_surface{
+              mir_connection_create_surface_sync(mir_connection, &surface_parameters)}
+    {
+        if (!mir_surface_is_valid(mir_surface))
+        {
+            BOOST_THROW_EXCEPTION(
+                std::runtime_error(mir_surface_get_error_message(mir_surface)));
+        }
+    }
+
+    ~MirClientHostSurface()
+    {
+        mir_surface_release_sync(mir_surface);
+    }
+
+    EGLNativeWindowType egl_native_window() override
+    {
+        return reinterpret_cast<EGLNativeWindowType>(
+            mir_surface_get_egl_native_window(mir_surface));
+    }
+
+    void set_event_handler(MirEventDelegate const* handler) override
+    {
+        mir_surface_set_event_handler(mir_surface, handler);
+    }
+
+private:
+    MirSurface* const mir_surface;
+
+};
+
+}
+
+mgn::MirClientHostConnection::MirClientHostConnection(
+    std::string const& host_socket, std::string const& name)
+    : mir_connection{mir_connect_sync(host_socket.c_str(), name.c_str())},
+      conf_change_callback{[]{}}
+{
+    if (!mir_connection_is_valid(mir_connection))
+    {
+        std::string const msg =
+            "Nested Mir Platform Connection Error: " +
+            std::string(mir_connection_get_error_message(mir_connection));
+
+        BOOST_THROW_EXCEPTION(std::runtime_error(msg));
+    }
+}
+
+mgn::MirClientHostConnection::~MirClientHostConnection()
+{
+    mir_connection_release(mir_connection);
+}
+
+std::vector<int> mgn::MirClientHostConnection::platform_fd_items()
+{
+    MirPlatformPackage pkg;
+    mir_connection_get_platform(mir_connection, &pkg);
+    return std::vector<int>(pkg.fd, pkg.fd + pkg.fd_items);
+}
+
+EGLNativeDisplayType mgn::MirClientHostConnection::egl_native_display()
+{
+    return reinterpret_cast<EGLNativeDisplayType>(
+        mir_connection_get_egl_native_display(mir_connection));
+}
+
+auto mgn::MirClientHostConnection::create_display_config()
+    -> std::shared_ptr<MirDisplayConfiguration>
+{
+    return std::shared_ptr<MirDisplayConfiguration>(
+        mir_connection_create_display_config(mir_connection),
+        [] (MirDisplayConfiguration* c)
+        {
+            if (c) mir_display_config_destroy(c);
+        });
+}
+
+void mgn::MirClientHostConnection::set_display_config_change_callback(
+    std::function<void()> const& callback)
+{
+    mir_connection_set_display_config_change_callback(
+        mir_connection,
+        &display_config_callback_thunk,
+        &(conf_change_callback = callback));
+}
+
+void mgn::MirClientHostConnection::apply_display_config(
+    MirDisplayConfiguration& display_config)
+{
+    mir_connection_apply_display_config(mir_connection, &display_config);
+}
+
+std::shared_ptr<mgn::HostSurface> mgn::MirClientHostConnection::create_surface(
+    MirSurfaceParameters const& surface_parameters)
+{
+    return std::make_shared<MirClientHostSurface>(
+        mir_connection, surface_parameters);
+}
+
+void mgn::MirClientHostConnection::drm_auth_magic(int magic)
+{
+    int status{-1};
+    mir_wait_for(mir_connection_drm_auth_magic(mir_connection, magic,
+                                               drm_auth_magic_callback, &status));
+    if (status)
+    {
+        std::string const msg("Nested Mir failed to authenticate magic");
+        BOOST_THROW_EXCEPTION(
+            boost::enable_error_info(
+                std::runtime_error(msg)) << boost::errinfo_errno(status));
+    }
+}
+
+void mgn::MirClientHostConnection::drm_set_gbm_device(struct gbm_device* dev)
+{
+    if (!mir_connection_drm_set_gbm_device(mir_connection, dev))
+    {
+        std::string const msg("Nested Mir failed to set the gbm device");
+        BOOST_THROW_EXCEPTION(std::runtime_error(msg));
+    }
+}

=== added file 'src/server/graphics/nested/mir_client_host_connection.h'
--- src/server/graphics/nested/mir_client_host_connection.h	1970-01-01 00:00:00 +0000
+++ src/server/graphics/nested/mir_client_host_connection.h	2014-04-17 11:09:02 +0000
@@ -0,0 +1,60 @@
+/*
+ * Copyright © 2014 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: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_GRAPHICS_NESTED_MIR_CLIENT_HOST_CONNECTION_H_
+#define MIR_GRAPHICS_NESTED_MIR_CLIENT_HOST_CONNECTION_H_
+
+#include "host_connection.h"
+
+#include <string>
+
+struct MirConnection;
+
+namespace mir
+{
+namespace graphics
+{
+namespace nested
+{
+
+class MirClientHostConnection : public HostConnection
+{
+public:
+    MirClientHostConnection(std::string const& host_socket, std::string const& name);
+    ~MirClientHostConnection();
+
+    std::vector<int> platform_fd_items() override;
+    EGLNativeDisplayType egl_native_display() override;
+    std::shared_ptr<MirDisplayConfiguration> create_display_config() override;
+    std::shared_ptr<HostSurface> create_surface(MirSurfaceParameters const&) override;
+    void set_display_config_change_callback(std::function<void()> const& cb) override;
+    void apply_display_config(MirDisplayConfiguration&) override;
+
+    void drm_auth_magic(int magic) override;
+    void drm_set_gbm_device(struct gbm_device* dev) override;
+
+private:
+    MirConnection* const mir_connection;
+    std::function<void()> conf_change_callback;
+};
+
+}
+}
+}
+
+#endif /* MIR_GRAPHICS_NESTED_MIR_CLIENT_HOST_CONNECTION_H_ */

=== modified file 'src/server/graphics/nested/nested_display.cpp'
--- src/server/graphics/nested/nested_display.cpp	2014-04-15 05:31:19 +0000
+++ src/server/graphics/nested/nested_display.cpp	2014-04-17 11:09:02 +0000
@@ -19,7 +19,7 @@
 #include "nested_display.h"
 #include "nested_display_configuration.h"
 #include "nested_output.h"
-#include "mir_api_wrappers.h"
+#include "host_connection.h"
 
 #include "mir/geometry/rectangle.h"
 #include "mir/graphics/pixel_format_utils.h"
@@ -28,14 +28,12 @@
 #include "mir/graphics/display_configuration_policy.h"
 #include "mir/graphics/overlapping_output_grouping.h"
 #include "mir/graphics/gl_config.h"
-#include "host_connection.h"
 
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
 
 namespace mg = mir::graphics;
 namespace mgn = mir::graphics::nested;
-namespace mgnw = mir::graphics::nested::mir_api_wrappers;
 namespace geom = mir::geometry;
 
 EGLint const mgn::detail::nested_egl_context_attribs[] =
@@ -60,13 +58,12 @@
 }
 
 mgn::detail::EGLDisplayHandle::EGLDisplayHandle(
-    MirConnection* connection,
+    EGLNativeDisplayType native_display,
     std::shared_ptr<GLConfig> const& gl_config)
     : egl_display(EGL_NO_DISPLAY),
       egl_context_(EGL_NO_CONTEXT),
       gl_config{gl_config}
 {
-    auto const native_display = (EGLNativeDisplayType) mir_connection_get_egl_native_display(connection);
     egl_display = eglGetDisplay(native_display);
     if (egl_display == EGL_NO_DISPLAY)
         BOOST_THROW_EXCEPTION(std::runtime_error("Nested Mir Display Error: Failed to fetch EGL display."));
@@ -112,16 +109,6 @@
     return result;
 }
 
-EGLNativeWindowType mgn::detail::EGLDisplayHandle::native_window(EGLConfig /*egl_config*/, MirSurface* mir_surface) const
-{
-    auto const native_window =
-        reinterpret_cast<EGLNativeWindowType>(mir_surface_get_egl_native_window(mir_surface));
-    if (!native_window)
-        BOOST_THROW_EXCEPTION(std::runtime_error("Nested Mir Display Error: Failed to fetch EGL native window."));
-
-    return native_window;
-}
-
 EGLContext mgn::detail::EGLDisplayHandle::egl_context() const
 {
     return egl_context_;
@@ -141,7 +128,7 @@
     connection{connection},
     event_handler{event_handler},
     display_report{display_report},
-    egl_display{*connection, gl_config},
+    egl_display{connection->egl_native_display(), gl_config},
     outputs{}
 {
     std::shared_ptr<DisplayConfiguration> conf(configuration());
@@ -164,7 +151,7 @@
 {
     return std::unique_ptr<mg::DisplayConfiguration>(
         new NestedDisplayConfiguration(
-            mir_connection_create_display_config(*connection)
+            connection->create_display_config()
         )
     );
 }
@@ -215,16 +202,11 @@
                             static_cast<uint32_t>(output.id.as_value())
                         };
 
-                        auto const mir_surface =
-                                mir_connection_create_surface_sync(*connection, &request_params);
-
-                        if (!mir_surface_is_valid(mir_surface))
-                            BOOST_THROW_EXCEPTION(
-                                        std::runtime_error(mir_surface_get_error_message(mir_surface)));
+                        auto const host_surface = connection->create_surface(request_params);
 
                         result[output.id] = std::make_shared<mgn::detail::NestedOutput>(
                             egl_display,
-                            mir_surface,
+                            host_surface,
                             area,
                             event_handler,
                             output.current_format);
@@ -247,25 +229,14 @@
 {
     auto const& conf = dynamic_cast<NestedDisplayConfiguration const&>(configuration);
 
-    mir_connection_apply_display_config(*connection, conf);
-}
-
-namespace
-{
-void display_config_callback_thunk(MirConnection* /*connection*/, void* context)
-{
-    (*static_cast<mg::DisplayConfigurationChangeHandler*>(context))();
-}
+    connection->apply_display_config(*conf);
 }
 
 void mgn::NestedDisplay::register_configuration_change_handler(
         EventHandlerRegister& /*handlers*/,
         DisplayConfigurationChangeHandler const& conf_change_handler)
 {
-    mir_connection_set_display_config_change_callback(
-        *connection,
-        &display_config_callback_thunk,
-        &(my_conf_change_handler = conf_change_handler));
+    connection->set_display_config_change_callback(conf_change_handler);
 }
 
 void mgn::NestedDisplay::register_pause_resume_handlers(

=== modified file 'src/server/graphics/nested/nested_display.h'
--- src/server/graphics/nested/nested_display.h	2014-04-15 05:31:19 +0000
+++ src/server/graphics/nested/nested_display.h	2014-04-17 11:09:02 +0000
@@ -66,13 +66,12 @@
 class EGLDisplayHandle
 {
 public:
-    EGLDisplayHandle(MirConnection* connection,
+    EGLDisplayHandle(EGLNativeDisplayType native_display,
                      std::shared_ptr<GLConfig> const& gl_config);
     ~EGLDisplayHandle() noexcept;
 
     void initialize(MirPixelFormat format);
     EGLConfig choose_windowed_es_config(MirPixelFormat format) const;
-    EGLNativeWindowType native_window(EGLConfig egl_config, MirSurface* mir_surface) const;
     EGLContext egl_context() const;
     operator EGLDisplay() const { return egl_display; }
 

=== modified file 'src/server/graphics/nested/nested_display_configuration.cpp'
--- src/server/graphics/nested/nested_display_configuration.cpp	2014-03-26 05:48:59 +0000
+++ src/server/graphics/nested/nested_display_configuration.cpp	2014-04-17 11:09:02 +0000
@@ -17,6 +17,7 @@
  */
 
 #include "nested_display_configuration.h"
+#include "host_connection.h"
 
 #include "mir/graphics/pixel_format_utils.h"
 
@@ -29,16 +30,14 @@
 namespace mg = mir::graphics;
 namespace mgn = mg::nested;
 
-mgn::NestedDisplayConfiguration::NestedDisplayConfiguration(MirDisplayConfiguration* connection) :
-display_config{connection}
-{
-}
-
-mgn::NestedDisplayConfiguration::~NestedDisplayConfiguration() noexcept
-{
-}
-
-void mgn::NestedDisplayConfiguration::for_each_card(std::function<void(DisplayConfigurationCard const&)> f) const
+mgn::NestedDisplayConfiguration::NestedDisplayConfiguration(
+    std::shared_ptr<MirDisplayConfiguration> const& display_config)
+    : display_config{display_config}
+{
+}
+
+void mgn::NestedDisplayConfiguration::for_each_card(
+    std::function<void(DisplayConfigurationCard const&)> f) const
 {
     std::for_each(
         display_config->cards,

=== modified file 'src/server/graphics/nested/nested_display_configuration.h'
--- src/server/graphics/nested/nested_display_configuration.h	2014-03-26 05:48:59 +0000
+++ src/server/graphics/nested/nested_display_configuration.h	2014-04-17 11:09:02 +0000
@@ -20,7 +20,8 @@
 #define MIR_GRAPHICS_NESTED_NESTED_DISPLAY_CONFIGURATION_H_
 
 #include "mir/graphics/display_configuration.h"
-#include "mir_api_wrappers.h"
+#include "mir_toolkit/client_types.h"
+#include <memory>
 
 namespace mir
 {
@@ -31,16 +32,17 @@
 class NestedDisplayConfiguration : public DisplayConfiguration
 {
 public:
-    explicit NestedDisplayConfiguration(MirDisplayConfiguration* display_config);
-    virtual ~NestedDisplayConfiguration() noexcept;
+    NestedDisplayConfiguration(
+        std::shared_ptr<MirDisplayConfiguration> const& display_config);
 
     void for_each_card(std::function<void(DisplayConfigurationCard const&)>) const override;
     void for_each_output(std::function<void(DisplayConfigurationOutput const&)>) const override;
     void for_each_output(std::function<void(UserDisplayConfigurationOutput&)>) override;
 
-    operator MirDisplayConfiguration*() const { return display_config; }
+    operator MirDisplayConfiguration*() const { return display_config.get(); }
+
 private:
-    mir_api_wrappers::MirDisplayConfigHandle display_config;
+    std::shared_ptr<MirDisplayConfiguration> const display_config;
 };
 }
 }

=== modified file 'src/server/graphics/nested/nested_output.cpp'
--- src/server/graphics/nested/nested_output.cpp	2014-03-26 05:48:59 +0000
+++ src/server/graphics/nested/nested_output.cpp	2014-04-17 11:09:02 +0000
@@ -17,42 +17,31 @@
  */
 
 #include "nested_output.h"
+#include "host_connection.h"
 #include "mir/input/event_filter.h"
 
-#include "mir_toolkit/mir_client_library.h"
-
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
 
 namespace mgn = mir::graphics::nested;
 namespace geom = mir::geometry;
 
-mgn::detail::MirSurfaceHandle::MirSurfaceHandle(MirSurface* mir_surface) :
-    mir_surface(mir_surface)
-{
-}
-
-mgn::detail::MirSurfaceHandle::~MirSurfaceHandle() noexcept
-{
-    mir_surface_release_sync(mir_surface);
-}
-
 mgn::detail::NestedOutput::NestedOutput(
     EGLDisplayHandle const& egl_display,
-    MirSurface* mir_surface,
+    std::shared_ptr<HostSurface> const& host_surface,
     geometry::Rectangle const& area,
     std::shared_ptr<input::EventFilter> const& event_handler,
     MirPixelFormat preferred_format) :
     egl_display(egl_display),
-    mir_surface{mir_surface},
+    host_surface{host_surface},
     egl_config{egl_display.choose_windowed_es_config(preferred_format)},
     egl_context{egl_display, eglCreateContext(egl_display, egl_config, egl_display.egl_context(), nested_egl_context_attribs)},
     area{area.top_left, area.size},
     event_handler{event_handler},
-    egl_surface{egl_display, egl_display.native_window(egl_config, mir_surface), egl_config}
+    egl_surface{egl_display, host_surface->egl_native_window(), egl_config}
 {
     MirEventDelegate ed = {event_thunk, this};
-    mir_surface_set_event_handler(mir_surface, &ed);
+    host_surface->set_event_handler(&ed);
 }
 
 geom::Rectangle mgn::detail::NestedOutput::view_area() const

=== modified file 'src/server/graphics/nested/nested_output.h'
--- src/server/graphics/nested/nested_output.h	2014-03-26 05:48:59 +0000
+++ src/server/graphics/nested/nested_output.h	2014-04-17 11:09:02 +0000
@@ -27,32 +27,17 @@
 {
 namespace nested
 {
+class HostSurface;
+
 namespace detail
 {
 
-class EGLSurfaceHandle;
-class MirSurfaceHandle
-{
-public:
-    explicit MirSurfaceHandle(MirSurface* mir_surface);
-
-    ~MirSurfaceHandle() noexcept;
-
-    operator MirSurface*() const { return mir_surface; }
-
-private:
-    MirSurface* mir_surface;
-
-    MirSurfaceHandle(MirSurfaceHandle const&) = delete;
-    MirSurfaceHandle operator=(MirSurfaceHandle const&) = delete;
-};
-
 class NestedOutput : public DisplayBuffer
 {
 public:
     NestedOutput(
         EGLDisplayHandle const& egl_display,
-        MirSurface* mir_surface,
+        std::shared_ptr<HostSurface> const& host_surface,
         geometry::Rectangle const& area,
         std::shared_ptr<input::EventFilter> const& event_handler,
         MirPixelFormat preferred_format);
@@ -74,7 +59,7 @@
     NestedOutput operator=(NestedOutput const&) = delete;
 private:
     EGLDisplayHandle const& egl_display;
-    MirSurfaceHandle const mir_surface;
+    std::shared_ptr<HostSurface> const host_surface;
     EGLConfig const egl_config;
     EGLContextStore const egl_context;
     geometry::Rectangle const area;

=== modified file 'src/server/graphics/nested/nested_platform.cpp'
--- src/server/graphics/nested/nested_platform.cpp	2014-03-28 16:15:40 +0000
+++ src/server/graphics/nested/nested_platform.cpp	2014-04-17 11:09:02 +0000
@@ -19,18 +19,11 @@
 #include "nested_platform.h"
 #include "host_connection.h"
 #include "mir/graphics/nested_context.h"
-#include "mir_toolkit/mir_client_library.h"
-#include "mir_toolkit/mir_client_library_drm.h"
 
 #include "nested_display.h"
 
-#include <boost/throw_exception.hpp>
-#include <boost/exception/errinfo_errno.hpp>
-#include <stdexcept>
-
 namespace mg = mir::graphics;
 namespace mgn = mir::graphics::nested;
-namespace mo = mir::options;
 
 namespace
 {
@@ -45,38 +38,17 @@
 
     std::vector<int> platform_fd_items()
     {
-        MirPlatformPackage pkg;
-        mir_connection_get_platform(*connection, &pkg);
-        return std::vector<int>(pkg.fd, pkg.fd + pkg.fd_items);
+        return connection->platform_fd_items();
     }
 
     void drm_auth_magic(int magic)
     {
-        int status;
-        mir_wait_for(mir_connection_drm_auth_magic(*connection, magic,
-                                                   drm_auth_magic_callback, &status));
-        if (status)
-        {
-            std::string const msg("Nested Mir failed to authenticate magic");
-            BOOST_THROW_EXCEPTION(
-                boost::enable_error_info(
-                    std::runtime_error(msg)) << boost::errinfo_errno(status));
-        }
+        connection->drm_auth_magic(magic);
     }
 
     void drm_set_gbm_device(struct gbm_device* dev)
     {
-        if (!mir_connection_drm_set_gbm_device(*connection, dev))
-        {
-            std::string const msg("Nested Mir failed to set the gbm device");
-            BOOST_THROW_EXCEPTION(std::runtime_error(msg));
-        }
-    }
-
-    static void drm_auth_magic_callback(int status, void* context)
-    {
-        int* status_ret = static_cast<int*>(context);
-        *status_ret = status;
+        connection->drm_set_gbm_device(dev);
     }
 
 private:
@@ -95,11 +67,6 @@
 display_report{display_report},
 connection{connection}
 {
-    if (!mir_connection_is_valid(*connection))
-    {
-        BOOST_THROW_EXCEPTION(std::runtime_error("Nested Mir Platform Connection Error: " + std::string(mir_connection_get_error_message(*connection))));
-    }
-
     native_platform->initialize(std::make_shared<MirConnectionNestedContext>(connection));
 }
 
@@ -138,6 +105,5 @@
 
 EGLNativeDisplayType mgn::NestedPlatform::egl_native_display() const
 {
-    return reinterpret_cast<EGLNativeDisplayType>(
-        mir_connection_get_egl_native_display(*connection));
+    return connection->egl_native_display();
 }

=== modified file 'tests/unit-tests/graphics/nested/test_nested_display_configuration.cpp'
--- tests/unit-tests/graphics/nested/test_nested_display_configuration.cpp	2014-03-26 05:48:59 +0000
+++ tests/unit-tests/graphics/nested/test_nested_display_configuration.cpp	2014-04-17 11:09:02 +0000
@@ -53,7 +53,7 @@
 struct NestedDisplayConfiguration : public ::testing::Test
 {
     template<int NoOfOutputs, int NoOfCards>
-    MirDisplayConfiguration* build_test_config(
+    std::shared_ptr<MirDisplayConfiguration> build_test_config(
         MirDisplayOutput const (&outputs)[NoOfOutputs],
         MirDisplayCard const (&cards)[NoOfCards])
     {
@@ -63,7 +63,22 @@
         auto card_tmp = new MirDisplayCard[NoOfCards];
         std::copy(cards, cards+NoOfCards, card_tmp);
 
-        return new MirDisplayConfiguration{ NoOfOutputs, out_tmp, NoOfCards, card_tmp };
+        return std::shared_ptr<MirDisplayConfiguration>(
+            new MirDisplayConfiguration{NoOfOutputs, out_tmp, NoOfCards, card_tmp},
+            [] (MirDisplayConfiguration* conf)
+            {
+                std::for_each(
+                    conf->outputs, conf->outputs + conf->num_outputs,
+                    [] (MirDisplayOutput const& output)
+                    {
+                        delete[] output.modes;
+                        delete[] output.output_formats;
+                    });
+
+                delete[] conf->outputs;
+                delete[] conf->cards;
+                delete conf;
+            });
     }
 
     template<int NoOfModes, int NoOfFormats>
@@ -97,7 +112,7 @@
             init_output(output, modes, formats);
     }
 
-    MirDisplayConfiguration* build_trivial_configuration()
+    std::shared_ptr<MirDisplayConfiguration> build_trivial_configuration()
     {
         static MirDisplayCard const cards[] {{default_card_id,1}};
         static MirDisplayMode const modes[] = {{ 1080, 1920, 4.33f }};
@@ -129,7 +144,7 @@
         return build_test_config(outputs, cards);
     }
 
-    MirDisplayConfiguration* build_non_trivial_configuration()
+    std::shared_ptr<MirDisplayConfiguration> build_non_trivial_configuration()
     {
         static MirDisplayCard const cards[] {
             {default_card_id,1},
@@ -228,7 +243,10 @@
 
 TEST_F(NestedDisplayConfiguration, empty_configuration_is_read_correctly)
 {
-    auto empty_configuration = new MirDisplayConfiguration{ 0, nullptr, 0, nullptr };
+    auto empty_configuration =
+        std::shared_ptr<MirDisplayConfiguration>(
+            new MirDisplayConfiguration{0, nullptr, 0, nullptr});
+
     mgn::NestedDisplayConfiguration config(empty_configuration);
 
     config.for_each_card([](mg::DisplayConfigurationCard const&) { FAIL(); });