Merge lp:~afrantzis/mir/bring-back-r631-fixed into lp:~mir-team/mir/trunk

[Alexandros Frantzis]

Bring back revision 931 with a fix for the crash it caused (LP: #1209053).

Bring back revision 931 with a fix for the crash it caused (LP: #1209053).

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:938
http://jenkins.qa.ubuntu.com/job/mir-ci/1242/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1640
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1525
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/480
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/480/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

LGTM

review: Approve

[Kevin DuBois (kdub)]

looks good to me...
apologies for getting the pixel format for the display wrong in the backed out revision

review: Approve

=== modified file 'include/client/mir_toolkit/mir_client_library.h'
--- include/client/mir_toolkit/mir_client_library.h	2013-08-07 03:08:54 +0000
+++ include/client/mir_toolkit/mir_client_library.h	2013-08-07 10:32:28 +0000
@@ -109,6 +109,17 @@
 MirDisplayConfiguration* mir_connection_create_display_config(MirConnection *connection);
 
 /**
+ * Register a callback to be called when the DisplayConfiguration changes. Once a change has occurred,
+ * you can use mir_connection_create_display_config to see the new configuration
+ *   \param [in] connection  The connection
+ *   \param [in] callback     The function to be called when a display change occurs
+ *   \param [in,out] context  User data passed to the callback function
+ */
+void mir_connection_set_display_config_change_callback(
+    MirConnection* connection,
+    mir_display_config_callback callback, void* context);
+
+/**
  * Destroy the DisplayConfiguration resource acquired from mir_connection_create_display_config
  *   \param [in] display_configuration  The display_configuration information resource to be destroyed 
  */

=== modified file 'include/platform/mir/graphics/display_configuration.h'
--- include/platform/mir/graphics/display_configuration.h	2013-08-07 03:08:54 +0000
+++ include/platform/mir/graphics/display_configuration.h	2013-08-07 10:32:28 +0000
@@ -22,6 +22,7 @@
 #include "mir/int_wrapper.h"
 #include "mir/geometry/size.h"
 #include "mir/geometry/point.h"
+#include "mir/geometry/pixel_format.h"
 
 #include <functional>
 #include <vector>
@@ -61,6 +62,8 @@
     DisplayConfigurationOutputId id;
     /** The id of the card the output is connected to. */
     DisplayConfigurationCardId card_id;
+    /** The pixel formats supported by the output */
+    std::vector<geometry::PixelFormat> pixel_formats;
     /** The modes supported by the output. */
     std::vector<DisplayConfigurationMode> modes;
     /** The physical size of the output. */
@@ -73,6 +76,8 @@
     geometry::Point top_left;
     /** The index in the 'modes' vector of the current output mode. */
     size_t current_mode_index;
+    /** The index in the 'pixel_format' vector of the current output pixel format. */
+    size_t current_format_index;
 };
 
 std::ostream& operator<<(std::ostream& out, DisplayConfigurationMode const& val);

=== modified file 'include/server/mir/frontend/event_sink.h'
--- include/server/mir/frontend/event_sink.h	2013-08-07 03:08:54 +0000
+++ include/server/mir/frontend/event_sink.h	2013-08-07 10:32:28 +0000
@@ -23,6 +23,10 @@
 
 namespace mir
 {
+namespace graphics
+{
+class DisplayConfiguration;
+}
 namespace frontend
 {
 class EventSink
@@ -31,6 +35,7 @@
     virtual ~EventSink() = default;
 
     virtual void handle_event(MirEvent const& e) = 0;
+    virtual void handle_display_config_change(graphics::DisplayConfiguration const& config) = 0;
 
 protected:
     EventSink() = default;

=== modified file 'include/shared/mir_toolkit/client_types.h'
--- include/shared/mir_toolkit/client_types.h	2013-08-07 03:08:54 +0000
+++ include/shared/mir_toolkit/client_types.h	2013-08-07 10:32:28 +0000
@@ -76,6 +76,15 @@
     MirSurface* surface, MirEvent const* event, void* context);
 
 /**
+ * Callback called when a display config change has occurred
+ *   \param [in] connection     The connection associated with the display change
+ *   \param [in,out] context    The context provided by client
+ */
+
+typedef void (*mir_display_config_callback)(
+    MirConnection* connection, void* callback);
+
+/**
  * The order of components in a format enum matches the
  * order of the components as they would be written in an
  *  integer representing a pixel value of that format.

=== modified file 'include/test/mir_test/display_config_matchers.h'
--- include/test/mir_test/display_config_matchers.h	2013-08-07 03:08:54 +0000
+++ include/test/mir_test/display_config_matchers.h	2013-08-07 10:32:28 +0000
@@ -19,15 +19,27 @@
 #ifndef MIR_TEST_DISPLAY_CONFIG_MATCHERS_H_
 #define MIR_TEST_DISPLAY_CONFIG_MATCHERS_H_
 
+#include "mir_protobuf.pb.h"
+#include "mir_toolkit/client_types.h"
+#include "mir/geometry/pixel_format.h"
 #include <gmock/gmock.h>
 
+//avoid a valgrind complaint by defining printer for this type
+static void PrintTo(MirDisplayConfiguration const&, ::std::ostream*) __attribute__ ((unused));
+void PrintTo(MirDisplayConfiguration const&, ::std::ostream*)
+{
+}
+
 namespace mir
 {
 namespace protobuf
 {
 
-//avoid a valgrind complaint by defining printer for this type
 class Connection;
+static void PrintTo(mir::protobuf::DisplayConfiguration const&, ::std::ostream*) __attribute__ ((unused));
+void PrintTo(mir::protobuf::DisplayConfiguration const&, ::std::ostream*) {}
+
+static void PrintTo(mir::protobuf::Connection const&, ::std::ostream*) __attribute__ ((unused));
 void PrintTo(mir::protobuf::Connection const&, ::std::ostream*)
 {
 }
@@ -35,7 +47,7 @@
 }
 namespace test
 {
-MATCHER_P2(ClientTypeConfigMatches, config, formats, "")
+MATCHER_P(ClientTypeConfigMatches, config, "")
 {
     //ASSERT_ doesn't work in MATCHER_P apparently.
     EXPECT_EQ(config.size(), arg->num_displays);
@@ -66,14 +78,12 @@
                 EXPECT_FLOAT_EQ(mode.vrefresh_hz, arg_mode.refresh_rate);
             }
     
-            //TODO: display formats currently is just the formats supported by the allocator. should be
-            //      the formats the display can handle, once we have interfaces from mg::Display for that
-            EXPECT_EQ(0u, arg_display.current_output_format);
-            EXPECT_EQ(formats.size(), arg_display.num_output_formats); 
-            if (formats.size() != arg_display.num_output_formats) return false;
-            for (j = 0u; j < formats.size(); j++)
+            EXPECT_EQ(info.current_format_index, arg_display.current_output_format);
+            EXPECT_EQ(info.pixel_formats.size(), arg_display.num_output_formats); 
+            if (info.pixel_formats.size() != arg_display.num_output_formats) return false;
+            for (j = 0u; j < info.pixel_formats.size(); j++)
             {
-                EXPECT_EQ(formats[j], static_cast<mir::geometry::PixelFormat>(arg_display.output_formats[j]));
+                EXPECT_EQ(info.pixel_formats[j], static_cast<mir::geometry::PixelFormat>(arg_display.output_formats[j]));
             }
         }
         return true;
@@ -81,8 +91,7 @@
     return false;
 }
 
- 
-MATCHER_P2(ProtobufConfigMatches, config, formats, "")
+MATCHER_P(ProtobufConfigMatches, config, "")
 {
     //ASSERT_ doesn't work in MATCHER_P apparently.
     EXPECT_EQ(config.size(), arg.display_output_size());
@@ -92,19 +101,19 @@
         for (auto const& info : config) 
         {
             auto& arg_display = arg.display_output(i++);
-            EXPECT_EQ(info->connected, arg_display.connected());
-            EXPECT_EQ(info->used, arg_display.used());
-            EXPECT_EQ(info->id.as_value(), arg_display.output_id());
-            EXPECT_EQ(info->card_id.as_value(), arg_display.card_id());
-            EXPECT_EQ(info->physical_size_mm.width.as_uint32_t(), arg_display.physical_width_mm()); 
-            EXPECT_EQ(info->physical_size_mm.height.as_uint32_t(), arg_display.physical_height_mm()); 
-            EXPECT_EQ(static_cast<int>(info->top_left.x.as_uint32_t()), arg_display.position_x()); 
-            EXPECT_EQ(static_cast<int>(info->top_left.y.as_uint32_t()), arg_display.position_y());
-            EXPECT_EQ(info->current_mode_index, arg_display.current_mode());
-            EXPECT_EQ(info->modes.size(), arg_display.mode_size());
-            if (info->modes.size() != static_cast<unsigned int>(arg_display.mode_size())) return false;
+            EXPECT_EQ(info.connected, arg_display.connected());
+            EXPECT_EQ(info.used, arg_display.used());
+            EXPECT_EQ(info.id.as_value(), arg_display.output_id());
+            EXPECT_EQ(info.card_id.as_value(), arg_display.card_id());
+            EXPECT_EQ(info.physical_size_mm.width.as_uint32_t(), arg_display.physical_width_mm()); 
+            EXPECT_EQ(info.physical_size_mm.height.as_uint32_t(), arg_display.physical_height_mm()); 
+            EXPECT_EQ(static_cast<int>(info.top_left.x.as_uint32_t()), arg_display.position_x()); 
+            EXPECT_EQ(static_cast<int>(info.top_left.y.as_uint32_t()), arg_display.position_y());
+            EXPECT_EQ(info.current_mode_index, arg_display.current_mode());
+            EXPECT_EQ(info.modes.size(), arg_display.mode_size());
+            if (info.modes.size() != static_cast<unsigned int>(arg_display.mode_size())) return false;
             auto j = 0u;
-            for (auto const& mode : info->modes)
+            for (auto const& mode : info.modes)
             {
                 auto& arg_mode = arg_display.mode(j++);
                 EXPECT_EQ(mode.size.width.as_uint32_t(), arg_mode.horizontal_resolution());
@@ -112,18 +121,64 @@
                 EXPECT_FLOAT_EQ(mode.vrefresh_hz, arg_mode.refresh_rate());
             }
 
-            EXPECT_EQ(0u, arg_display.current_format());
-            EXPECT_EQ(formats.size(), arg_display.pixel_format_size()); 
-            if (formats.size() != static_cast<unsigned int>(arg_display.pixel_format_size())) return false;
-            for (j=0u; j<formats.size(); j++)
+            EXPECT_EQ(info.current_format_index, arg_display.current_format());
+            EXPECT_EQ(info.pixel_formats.size(), arg_display.pixel_format_size()); 
+            if (info.pixel_formats.size() != static_cast<unsigned int>(arg_display.pixel_format_size())) return false;
+            for ( j = 0u; j < info.pixel_formats.size(); j++)
             {
-                EXPECT_EQ(formats[j], static_cast<mir::geometry::PixelFormat>(arg_display.pixel_format(j)));
+                EXPECT_EQ(info.pixel_formats[j], static_cast<mir::geometry::PixelFormat>(arg_display.pixel_format(j)));
             }
         }
         return true;;
     }
     return false;
 }
+
+MATCHER_P(ClientTypeMatchesProtobuf, config, "")
+{
+    //ASSERT_ doesn't work in MATCHER_P apparently.
+    EXPECT_EQ(config.display_output_size(), arg.num_displays);
+    if (config.display_output_size() == static_cast<int>(arg.num_displays))
+    {
+        for (auto i = 0u; i < arg.num_displays; i++) 
+        {
+            auto& conf_display = config.display_output(i);
+            auto& arg_display = arg.displays[i];
+            EXPECT_EQ(conf_display.connected(), arg_display.connected);
+            EXPECT_EQ(conf_display.used(), arg_display.used);
+            EXPECT_EQ(conf_display.output_id(), arg_display.output_id);
+            EXPECT_EQ(conf_display.card_id(), arg_display.card_id);
+            EXPECT_EQ(conf_display.physical_width_mm(), arg_display.physical_width_mm); 
+            EXPECT_EQ(conf_display.physical_height_mm(), arg_display.physical_height_mm); 
+            EXPECT_EQ(conf_display.position_x(), arg_display.position_x); 
+            EXPECT_EQ(conf_display.position_y(), arg_display.position_y);
+
+            EXPECT_EQ(conf_display.current_mode(), arg_display.current_mode);
+            EXPECT_EQ(conf_display.mode_size(), arg_display.num_modes);
+            if (conf_display.mode_size() != static_cast<int>(arg_display.num_modes)) return false;
+            for (auto j = 0u; j <  arg_display.num_modes; j++)
+            {
+                auto const& conf_mode = conf_display.mode(j);
+                auto const& arg_mode = arg_display.modes[j];
+                EXPECT_EQ(conf_mode.horizontal_resolution(), arg_mode.horizontal_resolution);
+                EXPECT_EQ(conf_mode.vertical_resolution(), arg_mode.vertical_resolution);
+                EXPECT_FLOAT_EQ(conf_mode.refresh_rate(), arg_mode.refresh_rate);
+            }
+
+            EXPECT_EQ(conf_display.current_format(), arg_display.current_output_format);
+            EXPECT_EQ(conf_display.pixel_format_size(), arg_display.num_output_formats); 
+            if (conf_display.pixel_format_size() != static_cast<int>(arg_display.num_output_formats)) return false;
+            for (auto j = 0u; j <  arg_display.num_output_formats; j++)
+            {
+                EXPECT_EQ(conf_display.pixel_format(j), arg_display.output_formats[j]);
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+
 }
 }
 #endif /* MIR_TEST_DISPLAY_CONFIG_MATCHERS_H_ */

=== modified file 'include/test/mir_test_doubles/null_event_sink.h'
--- include/test/mir_test_doubles/null_event_sink.h	2013-08-07 03:08:54 +0000
+++ include/test/mir_test_doubles/null_event_sink.h	2013-08-07 10:32:28 +0000
@@ -29,6 +29,7 @@
 struct NullEventSink : public frontend::EventSink
 {
     void handle_event(MirEvent const&) {}
+    void handle_display_config_change(graphics::DisplayConfiguration const&) {}
 };
 }
 }

=== added file 'include/test/mir_test_doubles/stub_display_configuration.h'
--- include/test/mir_test_doubles/stub_display_configuration.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_display_configuration.h	2013-08-07 10:32:28 +0000
@@ -0,0 +1,95 @@
+/*
+ * 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: Kevin DuBois <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_DISPLAY_CONFIGURATION_H_
+#define MIR_TEST_DOUBLES_STUB_DISPLAY_CONFIGURATION_H_
+#include "mir/graphics/display_configuration.h"
+#include <vector>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class StubDisplayConfig : public graphics::DisplayConfiguration
+{
+public:
+    StubDisplayConfig()
+    {
+        /* construct a non-trivial dummy display config to send */
+        int mode_index = 0;
+        for (auto i = 0u; i < 3u; i++)
+        {
+            std::vector<graphics::DisplayConfigurationMode> modes;
+            std::vector<geometry::PixelFormat> pfs{
+                geometry::PixelFormat::bgr_888,
+                geometry::PixelFormat::abgr_8888,
+                geometry::PixelFormat::xbgr_8888};
+
+            for (auto j = 0u; j <= i; j++)
+            {
+                geometry::Size sz{mode_index*4, mode_index*3};
+                graphics::DisplayConfigurationMode mode{sz, 10.0f * mode_index };
+                mode_index++;
+                modes.push_back(mode);
+            }
+
+            size_t mode_index = modes.size() - 1; 
+            geometry::Size physical_size{};
+            geometry::Point top_left{};
+            graphics::DisplayConfigurationOutput output{
+                graphics::DisplayConfigurationOutputId{static_cast<int>(i)},
+                graphics::DisplayConfigurationCardId{static_cast<int>(i)},
+                pfs, modes,
+                physical_size,
+                ((i % 2) == 0),
+                ((i % 2) == 1),
+                top_left,
+                mode_index, 1u
+            };
+
+            outputs.push_back(output);
+        }
+    };
+
+    void for_each_card(std::function<void(graphics::DisplayConfigurationCard const&)>) const
+    {
+    }
+
+    void for_each_output(std::function<void(graphics::DisplayConfigurationOutput const&)> f) const
+    {
+        for (auto& disp : outputs)
+        {
+            f(disp);
+        }
+    }
+
+    void configure_output(graphics::DisplayConfigurationOutputId, bool, geometry::Point, size_t)
+    {
+    }
+
+    std::vector<graphics::DisplayConfigurationOutput> outputs;
+};
+
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_STUB_DISPLAY_CONFIGURATION_H_ */

=== modified file 'src/client/connection_configuration.h'
--- src/client/connection_configuration.h	2013-08-07 03:08:54 +0000
+++ src/client/connection_configuration.h	2013-08-07 10:32:28 +0000
@@ -48,6 +48,7 @@
 class SurfaceMap;
 class Logger;
 class ClientPlatformFactory;
+class DisplayConfiguration;
 
 class ConnectionConfiguration
 {
@@ -59,6 +60,7 @@
     virtual std::shared_ptr<mir::logging::Logger> the_logger() = 0;
     virtual std::shared_ptr<ClientPlatformFactory> the_client_platform_factory() = 0;
     virtual std::shared_ptr<input::receiver::InputPlatform> the_input_platform() = 0;
+    virtual std::shared_ptr<DisplayConfiguration> the_display_configuration() = 0;
 
 protected:
     ConnectionConfiguration() = default;

=== modified file 'src/client/default_connection_configuration.cpp'
--- src/client/default_connection_configuration.cpp	2013-08-07 03:08:54 +0000
+++ src/client/default_connection_configuration.cpp	2013-08-07 10:32:28 +0000
@@ -18,6 +18,7 @@
 
 #include "default_connection_configuration.h"
 
+#include "display_configuration.h"
 #include "rpc/make_rpc_channel.h"
 #include "rpc/null_rpc_report.h"
 #include "mir/logging/dumb_console_logger.h"
@@ -58,7 +59,7 @@
         [this]
         {
             return mcl::rpc::make_rpc_channel(
-                the_socket_file(), the_surface_map(), the_rpc_report());
+                the_socket_file(), the_surface_map(), the_display_configuration(), the_rpc_report());
         });
 }
 
@@ -115,3 +116,12 @@
                 return std::make_shared<mcl::rpc::NullRpcReport>();
         });
 }
+
+std::shared_ptr<mcl::DisplayConfiguration> mcl::DefaultConnectionConfiguration::the_display_configuration()
+{
+    return display_configuration(
+        []
+        {
+            return std::make_shared<mcl::DisplayConfiguration>();
+        });
+}

=== modified file 'src/client/default_connection_configuration.h'
--- src/client/default_connection_configuration.h	2013-08-07 03:08:54 +0000
+++ src/client/default_connection_configuration.h	2013-08-07 10:32:28 +0000
@@ -45,6 +45,7 @@
     std::shared_ptr<mir::logging::Logger> the_logger();
     std::shared_ptr<ClientPlatformFactory> the_client_platform_factory();
     std::shared_ptr<input::receiver::InputPlatform> the_input_platform();
+    std::shared_ptr<DisplayConfiguration> the_display_configuration();
 
     virtual std::string the_socket_file();
     virtual std::shared_ptr<rpc::RpcReport> the_rpc_report();
@@ -55,6 +56,7 @@
     CachedPtr<ClientPlatformFactory> client_platform_factory;
     CachedPtr<input::receiver::InputPlatform> input_platform;
     CachedPtr<SurfaceMap> surface_map;
+    CachedPtr<DisplayConfiguration> display_configuration;
 
     CachedPtr<rpc::RpcReport> rpc_report;
 

=== modified file 'src/client/display_configuration.cpp'
--- src/client/display_configuration.cpp	2013-08-07 03:08:54 +0000
+++ src/client/display_configuration.cpp	2013-08-07 10:32:28 +0000
@@ -31,14 +31,29 @@
     for(auto i=0u; i< config->num_displays; i++)
     {
         if (config->displays[i].modes)
-            ::operator delete(config->displays[i].modes);
+            delete[] config->displays[i].modes;
         if (config->displays[i].output_formats)
-            ::operator delete(config->displays[i].output_formats);
+            delete[] config->displays[i].output_formats;
     }
     if (config->displays)
-        ::operator delete(config->displays);
-
-    ::operator delete(config);
+        delete[] config->displays;
+
+    delete config;
+}
+
+mcl::DisplayOutput::DisplayOutput(size_t num_modes_, size_t num_formats)
+{
+    num_modes = num_modes_;
+    modes = new MirDisplayMode[num_modes];
+   
+    num_output_formats = num_formats; 
+    output_formats = new MirPixelFormat[num_formats];
+}
+
+mcl::DisplayOutput::~DisplayOutput()
+{
+    delete[] modes;
+    delete[] output_formats;
 }
 
 namespace
@@ -48,7 +63,7 @@
     output.card_id = msg.card_id();
     output.output_id = msg.output_id();
 
-    for(auto i=0u; i < output.num_modes; i++)
+    for (auto i = 0u; i < output.num_modes; i++)
     {
         auto mode = msg.mode(i);
         output.modes[i].horizontal_resolution = mode.horizontal_resolution(); 
@@ -57,7 +72,7 @@
     }
     output.current_mode = msg.current_mode();
 
-    for(auto i=0u; i < output.num_output_formats; i++)
+    for (auto i = 0u; i < output.num_output_formats; i++)
     {
         output.output_formats[i] = static_cast<MirPixelFormat>(msg.pixel_format(i));
     }
@@ -70,26 +85,77 @@
     output.physical_width_mm = msg.physical_width_mm();
     output.physical_height_mm = msg.physical_height_mm();
 }
-}
-
-MirDisplayConfiguration* mcl::set_display_config_from_message(mp::Connection const& connection_msg)
-{
-    auto config = static_cast<MirDisplayConfiguration*>(::operator new(sizeof(MirDisplayConfiguration)));
-    config->num_displays = connection_msg.display_output_size();
-    config->displays = static_cast<MirDisplayOutput*>(::operator new(sizeof(MirDisplayOutput) * config->num_displays));
-
-    for(auto i=0u; i < config->num_displays; i++)
-    {
-        auto output = connection_msg.display_output(i);
-        config->displays[i].num_output_formats = output.pixel_format_size();
-        config->displays[i].output_formats = static_cast<MirPixelFormat*>(
-            ::operator new(sizeof(MirPixelFormat)*config->displays[i].num_output_formats));
- 
-        config->displays[i].num_modes = output.mode_size();
-        config->displays[i].modes = static_cast<MirDisplayMode*>(
-            ::operator new(sizeof(MirDisplayMode)*config->displays[i].num_modes));
-
-        fill_display_output(config->displays[i], output);
-    }
-    return config;
+
+}
+
+
+mcl::DisplayConfiguration::DisplayConfiguration()
+    : notify_change([]{})
+{
+}
+
+mcl::DisplayConfiguration::~DisplayConfiguration()
+{
+}
+
+void mcl::DisplayConfiguration::update_configuration(mp::Connection const& connection_msg)
+{
+    std::unique_lock<std::mutex> lk(guard);
+    outputs.clear();
+    for (auto i = 0; i < connection_msg.display_output_size(); i++)
+    {
+        auto const& msg_output = connection_msg.display_output(i);
+        auto output = std::make_shared<mcl::DisplayOutput>(msg_output.mode_size(), msg_output.pixel_format_size());
+        fill_display_output(*output, msg_output);
+        outputs.push_back(output);
+    }
+}
+
+void mcl::DisplayConfiguration::update_configuration(mp::DisplayConfiguration const& msg)
+{
+    {
+        std::unique_lock<std::mutex> lk(guard);
+        outputs.clear();
+        for (auto i = 0; i < msg.display_output_size(); i++)
+        {
+            auto const& msg_output = msg.display_output(i);
+            auto output = std::make_shared<mcl::DisplayOutput>(msg_output.mode_size(), msg_output.pixel_format_size());
+            fill_display_output(*output, msg_output);
+            outputs.push_back(output);
+        }
+    }
+
+    notify_change();
+}
+
+//user is responsible for freeing the returned value
+MirDisplayConfiguration* mcl::DisplayConfiguration::copy_to_client() const
+{
+    std::unique_lock<std::mutex> lk(guard);
+    auto new_config = new MirDisplayConfiguration;
+    new_config->num_displays = outputs.size();
+    new_config->displays = new MirDisplayOutput[new_config->num_displays];
+
+    auto i=0u;
+    for (auto const& out : outputs)
+    {
+        auto new_info = &new_config->displays[i++];
+        MirDisplayOutput* output = out.get();
+        std::memcpy(new_info, output, sizeof(MirDisplayOutput)); 
+
+        new_info->output_formats = new MirPixelFormat[new_info->num_output_formats];
+        auto format_size = sizeof(MirPixelFormat) * new_info->num_output_formats;
+        std::memcpy(new_info->output_formats, output->output_formats, format_size);
+
+        new_info->modes = new MirDisplayMode[new_info->num_modes];
+        auto mode_size = sizeof(MirDisplayMode)* new_info->num_modes;
+        std::memcpy(new_info->modes, output->modes, mode_size);
+    }
+    return new_config;
+}
+
+void mcl::DisplayConfiguration::set_display_change_handler(std::function<void()> const& fn)
+{
+    std::unique_lock<std::mutex> lk(guard);
+    notify_change = fn;
 }

=== modified file 'src/client/display_configuration.h'
--- src/client/display_configuration.h	2013-08-07 03:08:54 +0000
+++ src/client/display_configuration.h	2013-08-07 10:32:28 +0000
@@ -22,14 +22,44 @@
 #include "mir_toolkit/client_types.h"
 #include "mir_protobuf.pb.h"
 
+#include <mutex>
+#include <functional>
+#include <vector>
+#include <memory>
+
 namespace mir
 {
 namespace client
 {
+class DisplayOutput : public MirDisplayOutput
+{
+public:
+    DisplayOutput(size_t num_modes_, size_t num_formats);
+    ~DisplayOutput();
+};
 
-//convenient helpers
+//convenient helper
 void delete_config_storage(MirDisplayConfiguration* config);
-MirDisplayConfiguration* set_display_config_from_message(mir::protobuf::Connection const& connection_msg);
+
+class DisplayConfiguration
+{
+public:
+    DisplayConfiguration();
+    ~DisplayConfiguration();
+
+    void update_configuration(mir::protobuf::Connection const& msg);
+    void update_configuration(mir::protobuf::DisplayConfiguration const& msg);
+    void set_display_change_handler(std::function<void()> const&);
+
+    //copying to a c POD, so kinda kludgy
+    MirDisplayConfiguration* copy_to_client() const;
+
+private:
+    std::mutex mutable guard;
+    std::vector<std::shared_ptr<DisplayOutput>> outputs;
+    std::function<void()> notify_change;
+};
+
 
 }
 }

=== modified file 'src/client/mir_client_library.cpp'
--- src/client/mir_client_library.cpp	2013-08-07 03:08:54 +0000
+++ src/client/mir_client_library.cpp	2013-08-07 10:32:28 +0000
@@ -239,7 +239,7 @@
 
 MirDisplayConfiguration* mir_connection_create_display_config(MirConnection *connection)
 {
-    if (connection) 
+    if (connection)
         return connection->create_copy_of_display_config();
     return nullptr;
 }
@@ -397,10 +397,17 @@
     return surf ? surf->attrib(mir_surface_attrib_swapinterval) : -1;
 }
 
+void mir_connection_set_display_config_change_callback(MirConnection* connection,
+    mir_display_config_callback callback, void* context)
+{
+    if (connection)
+        connection->register_display_change_callback(callback, context);
+}
+
 MirWaitHandle* mir_connection_apply_display_config(MirConnection *connection, MirDisplayConfiguration* display_configuration)
 {
     if (!connection)
         return NULL;
  
-    return connection->configure_display(display_configuration); 
+    return connection->configure_display(display_configuration);
 }

=== modified file 'src/client/mir_connection.cpp'
--- src/client/mir_connection.cpp	2013-08-07 03:08:54 +0000
+++ src/client/mir_connection.cpp	2013-08-07 10:32:28 +0000
@@ -49,6 +49,7 @@
         logger(conf.the_logger()),
         client_platform_factory(conf.the_client_platform_factory()),
         input_platform(conf.the_input_platform()),
+        display_configuration(conf.the_display_configuration()),
         surface_map(conf.the_surface_map())
 {
     {
@@ -156,6 +157,7 @@
          */
         platform = client_platform_factory->create_client_platform(this);
         native_display = platform->create_egl_native_display();
+        display_configuration->update_configuration(connect_result);
     }
 
     callback(this, context);
@@ -275,11 +277,7 @@
 MirDisplayConfiguration* MirConnection::create_copy_of_display_config()
 {
     std::lock_guard<std::recursive_mutex> lock(mutex);
-    if (!connect_result.has_error() && (connect_result.display_output_size() > 0))
-    {
-        return mcl::set_display_config_from_message(connect_result);
-    }
-    return nullptr;
+    return display_configuration->copy_to_client();
 }
 
 void MirConnection::possible_pixel_formats(MirPixelFormat* formats,
@@ -324,6 +322,11 @@
     surface_map->insert(id, surface);
 }
 
+void MirConnection::register_display_change_callback(mir_display_config_callback callback, void* context)
+{
+    display_configuration->set_display_change_handler(std::bind(callback, this, context));
+}
+
 bool MirConnection::validate_user_display_config(MirDisplayConfiguration* config)
 {
     std::lock_guard<std::recursive_mutex> lock(mutex);

=== modified file 'src/client/mir_connection.h'
--- src/client/mir_connection.h	2013-08-07 03:08:54 +0000
+++ src/client/mir_connection.h	2013-08-07 10:32:28 +0000
@@ -43,6 +43,7 @@
 class ConnectionConfiguration;
 class ClientPlatformFactory;
 class SurfaceMap;
+class DisplayConfiguration;
 
 namespace rpc
 {
@@ -98,6 +99,8 @@
                                   mir_drm_auth_magic_callback callback,
                                   void* context);
 
+    void register_display_change_callback(mir_display_config_callback callback, void* context);
+
     void populate(MirPlatformPackage& platform_package);
     MirDisplayConfiguration* create_copy_of_display_config(); 
     void possible_pixel_formats(MirPixelFormat* formats,
@@ -144,6 +147,8 @@
     std::mutex release_wait_handle_guard;
     std::vector<MirWaitHandle*> release_wait_handles;
 
+    std::shared_ptr<mir::client::DisplayConfiguration> const display_configuration;
+
     std::shared_ptr<mir::client::SurfaceMap> surface_map;
     static std::mutex connection_guard;
     static std::unordered_set<MirConnection*> valid_connections;

=== modified file 'src/client/rpc/make_rpc_channel.h'
--- src/client/rpc/make_rpc_channel.h	2013-08-07 03:08:54 +0000
+++ src/client/rpc/make_rpc_channel.h	2013-08-07 10:32:28 +0000
@@ -25,6 +25,7 @@
 namespace client
 {
 class SurfaceMap;
+class DisplayConfiguration;
 
 namespace rpc
 {
@@ -34,6 +35,7 @@
 std::shared_ptr<MirBasicRpcChannel>
 make_rpc_channel(std::string const& name,
                  std::shared_ptr<SurfaceMap> const& map,
+                 std::shared_ptr<DisplayConfiguration> const& disp_conf,
                  std::shared_ptr<RpcReport> const& rpc_report);
 }
 }

=== modified file 'src/client/rpc/make_socket_rpc_channel.cpp'
--- src/client/rpc/make_socket_rpc_channel.cpp	2013-08-07 03:08:54 +0000
+++ src/client/rpc/make_socket_rpc_channel.cpp	2013-08-07 10:32:28 +0000
@@ -25,7 +25,8 @@
 std::shared_ptr<mclr::MirBasicRpcChannel>
 mclr::make_rpc_channel(std::string const& name,
                        std::shared_ptr<mcl::SurfaceMap> const& map,
+                       std::shared_ptr<mcl::DisplayConfiguration> const& disp_conf,
                        std::shared_ptr<RpcReport> const& rpc_report)
 { 
-    return std::make_shared<MirSocketRpcChannel>(name, map, rpc_report);
+    return std::make_shared<MirSocketRpcChannel>(name, map, disp_conf, rpc_report);
 }

=== modified file 'src/client/rpc/mir_socket_rpc_channel.cpp'
--- src/client/rpc/mir_socket_rpc_channel.cpp	2013-08-07 03:08:54 +0000
+++ src/client/rpc/mir_socket_rpc_channel.cpp	2013-08-07 10:32:28 +0000
@@ -22,6 +22,7 @@
 #include "mir/protobuf/google_protobuf_guard.h"
 #include "../surface_map.h"
 #include "../mir_surface.h"
+#include "../display_configuration.h"
 
 #include "mir_protobuf.pb.h"  // For Buffer frig
 #include "mir_protobuf_wire.pb.h"
@@ -45,13 +46,15 @@
 mclr::MirSocketRpcChannel::MirSocketRpcChannel(
     std::string const& endpoint,
     std::shared_ptr<mcl::SurfaceMap> const& surface_map,
+    std::shared_ptr<DisplayConfiguration> const& disp_config,
     std::shared_ptr<RpcReport> const& rpc_report) :
     rpc_report(rpc_report),
     pending_calls(rpc_report),
     work(io_service),
     endpoint(endpoint),
     socket(io_service),
-    surface_map(surface_map)
+    surface_map(surface_map),
+    display_configuration(disp_config)
 {
     socket.connect(endpoint);
 
@@ -319,6 +322,12 @@
     mir::protobuf::EventSequence seq;
 
     seq.ParseFromString(event);
+
+    if (seq.has_display_configuration())
+    {
+        display_configuration->update_configuration(seq.display_configuration());
+    }
+
     int const nevents = seq.event_size();
     for (int i = 0; i != nevents; ++i)
     {
@@ -350,7 +359,7 @@
             {
                 rpc_report->event_parsing_failed(event);
             }
-        }
+        } 
     }
 }
 

=== modified file 'src/client/rpc/mir_socket_rpc_channel.h'
--- src/client/rpc/mir_socket_rpc_channel.h	2013-08-07 03:08:54 +0000
+++ src/client/rpc/mir_socket_rpc_channel.h	2013-08-07 10:32:28 +0000
@@ -41,6 +41,7 @@
 
 namespace client
 {
+class DisplayConfiguration;
 class SurfaceMap;
 namespace rpc
 {
@@ -52,6 +53,7 @@
 public:
     MirSocketRpcChannel(std::string const& endpoint,
                         std::shared_ptr<SurfaceMap> const& surface_map,
+                        std::shared_ptr<DisplayConfiguration> const& disp_config,
                         std::shared_ptr<RpcReport> const& rpc_report);
     ~MirSocketRpcChannel();
 
@@ -84,6 +86,7 @@
     mir::protobuf::wire::Result read_message_body(const size_t body_size);
 
     std::shared_ptr<SurfaceMap> surface_map;
+    std::shared_ptr<DisplayConfiguration> display_configuration;
 };
 
 }

=== modified file 'src/server/frontend/event_sender.cpp'
--- src/server/frontend/event_sender.cpp	2013-08-07 03:08:54 +0000
+++ src/server/frontend/event_sender.cpp	2013-08-07 10:32:28 +0000
@@ -17,11 +17,15 @@
  */
 
 #include "mir/frontend/client_constants.h"
+#include "mir/graphics/display_configuration.h"
 #include "event_sender.h"
 #include "message_sender.h"
+#include "protobuf_buffer_packer.h"
+
 #include "mir_protobuf_wire.pb.h"
 #include "mir_protobuf.pb.h"
 
+namespace mg = mir::graphics;
 namespace mfd = mir::frontend::detail;
 namespace mp = mir::protobuf;
 
@@ -41,15 +45,32 @@
         mp::Event *ev = seq.add_event();
         ev->set_raw(&e, sizeof(MirEvent));
 
-        std::string buffer;
-        buffer.reserve(serialization_buffer_size);
-        seq.SerializeToString(&buffer);
-
-        mir::protobuf::wire::Result result;
-        result.add_events(buffer);
-
-        result.SerializeToString(&buffer);
-
-        sender->send(buffer);
+        send_event_sequence(seq);
     }
 }
+
+void mfd::EventSender::handle_display_config_change(graphics::DisplayConfiguration const& display_config)
+{
+    mp::EventSequence seq;
+    auto message = seq.mutable_display_configuration();
+
+    display_config.for_each_output([&message](mg::DisplayConfigurationOutput const& config)
+    {
+        auto disp = message->add_display_output();
+        mfd::pack_protobuf_display_output(disp, config); 
+    });
+
+    send_event_sequence(seq);
+}
+
+void mfd::EventSender::send_event_sequence(mp::EventSequence& seq)
+{
+    std::string send_buffer;
+    send_buffer.reserve(serialization_buffer_size);
+    seq.SerializeToString(&send_buffer);
+
+    mir::protobuf::wire::Result result;
+    result.add_events(send_buffer);
+    result.SerializeToString(&send_buffer);
+    sender->send(send_buffer);
+}

=== modified file 'src/server/frontend/event_sender.h'
--- src/server/frontend/event_sender.h	2013-08-07 03:08:54 +0000
+++ src/server/frontend/event_sender.h	2013-08-07 10:32:28 +0000
@@ -24,6 +24,10 @@
 
 namespace mir
 {
+namespace protobuf
+{
+class EventSequence;
+}
 namespace frontend
 {
 namespace detail
@@ -35,8 +39,11 @@
 public:
     explicit EventSender(std::shared_ptr<MessageSender> const& socket_sender);
     void handle_event(MirEvent const& e);
+    void handle_display_config_change(graphics::DisplayConfiguration const& config);
 
 private:
+    void send_event_sequence(protobuf::EventSequence&);
+
     std::shared_ptr<MessageSender> const sender;
 };
  

=== modified file 'src/server/frontend/protobuf_buffer_packer.cpp'
--- src/server/frontend/protobuf_buffer_packer.cpp	2013-08-07 03:08:54 +0000
+++ src/server/frontend/protobuf_buffer_packer.cpp	2013-08-07 10:32:28 +0000
@@ -18,8 +18,38 @@
 
 #include "protobuf_buffer_packer.h"
 
+#include "mir/graphics/display_configuration.h"
+#include "mir_protobuf.pb.h"
+
 namespace mfd=mir::frontend::detail;
 
+void mfd::pack_protobuf_display_output(protobuf::DisplayOutput* output,
+                                       graphics::DisplayConfigurationOutput const& config)
+{
+    output->set_output_id(config.id.as_value());
+    output->set_card_id(config.card_id.as_value());
+    output->set_connected(config.connected);
+    output->set_used(config.used);
+    output->set_physical_width_mm(config.physical_size_mm.width.as_uint32_t());
+    output->set_physical_height_mm(config.physical_size_mm.height.as_uint32_t());
+    output->set_position_x(config.top_left.x.as_uint32_t());
+    output->set_position_y(config.top_left.y.as_uint32_t());
+    for (auto const& mode : config.modes)
+    {
+        auto output_mode = output->add_mode();
+        output_mode->set_horizontal_resolution(mode.size.width.as_uint32_t()); 
+        output_mode->set_vertical_resolution(mode.size.height.as_uint32_t());
+        output_mode->set_refresh_rate(mode.vrefresh_hz);
+    }
+    output->set_current_mode(config.current_mode_index);
+
+    for (auto const& pf : config.pixel_formats)
+    {
+        output->add_pixel_format(static_cast<uint32_t>(pf));
+    }
+    output->set_current_format(config.current_format_index);
+}
+
 mfd::ProtobufBufferPacker::ProtobufBufferPacker(protobuf::Buffer* response)
     : buffer_response(response)
 {

=== modified file 'src/server/frontend/protobuf_buffer_packer.h'
--- src/server/frontend/protobuf_buffer_packer.h	2013-08-07 03:08:54 +0000
+++ src/server/frontend/protobuf_buffer_packer.h	2013-08-07 10:32:28 +0000
@@ -24,11 +24,17 @@
 
 namespace mir
 {
+namespace graphics
+{
+struct DisplayConfigurationOutput;
+}
 namespace frontend
 {
 namespace detail
 {
 
+void pack_protobuf_display_output(protobuf::DisplayOutput* output, graphics::DisplayConfigurationOutput const&);
+
 class ProtobufBufferPacker : public graphics::BufferIPCPacker
 {
 public:

=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2013-08-07 03:08:54 +0000
+++ src/server/frontend/session_mediator.cpp	2013-08-07 10:32:28 +0000
@@ -98,33 +98,11 @@
         platform->add_fd(ipc_fds);
 
     auto display_config = display_changer->active_configuration();
-    auto supported_pfs = buffer_allocator->supported_pixel_formats();
-    display_config->for_each_output([&response, &supported_pfs](mg::DisplayConfigurationOutput const& config)
+    display_config->for_each_output([&response](mg::DisplayConfigurationOutput const& config)
     {
         auto output = response->add_display_output();
-        output->set_output_id(config.id.as_value());
-        output->set_card_id(config.card_id.as_value());
-        output->set_connected(config.connected);
-        output->set_used(config.used);
-        output->set_physical_width_mm(config.physical_size_mm.width.as_uint32_t());
-        output->set_physical_height_mm(config.physical_size_mm.height.as_uint32_t());
-        output->set_position_x(config.top_left.x.as_uint32_t());
-        output->set_position_y(config.top_left.y.as_uint32_t());
-        for (auto const& mode : config.modes)
-        {
-            auto output_mode = output->add_mode();
-            output_mode->set_horizontal_resolution(mode.size.width.as_uint32_t()); 
-            output_mode->set_vertical_resolution(mode.size.height.as_uint32_t());
-            output_mode->set_refresh_rate(mode.vrefresh_hz);
-        }
-        output->set_current_mode(config.current_mode_index);
+        mfd::pack_protobuf_display_output(output, config);
 
-        for (auto const& pf : supported_pfs)
-        {
-            output->add_pixel_format(static_cast<uint32_t>(pf));
-        }
-        //TODO: should set the actual display format from the display, once display lets us at that info
-        output->set_current_format(0);
     });
 
     resource_cache->save_resource(response, ipc_package);

=== modified file 'src/server/graphics/android/android_display.cpp'
--- src/server/graphics/android/android_display.cpp	2013-08-07 03:08:54 +0000
+++ src/server/graphics/android/android_display.cpp	2013-08-07 10:32:28 +0000
@@ -56,12 +56,13 @@
     AndroidDisplayConfiguration(geom::Size const& display_size)
         : configuration{mg::DisplayConfigurationOutputId{0},
                         mg::DisplayConfigurationCardId{0},
+                        {geom::PixelFormat::abgr_8888},
                         {mg::DisplayConfigurationMode{display_size,0.0f}},
                         geom::Size{0,0},
                         true,
                         true,
                         geom::Point{0,0},
-                        0}
+                        0, 0}
     {
     }
     void for_each_card(std::function<void(mg::DisplayConfigurationCard const&)>) const

=== modified file 'src/server/graphics/gbm/real_kms_display_configuration.cpp'
--- src/server/graphics/gbm/real_kms_display_configuration.cpp	2013-08-07 03:08:54 +0000
+++ src/server/graphics/gbm/real_kms_display_configuration.cpp	2013-08-07 10:32:28 +0000
@@ -170,6 +170,9 @@
     bool connected{connector.connection == DRM_MODE_CONNECTED};
     size_t current_mode_index{std::numeric_limits<size_t>::max()};
     std::vector<DisplayConfigurationMode> modes;
+    std::vector<geom::PixelFormat> formats {geom::PixelFormat::argb_8888,
+                                            geom::PixelFormat::xrgb_8888};
+
     drmModeModeInfo current_mode_info = drmModeModeInfo();
 
     /* Get information about the current mode */
@@ -201,8 +204,8 @@
 
     if (iter == outputs.end())
     {
-        outputs.push_back({id, card_id, modes, physical_size,
-                           connected, false, geom::Point(), current_mode_index});
+        outputs.push_back({id, card_id, formats, modes, physical_size,
+                           connected, false, geom::Point(), current_mode_index, 0u});
     }
     else
     {

=== modified file 'src/shared/protobuf/mir_protobuf.proto'
--- src/shared/protobuf/mir_protobuf.proto	2013-08-07 03:08:54 +0000
+++ src/shared/protobuf/mir_protobuf.proto	2013-08-07 10:32:28 +0000
@@ -144,12 +144,14 @@
   optional bytes raw = 1;  // MirEvent structure
 }
 
+message DisplayConfiguration {
+  repeated DisplayOutput display_output = 1;
+  optional string error = 127;
+}
+
 message EventSequence {
   repeated Event event = 1;
-}
-
-message DisplayConfiguration {
-  repeated DisplayOutput display_output = 1;
+  optional DisplayConfiguration display_configuration = 2;
   optional string error = 127;
 }
 

=== modified file 'tests/integration-tests/test_display_info.cpp'
--- tests/integration-tests/test_display_info.cpp	2013-08-07 03:08:54 +0000
+++ tests/integration-tests/test_display_info.cpp	2013-08-07 10:32:28 +0000
@@ -17,23 +17,30 @@
  */
 
 #include "mir/graphics/display.h"
-#include "mir/graphics/display_configuration.h"
 #include "mir/graphics/buffer.h"
 #include "mir/frontend/session_authorizer.h"
 #include "mir/graphics/graphic_buffer_allocator.h"
+#include "mir/frontend/protobuf_ipc_factory.h"
+#include "mir/frontend/resource_cache.h"
+#include "mir/frontend/session_mediator.h"
 
 #include "mir_test_framework/display_server_test_fixture.h"
+#include "mir_test_framework/cross_process_sync.h"
 #include "mir_test_doubles/stub_buffer.h"
 #include "mir_test_doubles/null_display.h"
+#include "mir_test_doubles/null_event_sink.h"
 #include "mir_test_doubles/null_display_config.h"
 #include "mir_test_doubles/null_display_changer.h"
 #include "mir_test_doubles/stub_display_buffer.h"
 #include "mir_test_doubles/null_platform.h"
 #include "mir_test/display_config_matchers.h"
+#include "mir_test_doubles/stub_display_configuration.h"
 #include "mir_test/fake_shared.h"
 
 #include "mir_toolkit/mir_client_library.h"
 
+#include <condition_variable>
+#include <thread>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -48,52 +55,6 @@
 
 namespace
 {
-class StubDisplayConfig : public mtd::NullDisplayConfig
-{
-public:
-    StubDisplayConfig()
-    {
-        /* construct a non-trivial dummy display config to send */
-        int mode_index = 0;
-        for (auto i = 0u; i < 3u; i++)
-        {
-            std::vector<mg::DisplayConfigurationMode> modes;
-            for (auto j = 0u; j <= i; j++)
-            {
-                geom::Size sz{mode_index*4, mode_index*3};
-                mg::DisplayConfigurationMode mode{sz, 10.0f * mode_index };
-                mode_index++;
-                modes.push_back(mode);
-            }
-
-            size_t mode_index = modes.size() - 1; 
-            geom::Size physical_size{};
-            geom::Point top_left{};
-            mg::DisplayConfigurationOutput output{
-                mg::DisplayConfigurationOutputId{static_cast<int>(i)},
-                mg::DisplayConfigurationCardId{static_cast<int>(i)},
-                modes,
-                physical_size,
-                ((i % 2) == 0),
-                ((i % 2) == 1),
-                top_left,
-                mode_index
-            };
-
-            outputs.push_back(output);
-        }
-    };
-
-    void for_each_output(std::function<void(mg::DisplayConfigurationOutput const&)> f) const override
-    {
-        for (auto& disp : outputs)
-        {
-            f(disp);
-        }
-    }
-
-    std::vector<mg::DisplayConfigurationOutput> outputs;
-};
 
 class StubDisplay : public mtd::NullDisplay
 {
@@ -117,10 +78,13 @@
     {
         return mt::fake_shared(stub_display_config);
     }
-    static StubDisplayConfig stub_display_config;
+
+    static mtd::StubDisplayConfig stub_display_config;
+private:
+    mtd::NullDisplayBuffer display_buffer;
 };
-StubDisplayConfig StubChanger::stub_display_config;
 
+mtd::StubDisplayConfig StubChanger::stub_display_config;
 
 char const* const mir_test_socket = mtf::test_socket_file().c_str();
 
@@ -209,8 +173,7 @@
             auto connection = mir_connect_sync(mir_test_socket, __PRETTY_FUNCTION__);
             auto configuration = mir_connection_create_display_config(connection);
 
-            EXPECT_THAT(configuration, mt::ClientTypeConfigMatches(StubChanger::stub_display_config.outputs,
-                                                                   StubGraphicBufferAllocator::pixel_formats));
+            EXPECT_THAT(configuration, mt::ClientTypeConfigMatches(StubChanger::stub_display_config.outputs));
 
             mir_display_config_destroy(configuration);
             mir_connection_release(connection);
@@ -327,3 +290,183 @@
 
     launch_client_process(client_config);
 }
+
+
+namespace
+{
+class EventSinkSkimmingIpcFactory : public mf::ProtobufIpcFactory
+{
+public:
+    EventSinkSkimmingIpcFactory(
+        std::shared_ptr<mf::Shell> const& shell,
+        std::shared_ptr<mf::SessionMediatorReport> const& sm_report,
+        std::shared_ptr<mf::MessageProcessorReport> const& mr_report,
+        std::shared_ptr<mg::Platform> const& graphics_platform,
+        std::shared_ptr<msh::DisplayChanger> const& graphics_changer,
+        std::shared_ptr<mg::GraphicBufferAllocator> const& buffer_allocator)
+        : shell(shell),
+          sm_report(sm_report),
+          mp_report(mr_report),
+          cache(std::make_shared<mf::ResourceCache>()),
+          graphics_platform(graphics_platform),
+          graphics_changer(graphics_changer),
+          buffer_allocator(buffer_allocator),
+          last_event_sink(std::make_shared<mtd::NullEventSink>())
+    {
+    }
+
+    std::shared_ptr<mf::EventSink> last_clients_event_sink()
+    {
+        return std::move(last_event_sink);
+    }
+
+private:
+    std::shared_ptr<mf::Shell> shell;
+    std::shared_ptr<mf::SessionMediatorReport> const sm_report;
+    std::shared_ptr<mf::MessageProcessorReport> const mp_report;
+    std::shared_ptr<mf::ResourceCache> const cache;
+    std::shared_ptr<mg::Platform> const graphics_platform;
+    std::shared_ptr<msh::DisplayChanger> const graphics_changer;
+    std::shared_ptr<mg::GraphicBufferAllocator> const buffer_allocator;
+    std::shared_ptr<mf::EventSink> last_event_sink;
+
+    virtual std::shared_ptr<mir::protobuf::DisplayServer> make_ipc_server(
+        std::shared_ptr<mf::EventSink> const& sink, bool)
+    {
+        last_event_sink = sink;
+        return std::make_shared<mf::SessionMediator>(
+            shell,
+            graphics_platform,
+            graphics_changer,
+            buffer_allocator,
+            sm_report,
+            sink,
+            resource_cache());
+    }
+
+    virtual std::shared_ptr<mf::ResourceCache> resource_cache()
+    {
+        return cache;
+    }
+
+    virtual std::shared_ptr<mf::MessageProcessorReport> report()
+    {
+        return mp_report;
+    }
+
+};
+
+}
+
+TEST_F(BespokeDisplayServerTestFixture, display_change_notification)
+{
+    mtf::CrossProcessSync client_ready_fence;
+    mtf::CrossProcessSync send_event_fence;
+
+    struct ServerConfig : TestingServerConfiguration
+    {
+        ServerConfig(mtf::CrossProcessSync const& send_event_fence)
+            : send_event_fence(send_event_fence)
+        {
+        }
+
+        std::shared_ptr<mg::Platform> the_graphics_platform() override
+        {
+            if (!platform)
+                platform = std::make_shared<StubPlatform>();
+            return platform;
+        }
+
+        std::shared_ptr<mir::frontend::ProtobufIpcFactory> the_ipc_factory(
+            std::shared_ptr<mf::Shell> const& shell,
+            std::shared_ptr<mg::GraphicBufferAllocator> const& allocator) override
+        {
+            if (!ipc_factory)
+            {
+                ipc_factory = std::make_shared<EventSinkSkimmingIpcFactory>(
+                                shell,
+                                the_session_mediator_report(),
+                                the_message_processor_report(),
+                                the_graphics_platform(),
+                                the_shell_display_changer(), allocator);
+            }
+            return ipc_factory;
+        }
+
+        void exec() override
+        {
+            change_thread = std::move(std::thread([this](){
+                send_event_fence.wait_for_signal_ready_for(std::chrono::milliseconds(1000));
+                auto notifier = ipc_factory->last_clients_event_sink();
+                notifier->handle_display_config_change(StubChanger::stub_display_config);
+            })); 
+        }
+
+        void on_exit() override
+        {
+            change_thread.join();
+        }
+
+        mtf::CrossProcessSync send_event_fence;
+        std::shared_ptr<EventSinkSkimmingIpcFactory> ipc_factory;
+        std::shared_ptr<StubPlatform> platform;
+        std::thread change_thread;
+    } server_config(send_event_fence);
+
+    struct Client : TestingClientConfiguration
+    {
+        Client(mtf::CrossProcessSync const& client_ready_fence)
+         : client_ready_fence(client_ready_fence)
+        {
+        }
+
+        static void change_handler(MirConnection* connection, void* context)
+        {
+            auto configuration = mir_connection_create_display_config(connection);
+
+            EXPECT_THAT(configuration, mt::ClientTypeConfigMatches(StubChanger::stub_display_config.outputs));
+            mir_display_config_destroy(configuration);
+
+            auto client_config = (Client*) context; 
+            client_config->notify_callback();
+        }
+
+        void notify_callback()
+        {
+            callback_called = true;
+            callback_wait.notify_all();
+        }
+        void exec()
+        {
+            std::unique_lock<std::mutex> lk(mut);
+            MirConnection* connection = mir_connect_sync(mir_test_socket, "notifier");
+            callback_called = false;
+        
+            mir_connection_set_display_config_change_callback(connection, &change_handler, this);
+
+            client_ready_fence.try_signal_ready_for(std::chrono::milliseconds(1000));
+
+            while(!callback_called)
+            {
+                callback_wait.wait(lk);
+            } 
+
+            mir_connection_release(connection);
+        }
+
+        mtf::CrossProcessSync client_ready_fence;
+
+        std::mutex mut;
+        std::condition_variable callback_wait;
+        bool callback_called;
+    } client_config(client_ready_fence);
+
+    launch_server_process(server_config);
+    launch_client_process(client_config);
+
+    run_in_test_process([&]
+    {
+        client_ready_fence.wait_for_signal_ready_for(std::chrono::milliseconds(1000));
+        send_event_fence.try_signal_ready_for(std::chrono::milliseconds(1000));
+    });
+}

=== modified file 'tests/mir_test_doubles/test_protobuf_client.cpp'
--- tests/mir_test_doubles/test_protobuf_client.cpp	2013-08-07 03:08:54 +0000
+++ tests/mir_test_doubles/test_protobuf_client.cpp	2013-08-07 10:32:28 +0000
@@ -20,6 +20,7 @@
 #include "mir_test_doubles/mock_rpc_report.h"
 
 #include "src/client/connection_surface_map.h"
+#include "src/client/display_configuration.h"
 #include "src/client/rpc/make_rpc_channel.h"
 #include "src/client/rpc/mir_basic_rpc_channel.h"
 
@@ -32,7 +33,10 @@
     int timeout_ms) :
     rpc_report(std::make_shared<testing::NiceMock<doubles::MockRpcReport>>()),
     channel(mir::client::rpc::make_rpc_channel(
-        socket_file,std::make_shared<mir::client::ConnectionSurfaceMap>(),rpc_report)),
+        socket_file,
+        std::make_shared<mir::client::ConnectionSurfaceMap>(),
+        std::make_shared<mir::client::DisplayConfiguration>(),
+        rpc_report)),
     display_server(channel.get(), ::google::protobuf::Service::STUB_DOESNT_OWN_CHANNEL),
     maxwait(timeout_ms),
     connect_done_called(false),

=== modified file 'tests/mir_test_framework/testing_server_options.cpp'
--- tests/mir_test_framework/testing_server_options.cpp	2013-08-07 03:08:54 +0000
+++ tests/mir_test_framework/testing_server_options.cpp	2013-08-07 10:32:28 +0000
@@ -79,7 +79,8 @@
     {
         mg::DisplayConfigurationOutput dummy_output_config{
             mg::DisplayConfigurationOutputId{0}, mg::DisplayConfigurationCardId{0},
-            modes, geom::Size{}, true, true, geom::Point{0,0}, 0};
+            std::vector<geom::PixelFormat>{geom::PixelFormat::abgr_8888},
+            modes, geom::Size{}, true, true, geom::Point{0,0}, 0, 0};
 
         f(dummy_output_config);
     }

=== modified file 'tests/unit-tests/client/CMakeLists.txt'
--- tests/unit-tests/client/CMakeLists.txt	2013-08-07 03:08:54 +0000
+++ tests/unit-tests/client/CMakeLists.txt	2013-08-07 10:32:28 +0000
@@ -6,6 +6,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_client_mir_surface.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_mir_connection.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_wait_handle.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_client_display_conf.cpp
 )
 
 if(MIR_PLATFORM STREQUAL "android")

=== added file 'tests/unit-tests/client/test_client_display_conf.cpp'
--- tests/unit-tests/client/test_client_display_conf.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/client/test_client_display_conf.cpp	2013-08-07 10:32:28 +0000
@@ -0,0 +1,78 @@
+/*
+ * 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: Kevin DuBois <[e-mail]>
+ */
+
+#include "src/client/display_configuration.h"
+
+#include "mir_test/display_config_matchers.h"
+#include "gtest/gtest.h"
+
+namespace mp = mir::protobuf;
+namespace mcl = mir::client;
+namespace mt = mir::test;
+
+namespace
+{
+void fill(mp::DisplayOutput* out)
+{
+    out->add_pixel_format(4);
+    out->set_current_format(45);
+    auto mode = out->add_mode();
+    mode->set_horizontal_resolution(4);
+    mode->set_vertical_resolution(558);
+    mode->set_refresh_rate(4.33f);
+    out->set_current_mode(0);
+    out->set_position_x(5);
+    out->set_position_y(6);
+    out->set_card_id(7);
+    out->set_output_id(8);
+    out->set_connected(1);
+    out->set_used(1);
+    out->set_physical_width_mm(11);
+    out->set_physical_height_mm(12);
+}
+}
+
+TEST(TestDisplayConfiguration, configuration_storage)
+{
+    mp::Connection connect_result;
+    fill(connect_result.add_display_output());
+    fill(connect_result.add_display_output());
+ 
+    mcl::DisplayConfiguration internal_config;
+
+    internal_config.update_configuration(connect_result);
+    MirDisplayConfiguration *info;
+    info = internal_config.copy_to_client();
+   
+    EXPECT_THAT(*info, mt::ClientTypeMatchesProtobuf(connect_result)); 
+    mcl::delete_config_storage(info);
+
+    int called_count = 0u;
+    internal_config.set_display_change_handler([&]() { called_count++; });
+
+    mp::DisplayConfiguration new_result; 
+    fill(new_result.add_display_output());
+
+    internal_config.update_configuration(new_result);
+
+    info = internal_config.copy_to_client();
+    EXPECT_THAT(*info, mt::ClientTypeMatchesProtobuf(new_result)); 
+    EXPECT_EQ(1u, called_count);
+
+    mcl::delete_config_storage(info);
+}

=== modified file 'tests/unit-tests/client/test_mir_connection.cpp'
--- tests/unit-tests/client/test_mir_connection.cpp	2013-08-07 03:08:54 +0000
+++ tests/unit-tests/client/test_mir_connection.cpp	2013-08-07 10:32:28 +0000
@@ -124,6 +124,7 @@
         std::shared_ptr<mcl::ClientPlatform> const& platform,
         std::shared_ptr<mcl::rpc::MirBasicRpcChannel> const& channel)
         : DefaultConnectionConfiguration(""),
+          disp_config(std::make_shared<mcl::DisplayConfiguration>()),
           platform{platform},
           channel{channel}
     {
@@ -139,7 +140,12 @@
         return std::make_shared<StubClientPlatformFactory>(platform);
     }
 
+    std::shared_ptr<mcl::DisplayConfiguration> the_display_configuration() override
+    {
+        return disp_config;
+    }
 private:
+    std::shared_ptr<mcl::DisplayConfiguration> disp_config;
     std::shared_ptr<mcl::ClientPlatform> const platform;
     std::shared_ptr<mcl::rpc::MirBasicRpcChannel> const channel;
 };

=== modified file 'tests/unit-tests/frontend/CMakeLists.txt'
--- tests/unit-tests/frontend/CMakeLists.txt	2013-08-07 03:08:54 +0000
+++ tests/unit-tests/frontend/CMakeLists.txt	2013-08-07 10:32:28 +0000
@@ -8,6 +8,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_resource_cache.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_session_mediator.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_socket_session.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_event_sender.cpp
 )
 
 # TODO this test is a mess - something better is needed.

=== modified file 'tests/unit-tests/frontend/stress_protobuf_communicator.cpp'
--- tests/unit-tests/frontend/stress_protobuf_communicator.cpp	2013-08-07 03:08:54 +0000
+++ tests/unit-tests/frontend/stress_protobuf_communicator.cpp	2013-08-07 10:32:28 +0000
@@ -26,6 +26,7 @@
 #include "mir_test/test_protobuf_server.h"
 
 #include "src/client/connection_surface_map.h"
+#include "src/client/display_configuration.h"
 #include "src/client/rpc/null_rpc_report.h"
 #include "src/client/rpc/make_rpc_channel.h"
 #include "src/client/rpc/mir_basic_rpc_channel.h"
@@ -172,7 +173,10 @@
     int timeout_ms) :
     rpc_report(std::make_shared<mir::client::rpc::NullRpcReport>()),
     channel(mir::client::rpc::make_rpc_channel(
-        socket_file, std::make_shared<mir::client::ConnectionSurfaceMap>(), rpc_report)),
+        socket_file,
+        std::make_shared<mir::client::ConnectionSurfaceMap>(),
+        std::make_shared<mir::client::DisplayConfiguration>(),
+        rpc_report)),
     display_server(channel.get(), ::google::protobuf::Service::STUB_DOESNT_OWN_CHANNEL),
     maxwait(timeout_ms),
     connect_done_called(false),

=== added file 'tests/unit-tests/frontend/test_event_sender.cpp'
--- tests/unit-tests/frontend/test_event_sender.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/frontend/test_event_sender.cpp	2013-08-07 10:32:28 +0000
@@ -0,0 +1,68 @@
+/*
+ * 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: Kevin DuBois <[e-mail]>
+ */
+
+#include "src/server/frontend/message_sender.h"
+#include "src/server/frontend/event_sender.h"
+#include "mir_test_doubles/stub_display_configuration.h"
+#include "mir_test/display_config_matchers.h"
+#include "mir_test/fake_shared.h"
+
+#include <vector>
+#include "mir_protobuf.pb.h"
+#include "mir_protobuf_wire.pb.h"
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+namespace mt=mir::test;
+namespace mtd=mir::test::doubles;
+namespace mfd=mir::frontend::detail;
+namespace geom=mir::geometry;
+
+namespace 
+{
+struct MockMsgSender : public mfd::MessageSender
+{
+    MOCK_METHOD1(send, void(std::string const&));
+    MOCK_METHOD1(send_fds, void(std::vector<int32_t> const&));
+};
+}
+
+TEST(TestEventSender, display_send)
+{
+    using namespace testing;
+
+    mtd::StubDisplayConfig config;
+    MockMsgSender mock_msg_sender;
+
+    auto msg_validator = [&config](std::string const& msg){
+        mir::protobuf::wire::Result wire;
+        wire.ParseFromString(msg);
+        std::string str = wire.events(0);
+        mir::protobuf::EventSequence seq;
+        seq.ParseFromString(str);
+        EXPECT_THAT(seq.display_configuration(), mt::ProtobufConfigMatches(config.outputs));
+    };
+
+    EXPECT_CALL(mock_msg_sender, send(_))
+        .Times(1)
+        .WillOnce(Invoke(msg_validator));
+
+    mfd::EventSender sender(mt::fake_shared(mock_msg_sender));
+
+    sender.handle_display_config_change(config);
+}

=== modified file 'tests/unit-tests/frontend/test_session_mediator.cpp'
--- tests/unit-tests/frontend/test_session_mediator.cpp	2013-08-07 03:08:54 +0000
+++ tests/unit-tests/frontend/test_session_mediator.cpp	2013-08-07 10:32:28 +0000
@@ -30,6 +30,7 @@
 #include "mir_test_doubles/mock_display.h"
 #include "mir_test_doubles/mock_display_changer.h"
 #include "mir_test_doubles/null_display.h"
+#include "mir_test_doubles/null_event_sink.h"
 #include "mir_test_doubles/null_display_changer.h"
 #include "mir_test_doubles/mock_display.h"
 #include "mir_test_doubles/mock_shell.h"
@@ -37,6 +38,7 @@
 #include "mir_test_doubles/mock_buffer.h"
 #include "mir_test_doubles/stub_session.h"
 #include "mir_test_doubles/stub_surface_builder.h"
+#include "mir_test_doubles/stub_display_configuration.h"
 #include "mir_test/display_config_matchers.h"
 #include "mir_test/fake_shared.h"
 #include "mir/frontend/event_sink.h"
@@ -160,12 +162,6 @@
                                               std::shared_ptr<mg::Buffer> const&));
 };
 
-class NullEventSink : public mir::frontend::EventSink
-{
-public:
-    void handle_event(MirEvent const& ) override {}
-};
-
 struct SessionMediatorTest : public ::testing::Test
 {
     SessionMediatorTest()
@@ -177,7 +173,7 @@
           resource_cache{std::make_shared<mf::ResourceCache>()},
           mediator{shell, graphics_platform, graphics_changer,
                    buffer_allocator, report, 
-                   std::make_shared<NullEventSink>(),
+                   std::make_shared<mtd::NullEventSink>(),
                    resource_cache},
           stubbed_session{std::make_shared<StubbedSession>()},
           null_callback{google::protobuf::NewPermanentCallback(google::protobuf::DoNothing)}
@@ -333,15 +329,8 @@
 {
     using namespace testing;
     geom::Size sz{1022, 2411};
-   
-    std::vector<mg::DisplayConfigurationMode> modes{{sz, 344.0f},{sz, 234.0f}};
-    mg::DisplayConfigurationOutput output{
-        mg::DisplayConfigurationOutputId{static_cast<int>(3)},
-        mg::DisplayConfigurationCardId{static_cast<int>(2)},
-        modes, sz, true, false,
-        geom::Point{4,12}, 0u};
 
-    StubConfig config(mt::fake_shared(output));
+    mtd::StubDisplayConfig config;
 
     auto mock_display = std::make_shared<mtd::MockDisplayChanger>();
     EXPECT_CALL(*mock_display, active_configuration())
@@ -350,7 +339,7 @@
     mf::SessionMediator mediator(
         shell, graphics_platform, mock_display,
         buffer_allocator, report, 
-        std::make_shared<NullEventSink>(),
+        std::make_shared<mtd::NullEventSink>(),
         resource_cache);
 
     mp::ConnectParameters connect_parameters;
@@ -359,19 +348,9 @@
     connection.clear_display_info();
     connection.clear_display_output();
 
-    std::vector<geom::PixelFormat> const pixel_formats{
-        geom::PixelFormat::bgr_888,
-        geom::PixelFormat::abgr_8888,
-        geom::PixelFormat::xbgr_8888
-    };
-
-    EXPECT_CALL(*buffer_allocator, supported_pixel_formats())
-        .WillOnce(Return(pixel_formats));
-
-    
     mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
 
-    EXPECT_THAT(connection, mt::ProtobufConfigMatches(config.outputs, pixel_formats));
+    EXPECT_THAT(connection, mt::ProtobufConfigMatches(config.outputs));
 }
 
 TEST_F(SessionMediatorTest, creating_surface_packs_response_with_input_fds)
@@ -511,7 +490,7 @@
  
     mf::SessionMediator session_mediator{
             shell, graphics_platform, mock_display_selector,
-            buffer_allocator, report, std::make_shared<NullEventSink>(), resource_cache};
+            buffer_allocator, report, std::make_shared<mtd::NullEventSink>(), resource_cache};
 
     session_mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
 

=== modified file 'tests/unit-tests/frontend/test_session_mediator_gbm.cpp'
--- tests/unit-tests/frontend/test_session_mediator_gbm.cpp	2013-08-07 03:08:54 +0000
+++ tests/unit-tests/frontend/test_session_mediator_gbm.cpp	2013-08-07 10:32:28 +0000
@@ -29,6 +29,8 @@
 #include <boost/exception/errinfo_errno.hpp>
 #include <boost/throw_exception.hpp>
 
+#include "mir_test_doubles/null_display.h"
+#include "mir_test_doubles/null_event_sink.h"
 #include "mir_test_doubles/null_display_changer.h"
 #include "mir_test_doubles/null_platform.h"
 #include "mir_test_doubles/mock_session.h"
@@ -73,12 +75,6 @@
     MOCK_METHOD1(drm_auth_magic, void(drm_magic_t));
 };
 
-class NullEventSink : public mir::frontend::EventSink
-{
-public:
-    void handle_event(MirEvent const& ) override {}
-};
-
 struct SessionMediatorGBMTest : public ::testing::Test
 {
     SessionMediatorGBMTest()
@@ -90,7 +86,7 @@
           resource_cache{std::make_shared<mf::ResourceCache>()},
           mediator{shell, mock_platform, display_changer,
                    buffer_allocator, report,
-                   std::make_shared<NullEventSink>(),
+                   std::make_shared<mtd::NullEventSink>(),
                    resource_cache},
           null_callback{google::protobuf::NewPermanentCallback(google::protobuf::DoNothing)}
     {

=== modified file 'tests/unit-tests/graphics/gbm/test_gbm_cursor.cpp'
--- tests/unit-tests/graphics/gbm/test_gbm_cursor.cpp	2013-08-07 03:08:54 +0000
+++ tests/unit-tests/graphics/gbm/test_gbm_cursor.cpp	2013-08-07 10:32:28 +0000
@@ -90,6 +90,7 @@
             {
                 mg::DisplayConfigurationOutputId{10},
                 card_id,
+                {},
                 {
                     {geom::Size{10, 20}, 59.9},
                     {geom::Size{200, 100}, 59.9},
@@ -98,12 +99,14 @@
                 true,
                 true,
                 geom::Point{0, 0},
-                1
+                1,
+                0
             });
         outputs.push_back(
             {
                 mg::DisplayConfigurationOutputId{11},
                 card_id,
+                {},
                 {
                     {geom::Size{200, 200}, 59.9},
                     {geom::Size{100, 200}, 59.9},
@@ -112,6 +115,7 @@
                 true,
                 true,
                 geom::Point{100, 50},
+                0,
                 0
             });
     }

=== modified file 'tests/unit-tests/graphics/gbm/test_gbm_display_configuration.cpp'
--- tests/unit-tests/graphics/gbm/test_gbm_display_configuration.cpp	2013-08-07 03:08:54 +0000
+++ tests/unit-tests/graphics/gbm/test_gbm_display_configuration.cpp	2013-08-07 10:32:28 +0000
@@ -174,31 +174,37 @@
         {
             mg::DisplayConfigurationOutputId{connector0_id},
             mg::DisplayConfigurationCardId{0},
+            {},
             conf_modes0,
             connector0_physical_size_mm,
             true,
             true,
             geom::Point(),
-            1
+            1,
+            0
         },
         {
             mg::DisplayConfigurationOutputId{connector1_id},
             mg::DisplayConfigurationCardId{0},
+            {},
             std::vector<mg::DisplayConfigurationMode>(),
             connector1_physical_size_mm,
             false,
             false,
             geom::Point(),
+            std::numeric_limits<size_t>::max(),
             std::numeric_limits<size_t>::max()
         },
         {
             mg::DisplayConfigurationOutputId{connector2_id},
             mg::DisplayConfigurationCardId{0},
+            {},
             std::vector<mg::DisplayConfigurationMode>(),
             connector2_physical_size_mm,
             false,
             false,
             geom::Point(),
+            std::numeric_limits<size_t>::max(),
             std::numeric_limits<size_t>::max()
         }
     };
@@ -323,22 +329,26 @@
         {
             mg::DisplayConfigurationOutputId(connector_ids[0]),
             mg::DisplayConfigurationCardId{0},
+            {},
             conf_modes0,
             connector_physical_sizes_mm_before[0],
             true,
             true,
             geom::Point(),
-            1
+            1,
+            0
         },
         {
             mg::DisplayConfigurationOutputId(connector_ids[1]),
             mg::DisplayConfigurationCardId{0},
+            {},
             std::vector<mg::DisplayConfigurationMode>(),
             connector_physical_sizes_mm_before[1],
             false,
             false,
             geom::Point(),
-            std::numeric_limits<size_t>::max()
+            std::numeric_limits<size_t>::max(),
+            std::numeric_limits<size_t>::max() 
         },
     };
 
@@ -347,22 +357,26 @@
         {
             mg::DisplayConfigurationOutputId(connector_ids[0]),
             mg::DisplayConfigurationCardId{0},
+            {},
             std::vector<mg::DisplayConfigurationMode>(),
             connector_physical_sizes_mm_after[0],
             false,
             true,
             geom::Point(),
+            std::numeric_limits<size_t>::max(),
             std::numeric_limits<size_t>::max()
         },
         {
             mg::DisplayConfigurationOutputId(connector_ids[1]),
             mg::DisplayConfigurationCardId{0},
+            {},
             conf_modes0,
             connector_physical_sizes_mm_after[1],
             true,
             false,
             geom::Point(),
-            1
+            1,
+            0
         },
     };
 

=== modified file 'tests/unit-tests/graphics/gbm/test_overlapping_output_grouping.cpp'
--- tests/unit-tests/graphics/gbm/test_overlapping_output_grouping.cpp	2013-08-07 03:08:54 +0000
+++ tests/unit-tests/graphics/gbm/test_overlapping_output_grouping.cpp	2013-08-07 10:32:28 +0000
@@ -69,12 +69,14 @@
             {
                 mg::DisplayConfigurationOutputId(i),
                 mg::DisplayConfigurationCardId{1},
+                {},
                 modes,
                 {100, 100},
                 connected,
                 used,
                 rect.top_left,
-                i - 1
+                i - 1,
+                0
             };
 
             f(output);

=== modified file 'tests/unit-tests/graphics/test_default_display_configuration_policy.cpp'
--- tests/unit-tests/graphics/test_default_display_configuration_policy.cpp	2013-08-07 03:08:54 +0000
+++ tests/unit-tests/graphics/test_default_display_configuration_policy.cpp	2013-08-07 10:32:28 +0000
@@ -40,6 +40,9 @@
                 mg::DisplayConfigurationOutputId{10},
                 card_id,
                 {
+                    {geom::PixelFormat::abgr_8888}
+                },
+                {
                     {geom::Size{123, 111}, 59.9},
                     {geom::Size{123, 111}, 59.9},
                     {geom::Size{123, 111}, 59.9}
@@ -48,7 +51,8 @@
                 true,
                 false,
                 geom::Point{geom::X{123}, geom::Y{343}},
-                1
+                1,
+                0
             });
         /* Connected without modes */
         outputs.push_back(
@@ -56,10 +60,12 @@
                 mg::DisplayConfigurationOutputId{11},
                 card_id,
                 {},
+                {},
                 geom::Size{566, 111},
                 true,
                 false,
                 geom::Point(),
+                std::numeric_limits<size_t>::max(),
                 std::numeric_limits<size_t>::max()
             });
         /* Connected with a single mode */
@@ -68,12 +74,16 @@
                 mg::DisplayConfigurationOutputId{12},
                 card_id,
                 {
+                    {geom::PixelFormat::abgr_8888}
+                },
+                {
                     {geom::Size{523, 555}, 60.0},
                 },
                 geom::Size{324, 642},
                 true,
                 false,
                 geom::Point(),
+                0,
                 0
             });
         /* Not connected */
@@ -81,12 +91,16 @@
             {
                 mg::DisplayConfigurationOutputId{13},
                 card_id,
+                {
+                    {geom::PixelFormat::abgr_8888}
+                },
                 {},
                 geom::Size{324, 642},
                 false,
                 false,
                 geom::Point(),
-                1
+                1,
+                0
             });
     }
 

=== modified file 'tests/unit-tests/graphics/test_display_configuration.cpp'
--- tests/unit-tests/graphics/test_display_configuration.cpp	2013-08-07 03:08:54 +0000
+++ tests/unit-tests/graphics/test_display_configuration.cpp	2013-08-07 10:32:28 +0000
@@ -31,6 +31,9 @@
     mg::DisplayConfigurationOutputId{3},
     mg::DisplayConfigurationCardId{2},
     {
+        {geom::PixelFormat::abgr_8888}
+    },
+    {
         {geom::Size{10, 20}, 60.0},
         {geom::Size{10, 20}, 59.0},
         {geom::Size{15, 20}, 59.0}
@@ -39,7 +42,8 @@
     true,
     true,
     geom::Point(),
-    2
+    2,
+    0
 };
 
 }