Merge lp:~robertcarr/mir/socket-messenger-reporting into lp:~vanvugt/mir/fix-1226139

[Robert Carr]

Report exceptions in socket messenger.

Report socket messenger write errors so we can keep track of this.

[lp:~robertcarr/mir/socket-messenger-reporting]

1074. By Robert Carr on 2013-09-23

Typo

[Alan Griffiths (alan-griffiths)]

[ try]
9 {
50 ba::write(*socket, ba::buffer(whole_message));
51 }
52 - catch (std::exception &)
53 + catch (std::exception &ex)
54 {
55 - // Don't care
56 + report->error(ex);
57 }

This is better written as:

    boost::system::error_code ec;
    ba::write(*socket, ba::buffer(whole_message), ec);

    if (!ec)
    {
        report->error(ec.message());
    }

And not throwing and catching exceptions.

review: Needs Fixing

[lp:~robertcarr/mir/socket-messenger-reporting]

1075. By Robert Carr on 2013-09-26

Merge trunk and update to new frontend interfaces

1076. By Robert Carr on 2013-09-26

Update tests

[Robert Carr (robertcarr)]

Fixed to use the error code, updating to trunk with the reorganization of some frontend interfaces (notably communicator_report->connector_report) made it necessary to introduce a new reporting interface. messenger_report

[lp:~robertcarr/mir/socket-messenger-reporting]

1077. By Robert Carr on 2013-09-26

Merge development branch

Unmerged revisions

1077. By Robert Carr on 2013-09-26

Merge development branch

1076. By Robert Carr on 2013-09-26

Update tests

1075. By Robert Carr on 2013-09-26

Merge trunk and update to new frontend interfaces

1074. By Robert Carr on 2013-09-23

Typo

1073. By Robert Carr on 2013-09-23

socket_messenger: Report exceptions

=== modified file '3rd_party/android-deps/android/input.h'
--- 3rd_party/android-deps/android/input.h	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-deps/android/input.h	2013-09-26 15:36:41 +0000
@@ -460,27 +460,6 @@
     AINPUT_KEYBOARD_TYPE_ALPHABETIC = 2
 };
 
-/*
- * Constants used to retrieve information about the range of motion for a particular
- * coordinate of a motion event.
- *
- * Refer to the documentation on android.view.InputDevice for more details about input sources
- * and their correct interpretation.
- *
- * DEPRECATION NOTICE: These constants are deprecated.  Use AMOTION_EVENT_AXIS_* constants instead.
- */
-enum {
-    AINPUT_MOTION_RANGE_X = AMOTION_EVENT_AXIS_X,
-    AINPUT_MOTION_RANGE_Y = AMOTION_EVENT_AXIS_Y,
-    AINPUT_MOTION_RANGE_PRESSURE = AMOTION_EVENT_AXIS_PRESSURE,
-    AINPUT_MOTION_RANGE_SIZE = AMOTION_EVENT_AXIS_SIZE,
-    AINPUT_MOTION_RANGE_TOUCH_MAJOR = AMOTION_EVENT_AXIS_TOUCH_MAJOR,
-    AINPUT_MOTION_RANGE_TOUCH_MINOR = AMOTION_EVENT_AXIS_TOUCH_MINOR,
-    AINPUT_MOTION_RANGE_TOOL_MAJOR = AMOTION_EVENT_AXIS_TOOL_MAJOR,
-    AINPUT_MOTION_RANGE_TOOL_MINOR = AMOTION_EVENT_AXIS_TOOL_MINOR,
-    AINPUT_MOTION_RANGE_ORIENTATION = AMOTION_EVENT_AXIS_ORIENTATION
-} __attribute__ ((deprecated));
-
 #ifdef __cplusplus
 }
 #endif

=== modified file '3rd_party/android-deps/std/PropertyMap.h'
--- 3rd_party/android-deps/std/PropertyMap.h	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-deps/std/PropertyMap.h	2013-09-26 15:36:41 +0000
@@ -62,10 +62,20 @@
     /* Clears the property map. */
     void clear() { options = boost::program_options::variables_map(); }
 
-//    /* Adds a property.
-//     * Replaces the property with the same key if it is already present.
-//     */
-//    void addProperty(const String8& key, const String8& value);
+    /* Adds a property.
+     * Replaces the property with the same key if it is already present.
+     */
+    void addProperty(const String8& key, const String8& value)
+    {
+        namespace po = boost::program_options;
+        options.insert(std::make_pair(key, po::variable_value(value, false)));
+    }
+
+    void addAll(const PropertyMap* other)
+    {
+        options.insert(other->options.begin(), other->options.end());
+    }
+
 //
 //    /* Returns true if the property map contains the specified key. */
 //    bool hasProperty(const String8& key) const;

=== modified file '3rd_party/android-deps/std/Vector.h'
--- 3rd_party/android-deps/std/Vector.h	2013-03-13 04:54:15 +0000
+++ 3rd_party/android-deps/std/Vector.h	2013-09-26 15:36:41 +0000
@@ -62,7 +62,7 @@
 
     /*! copy operator */
 //  const Vector<ValueType>& operator = (const Vector<ValueType>& rhs) const;
-    Vector<ValueType>& operator=(const Vector<ValueType>& rhs) = default;
+    Vector<ValueType>& operator=(const Vector<ValueType>& /* rhs */) = default;
 
 //  const Vector<ValueType>& operator = (const SortedVector<ValueType>& rhs) const;
 //  Vector<ValueType>& operator = (const SortedVector<ValueType>& rhs);

=== modified file '3rd_party/android-input/README'
--- 3rd_party/android-input/README	2012-11-06 18:05:11 +0000
+++ 3rd_party/android-input/README	2013-09-26 15:36:41 +0000
@@ -3,25 +3,6 @@
 
 All the needed base, helper and utility classes (e.g. String8) were also brought along.
 
-Subdirectories:
- * android_pristine - The original, unmodified, android files, as they were
-                      fetched from android's source tree. Here just as a reference
-                      to track the local modifications made. Useful when you want to
-                      update the project to the latest android source tree.
- * android - The android files, but with some modifications to work on this
-             project. They are the ones that actually get compiled.
-
-We strive to keep a minimal delta between android and android_pristine to make easier
-for us to get all updates made by them on the android project. That is, to avoid
-forking that code and therefore having to maintain it all ourselves. We just maintain
-the delta/modifications instead.
-
-Running
-=======
-
-Set the following environment variables to something or any path, otherwise applications
-seg fault: ANDROID_ROOT, ANDROID_DATA
-
 Debugging
 =========
 

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp	2013-03-13 04:54:15 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputReader.cpp	2013-09-26 15:36:41 +0000
@@ -2553,7 +2553,8 @@
 TouchInputMapper::TouchInputMapper(InputDevice* device) :
         InputMapper(device),
         mSource(0), mDeviceMode(DEVICE_MODE_DISABLED),
-        mSurfaceOrientation(-1), mSurfaceWidth(-1), mSurfaceHeight(-1) {
+        mSurfaceOrientation(-1), mSurfaceWidth(-1), mSurfaceHeight(-1),
+        mPointerUsage(POINTER_USAGE_NONE) {
 }
 
 TouchInputMapper::~TouchInputMapper() {

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputReader.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputReader.h	2013-05-03 16:38:07 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputReader.h	2013-09-26 15:36:41 +0000
@@ -602,8 +602,6 @@
     inline bool haveRelativeVWheel() const { return mHaveRelWheel; }
     inline bool haveRelativeHWheel() const { return mHaveRelHWheel; }
 
-    inline int32_t getRelativeX() const { return mRelX; }
-    inline int32_t getRelativeY() const { return mRelY; }
     inline int32_t getRelativeVWheel() const { return mRelWheel; }
     inline int32_t getRelativeHWheel() const { return mRelHWheel; }
 
@@ -611,8 +609,6 @@
     bool mHaveRelWheel;
     bool mHaveRelHWheel;
 
-    int32_t mRelX;
-    int32_t mRelY;
     int32_t mRelWheel;
     int32_t mRelHWheel;
 

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-08-28 03:41:48 +0000
+++ CMakeLists.txt	2013-09-26 15:36:41 +0000
@@ -28,7 +28,7 @@
 
 set(MIR_VERSION_MAJOR 0)
 set(MIR_VERSION_MINOR 0)
-set(MIR_VERSION_PATCH 10)
+set(MIR_VERSION_PATCH 12)
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 

=== modified file 'debian/changelog'
--- debian/changelog	2013-09-04 06:04:48 +0000
+++ debian/changelog	2013-09-26 15:36:41 +0000
@@ -1,3 +1,112 @@
+mir (0.0.12+13.10.20130926.1-0ubuntu1) saucy; urgency=low
+
+  [ kg ]
+  * bump version for ABI break (LP: #1229212)
+
+  [ Robert Ancell ]
+  * Bump version to 0.0.12
+
+  [ Alexandros Frantzis ]
+  * tests: Fix compiler warning about maybe-uninitialized struct member
+
+  [ Ubuntu daily release ]
+  * Automatic snapshot from revision 1084
+
+ -- Ubuntu daily release <[e-mail]>  Thu, 26 Sep 2013 08:39:29 +0000
+
+mir (0.0.11+13.10.20130924.1-0ubuntu1) saucy; urgency=low
+
+  [ kg ]
+  * bump version for ABI break (LP: #1229212)
+
+  [ Robert Ancell ]
+  * Allow an application to override the options being populated.
+  * Pass the program options to parse_options().
+  * Add missing include for std::cerr.
+  * Report when paused and resumed via configuration. (LP: #1192843)
+  * Add missing directory separator when searching for a config file to
+    parse.
+
+  [ Kevin Gunn ]
+  * change test timeouts and fix fence.
+
+  [ Alexandros Frantzis ]
+  * examples: Only check key information for key events This fixes a
+    memory error reported by valgrind for examples that use eglapp.
+  * shell: Apply the base configuration on a hardware change only if no
+    per-session configuration is active.
+  * graphics: consolidated fixed for nested code and examples on android
+    stack.
+
+  [ Eleni Maria Stea ]
+  * graphics: Pull in Eleni's changes to get the DRM fd to init GBM from
+    the host Mir instance.
+
+  [ Didier Roche ]
+  * remove (unused in the ppa as we have libmirserver3) hack to force
+    depending and building against the exact same version.
+
+  [ Robert Carr ]
+  * Add DPMS configuration API. (LP: #1193222)
+  * Deduplicate mtd::NullDisplayConfig and
+    mtd::NullDisplayConfiguration.
+  * Fix multiple internal client surfaces on android. (LP: #1228144)
+  * change test timeouts and fix fence.
+  * Add DPMS API and GBM/android impls.
+
+  [ Kevin DuBois ]
+  * platform, graphics: support nested (mir-on-mir) rendering on the
+    Android platform.
+
+  [ Michael Terry ]
+  * Change how Mir chooses socket locations to make it simpler for a
+    nested-Mir world, by using MIR_SOCKET as the host socket if no other
+    host socket is provided and passing MIR_SOCKET on to any children.
+    Also, change --nested-mode to --host-socket for clarity and add --
+    standalone to force standalone mode.
+
+  [ Daniel d'Andrada ]
+  * android-input housekeeping - Updated README - Removed some dead
+    code.
+
+  [ Daniel van Vugt ]
+  * Add DPMS configuration API. (LP: #1193222)
+  * Add a "flags" field to MirBufferPackage so that clients can find out
+    if the buffer they've been given is scanout-capable. This is
+    normally something a client should never need to know. However there
+    are two specialized cases where it's required to fix bugs in the
+    intel and radeon X drivers:   LP: #1218735, LP: #1218815 The intel
+    fix (already landed) contains a hack which will be updated after
+    this branch lands. (LP: #1218815, #1218735)
+  * GBM: Ensure that we don't create scanout buffers if bypass is
+    explicitly disabled from the environment. (LP: #1227133) . (LP:
+    #1227133)
+
+  [ Alan Griffiths ]
+  * graphics: Pull in Eleni's changes to get the DRM fd to init GBM from
+    the host Mir instance.
+  * input: Separate the code for dispatching input from that reading it.
+  * graphics: Hook up nested surfaces events to input.
+  * input: Connect nested input relay to input dispatch.
+  * graphics: Simplify NativeAndroidPlatform out of existence.
+  * tests: Fixes to get the tests "passing" on android/arm stack. (LP:
+    #1226284)
+  * graphics: consolidated fixed for nested code and examples on android
+    stack.
+  * examples: add command-line options to examples so the Mir server
+    connection can be selected.
+  * change test timeouts and fix fence.
+  * client: Add client side support for connecting via an existing FD.
+
+  [ Łukasz 'sil2100' Zemczak ]
+  * Revert revision 1054 ABI-change (the libmirclient3 one), which seems
+    to cause a lot of problems.
+
+  [ Ubuntu daily release ]
+  * Automatic snapshot from revision 1081
+
+ -- Ubuntu daily release <[e-mail]>  Tue, 24 Sep 2013 06:04:59 +0000
+
 mir (0.0.10+13.10.20130904-0ubuntu1) saucy; urgency=low
 
   [ Kevin DuBois ]

=== modified file 'debian/control'
--- debian/control	2013-09-18 13:59:53 +0000
+++ debian/control	2013-09-26 15:36:41 +0000
@@ -69,7 +69,7 @@
  .
  Contains the protocol's definition files.
 
-Package: libmirserver3
+Package: libmirserver4
 Section: libs
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
@@ -115,7 +115,7 @@
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmirserver3 (= ${binary:Version}),
+Depends: libmirserver4 (= ${binary:Version}),
          libmirprotobuf-dev (= ${binary:Version}),
          mircommon-dev (= ${binary:Version}),
          libglm-dev,
@@ -127,7 +127,7 @@
  .
  Contains header files required to build Mir servers.
 
-Package: libmirclient2
+Package: libmirclient3
 Section: libs
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
@@ -145,7 +145,7 @@
 Architecture: i386 amd64 armhf arm64
 Multi-Arch: same
 Pre-Depends: ${misc:Pre-Depends}
-Depends: libmirclient2 (= ${binary:Version}),
+Depends: libmirclient3 (= ${binary:Version}),
          libmirprotobuf-dev (= ${binary:Version}),
          mircommon-dev (= ${binary:Version}),
          ${misc:Depends},

=== renamed file 'debian/libmirclient2.install' => 'debian/libmirclient3.install'
--- debian/libmirclient2.install	2013-09-11 17:00:39 +0000
+++ debian/libmirclient3.install	2013-09-26 15:36:41 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmirclient.so.2
+usr/lib/*/libmirclient.so.3

=== renamed file 'debian/libmirserver3.install' => 'debian/libmirserver4.install'
--- debian/libmirserver3.install	2013-09-18 13:59:53 +0000
+++ debian/libmirserver4.install	2013-09-26 15:36:41 +0000
@@ -1,1 +1,1 @@
-usr/lib/*/libmirserver.so.3
+usr/lib/*/libmirserver.so.4

=== modified file 'debian/rules'
--- debian/rules	2013-08-28 03:41:48 +0000
+++ debian/rules	2013-09-26 15:36:41 +0000
@@ -38,5 +38,4 @@
 
 # TODO: we'll use a symbol file once mir is abi stable
 override_dh_makeshlibs:
-	dh_makeshlibs -p libmirserver1 -V 'libmirserver1 (= ${EXACT_PACKAGE_VERSION})'
-	dh_makeshlibs --remaining-packages -V
+	dh_makeshlibs -V

=== modified file 'doc/debug_for_xmir.md'
--- doc/debug_for_xmir.md	2013-09-11 17:00:39 +0000
+++ doc/debug_for_xmir.md	2013-09-26 15:36:41 +0000
@@ -78,7 +78,7 @@
 XMir component versions used and the use case steps. You may check the versions
 of key XMir components by the following
 
-    dpkg -s libmirclient1 | grep Version
+    dpkg -s libmirclient3 | grep Version
     dpkg -s libmirserver0 | grep Version
     dpkg -s lightdm | grep Version
     dpkg -s unity-system-compositor | grep Version

=== modified file 'examples/basic_server.cpp'
--- examples/basic_server.cpp	2013-08-29 03:48:16 +0000
+++ examples/basic_server.cpp	2013-09-26 15:36:41 +0000
@@ -16,18 +16,53 @@
  * Authored by: Alan Griffiths <[e-mail]>
  */
 
+#include "server_configuration.h"
+
+#include "mir/abnormal_exit.h"
+#include "mir/frontend/connector.h"
+#include "mir/options/option.h"
+#include "mir/report_exception.h"
 #include "mir/run_mir.h"
-#include "mir/report_exception.h"
-#include "server_configuration.h"
 
 #include <iostream>
 
+namespace
+{
+char const* const launch_child_opt = "launch-client";
+
+struct ServerConfiguration : mir::examples::ServerConfiguration
+{
+    ServerConfiguration(int argc, char const** argv) :
+        mir::examples::ServerConfiguration(argc, argv)
+    {
+        namespace po = boost::program_options;
+
+        add_options()
+            (launch_child_opt, po::value<std::string>(), "system() command to launch client");
+    }
+
+    void launch_client()
+    {
+        if (the_options()->is_set(launch_child_opt))
+        {
+            char buffer[128] = {0};
+            sprintf(buffer, "fd://%d", the_connector()->client_socket_fd());
+            setenv("MIR_SOCKET", buffer, 1);
+            auto ignore = system((the_options()->get(launch_child_opt, "") + "&").c_str());
+            (void)ignore;
+        }
+    }
+
+    using mir::examples::ServerConfiguration::the_options;
+};
+}
+
 int main(int argc, char const* argv[])
 try
 {
-    mir::examples::ServerConfiguration config(argc, argv);
+    ServerConfiguration config(argc, argv);
 
-    run_mir(config, [](mir::DisplayServer&) {/* empty init */});
+    run_mir(config, [&](mir::DisplayServer&){ config.launch_client(); });
     return 0;
 }
 catch (...)

=== modified file 'examples/demo-shell/demo_shell.cpp'
--- examples/demo-shell/demo_shell.cpp	2013-08-28 03:41:48 +0000
+++ examples/demo-shell/demo_shell.cpp	2013-09-26 15:36:41 +0000
@@ -98,6 +98,8 @@
             // and the SessionStore
             wm->set_focus_controller(config.the_focus_controller());
             wm->set_session_manager(config.the_session_manager());
+            wm->set_display(config.the_display());
+            wm->set_compositor(config.the_compositor());
         });
     return 0;
 }

=== modified file 'examples/demo-shell/window_manager.cpp'
--- examples/demo-shell/window_manager.cpp	2013-08-28 03:41:48 +0000
+++ examples/demo-shell/window_manager.cpp	2013-09-26 15:36:41 +0000
@@ -22,6 +22,9 @@
 #include "mir/shell/session_manager.h"
 #include "mir/shell/session.h"
 #include "mir/shell/surface.h"
+#include "mir/graphics/display.h"
+#include "mir/graphics/display_configuration.h"
+#include "mir/compositor/compositor.h"
 
 #include <linux/input.h>
 
@@ -30,6 +33,8 @@
 
 namespace me = mir::examples;
 namespace msh = mir::shell;
+namespace mg = mir::graphics;
+namespace mc = mir::compositor;
 
 namespace
 {
@@ -52,6 +57,16 @@
     session_manager = sm;
 }
 
+void me::WindowManager::set_display(std::shared_ptr<mg::Display> const& dpy)
+{
+    display = dpy;
+}
+
+void me::WindowManager::set_compositor(std::shared_ptr<mc::Compositor> const& cptor)
+{
+    compositor = cptor;
+}
+
 mir::geometry::Point average_pointer(MirMotionEvent const& motion)
 {
     using namespace mir;
@@ -73,15 +88,46 @@
 
 bool me::WindowManager::handle(MirEvent const& event)
 {
+    // TODO: Fix android configuration and remove static hack ~racarr
+    static bool display_off = false;
     assert(focus_controller);
+    assert(display);
+    assert(compositor);
 
     if (event.key.type == mir_event_type_key &&
-        event.key.action == mir_key_action_down &&
-        event.key.modifiers & mir_key_modifier_alt &&
-        event.key.scan_code == KEY_TAB)  // TODO: Use keycode once we support keymapping on the server side
+        event.key.action == mir_key_action_down)
     {
-        focus_controller->focus_next();
-        return true;
+        if (event.key.modifiers & mir_key_modifier_alt &&
+            event.key.scan_code == KEY_TAB)  // TODO: Use keycode once we support keymapping on the server side
+        {
+            focus_controller->focus_next();
+            return true;
+        }
+        if (event.key.modifiers & mir_key_modifier_alt && event.key.scan_code == KEY_P)
+        {
+            compositor->stop();
+            auto conf = display->configuration();
+            conf->for_each_output([&](mg::DisplayConfigurationOutput const& output) -> void
+            {
+                MirPowerMode power_mode;
+                if (!output.used) return;
+
+                if (display_off == true)
+                    power_mode = mir_power_mode_on;
+                else
+                    power_mode = mir_power_mode_off;
+
+                conf->configure_output(output.id, output.used,
+                                       output.top_left, 
+                                       output.current_mode_index,
+                                       power_mode);
+            });
+            display_off = !display_off;
+
+            display->configure(*conf.get());
+            compositor->start();
+            return true;
+        }
     }
     else if (event.type == mir_event_type_motion &&
              session_manager)

=== modified file 'examples/demo-shell/window_manager.h'
--- examples/demo-shell/window_manager.h	2013-08-28 03:41:48 +0000
+++ examples/demo-shell/window_manager.h	2013-09-26 15:36:41 +0000
@@ -31,6 +31,14 @@
 class FocusController;
 class SessionManager;
 }
+namespace graphics
+{
+class Display;
+}
+namespace compositor
+{
+class Compositor;
+}
 namespace examples
 {
 
@@ -42,6 +50,8 @@
 
     void set_focus_controller(std::shared_ptr<shell::FocusController> const& focus_controller);
     void set_session_manager(std::shared_ptr<shell::SessionManager> const& sm);
+    void set_display(std::shared_ptr<graphics::Display> const& display);
+    void set_compositor(std::shared_ptr<compositor::Compositor> const& compositor);
     
     bool handle(MirEvent const& event) override;
 
@@ -52,6 +62,9 @@
 private:
     std::shared_ptr<shell::FocusController> focus_controller;
     std::shared_ptr<shell::SessionManager> session_manager;
+    std::shared_ptr<graphics::Display> display;
+    std::shared_ptr<compositor::Compositor> compositor;
+
     geometry::Displacement relative_click;  // Click location in window space
     geometry::Point click;                  // Click location in screen space
     int max_fingers;  // Maximum number of fingers touched during gesture

=== modified file 'examples/demo_client_display_config.c'
--- examples/demo_client_display_config.c	2013-09-11 17:00:39 +0000
+++ examples/demo_client_display_config.c	2013-09-26 15:36:41 +0000
@@ -35,17 +35,46 @@
     configuration_mode_unknown,
     configuration_mode_clone,
     configuration_mode_horizontal,
-    configuration_mode_vertical
+    configuration_mode_vertical,
+    configuration_mode_single
 } ConfigurationMode;
 
 struct ClientContext
 {
     MirConnection *connection;
     ConfigurationMode mode;
+    int mode_data;
     volatile sig_atomic_t running;
     volatile sig_atomic_t reconfigure;
 };
 
+static void print_current_configuration(MirConnection *connection)
+{
+    MirDisplayConfiguration *conf = mir_connection_create_display_config(connection);
+
+    for (uint32_t i = 0; i < conf->num_outputs; i++)
+    {
+        MirDisplayOutput *output = &conf->outputs[i];
+        printf("Output id: %d connected: %d used: %d position_x: %d position_y: %d",
+               output->output_id, output->connected,
+               output->used, output->position_x, output->position_y);
+        if (output->current_mode < output->num_modes)
+        {
+            MirDisplayMode *mode = &output->modes[output->current_mode];
+            printf(" mode: %dx%d@%.2f\n",
+                   mode->horizontal_resolution,
+                   mode->vertical_resolution,
+                   mode->refresh_rate);
+        }
+        else
+        {
+            printf("\n");
+        }
+    }
+
+    mir_display_config_destroy(conf);
+}
+
 static int apply_configuration(MirConnection *connection, MirDisplayConfiguration *conf)
 {
     MirWaitHandle* handle = mir_connection_apply_display_config(connection, conf);
@@ -120,7 +149,36 @@
     }
 }
 
-static void configure_display(struct ClientContext *context, ConfigurationMode mode)
+static void configure_display_single(struct MirDisplayConfiguration *conf, int output_num)
+{
+    uint32_t num_connected = 0;
+    uint32_t output_to_enable = output_num;
+
+    for (uint32_t i = 0; i < conf->num_outputs; i++)
+    {
+        MirDisplayOutput *output = &conf->outputs[i];
+        if (output->connected && output->num_modes > 0)
+            ++num_connected;
+    }
+
+    if (output_to_enable > num_connected)
+        output_to_enable = num_connected;
+
+    for (uint32_t i = 0; i < conf->num_outputs; i++)
+    {
+        MirDisplayOutput *output = &conf->outputs[i];
+        if (output->connected && output->num_modes > 0)
+        {
+            output->used = (--output_to_enable == 0);
+            output->current_mode = 0;
+            output->position_x = 0;
+            output->position_y = 0;
+        }
+    }
+}
+
+static void configure_display(struct ClientContext *context, ConfigurationMode mode,
+                              int mode_data)
 {
     MirDisplayConfiguration *conf =
         mir_connection_create_display_config(context->connection);
@@ -140,9 +198,18 @@
         configure_display_horizontal(conf);
         printf("Applying horizontal configuration: ");
     }
+    else if (mode == configuration_mode_single)
+    {
+        configure_display_single(conf, mode_data);
+        printf("Applying single configuration for output %d: ", mode_data);
+    }
 
     if (apply_configuration(context->connection, conf))
+    {
         context->mode = mode;
+        context->mode_data = mode_data;
+    }
+
     mir_display_config_destroy(conf);
 }
 
@@ -152,17 +219,7 @@
 
     printf("=== Display configuration changed === \n");
 
-    MirDisplayConfiguration *conf = mir_connection_create_display_config(connection);
-
-    for (uint32_t i = 0; i < conf->num_outputs; i++)
-    {
-        MirDisplayOutput *output = &conf->outputs[i];
-        printf("Output id: %d connected: %d used: %d position_x: %d position_y: %d\n",
-               output->output_id, output->connected,
-               output->used, output->position_x, output->position_y);
-    }
-
-    mir_display_config_destroy(conf);
+    print_current_configuration(connection);
 
     struct ClientContext *ctx = (struct ClientContext*) context;
     ctx->reconfigure = 1;
@@ -183,15 +240,25 @@
         }
         else if (event->key.key_code == XKB_KEY_c)
         {
-            configure_display(ctx, configuration_mode_clone);
+            configure_display(ctx, configuration_mode_clone, 0);
         }
         else if (event->key.key_code == XKB_KEY_h)
         {
-            configure_display(ctx, configuration_mode_horizontal);
+            configure_display(ctx, configuration_mode_horizontal, 0);
         }
         else if (event->key.key_code == XKB_KEY_v)
         {
-            configure_display(ctx, configuration_mode_vertical);
+            configure_display(ctx, configuration_mode_vertical, 0);
+        }
+        else if (event->key.key_code >= XKB_KEY_1 &&
+                 event->key.key_code <= XKB_KEY_9)
+        {
+            configure_display(ctx, configuration_mode_single,
+                              event->key.key_code - XKB_KEY_0);
+        }
+        else if (event->key.key_code == XKB_KEY_p)
+        {
+            print_current_configuration(ctx->connection);
         }
     }
 }
@@ -203,10 +270,13 @@
     if (!mir_eglapp_init(argc, argv, &width, &height))
     {
         printf("A demo client that allows changing the display configuration. While the client\n"
-               "has the focus, use the following keys to change the display configuration:\n"
+               "has the focus, use the following keys to change and get information about the\n"
+               "display configuration:\n"
                " c: clone outputs\n"
                " h: arrange outputs horizontally in the virtual space\n"
-               " v: arrange outputs vertically in the virtual space\n");
+               " v: arrange outputs vertically in the virtual space\n"
+               " 1-9: enable only the Nth connected output (in the order returned by the hardware)\n"
+               " p: print current display configuration\n");
 
         return 1;
     }
@@ -214,7 +284,7 @@
     MirConnection *connection = mir_eglapp_native_connection();
     MirSurface *surface = mir_eglapp_native_surface();
 
-    struct ClientContext ctx = {connection, configuration_mode_unknown, 1, 0};
+    struct ClientContext ctx = {connection, configuration_mode_unknown, 0, 1, 0};
     mir_connection_set_display_config_change_callback(
         connection, display_change_callback, &ctx);
 
@@ -236,7 +306,7 @@
 
         if (ctx.reconfigure)
         {
-            configure_display(&ctx, ctx.mode);
+            configure_display(&ctx, ctx.mode, ctx.mode_data);
             ctx.reconfigure = 0;
         }
     }

=== modified file 'examples/render_surfaces.cpp'
--- examples/render_surfaces.cpp	2013-09-16 18:27:02 +0000
+++ examples/render_surfaces.cpp	2013-09-26 15:36:41 +0000
@@ -19,7 +19,7 @@
 #include "mir/compositor/default_display_buffer_compositor_factory.h"
 #include "mir/compositor/display_buffer_compositor.h"
 #include "mir/graphics/graphic_buffer_allocator.h"
-#include "mir/frontend/communicator.h"
+#include "mir/frontend/connector.h"
 #include "mir/shell/surface_creation_parameters.h"
 #include "mir/geometry/size.h"
 #include "mir/geometry/rectangles.h"
@@ -266,15 +266,16 @@
 
     ///\internal [RenderSurfacesServerConfiguration_stubs_tag]
     // Stub out server connectivity.
-    std::shared_ptr<mf::Communicator> the_communicator() override
+    std::shared_ptr<mf::Connector> the_connector() override
     {
-        struct NullCommunicator : public mf::Communicator
+        struct NullConnector : public mf::Connector
         {
             void start() {}
             void stop() {}
+            int client_socket_fd() const override { return 0; }
         };
 
-        return std::make_shared<NullCommunicator>();
+        return std::make_shared<NullConnector>();
     }
     ///\internal [RenderSurfacesServerConfiguration_stubs_tag]
 

=== modified file 'examples/server_configuration.cpp'
--- examples/server_configuration.cpp	2013-09-11 17:00:39 +0000
+++ examples/server_configuration.cpp	2013-09-26 15:36:41 +0000
@@ -52,13 +52,13 @@
                 if (conf_output.connected && conf_output.modes.size() > 0)
                 {
                     conf.configure_output(conf_output.id, true, geom::Point{max_x, 0},
-                                          preferred_mode_index);
+                                          preferred_mode_index, mir_power_mode_on);
                     max_x += conf_output.modes[preferred_mode_index].size.width.as_int();
                 }
                 else
                 {
                     conf.configure_output(conf_output.id, false, conf_output.top_left,
-                                          conf_output.current_mode_index);
+                                          conf_output.current_mode_index, mir_power_mode_on);
                 }
             });
     }
@@ -78,13 +78,13 @@
                 if (!done && conf_output.connected && conf_output.modes.size() > 0)
                 {
                     conf.configure_output(conf_output.id, true, geom::Point{0, 0},
-                                          preferred_mode_index);
+                                          preferred_mode_index, mir_power_mode_on);
                     done = true;
                 }
                 else
                 {
                     conf.configure_output(conf_output.id, false, conf_output.top_left,
-                                          conf_output.current_mode_index);
+                                          conf_output.current_mode_index, mir_power_mode_on);
                 }
             });
     }

=== modified file 'include/platform/mir/graphics/display_buffer.h'
--- include/platform/mir/graphics/display_buffer.h	2013-08-28 03:41:48 +0000
+++ include/platform/mir/graphics/display_buffer.h	2013-09-26 15:36:41 +0000
@@ -20,6 +20,7 @@
 #define MIR_GRAPHICS_DISPLAY_BUFFER_H_
 
 #include <mir/geometry/rectangle.h>
+
 #include <memory>
 
 namespace mir

=== modified file 'include/platform/mir/graphics/display_configuration.h'
--- include/platform/mir/graphics/display_configuration.h	2013-09-11 17:00:39 +0000
+++ include/platform/mir/graphics/display_configuration.h	2013-09-26 15:36:41 +0000
@@ -23,6 +23,7 @@
 #include "mir/geometry/size.h"
 #include "mir/geometry/point.h"
 #include "mir/geometry/pixel_format.h"
+#include "mir_toolkit/common.h"
 
 #include <functional>
 #include <vector>
@@ -105,6 +106,8 @@
     size_t current_mode_index;
     /** The index in the 'pixel_format' vector of the current output pixel format. */
     size_t current_format_index;
+    /** Current power mode **/
+    MirPowerMode power_mode;
 };
 
 std::ostream& operator<<(std::ostream& out, DisplayConfigurationCard const& val);
@@ -134,7 +137,7 @@
 
     /** Configures an output. */
     virtual void configure_output(DisplayConfigurationOutputId id, bool used,
-                                  geometry::Point top_left, size_t mode_index) = 0;
+                                  geometry::Point top_left, size_t mode_index, MirPowerMode power_mode) = 0;
 
 protected:
     DisplayConfiguration() = default;

=== added file 'include/server/mir/default_pause_resume_listener.h'
--- include/server/mir/default_pause_resume_listener.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/default_pause_resume_listener.h	2013-09-26 15:36:41 +0000
@@ -0,0 +1,40 @@
+/*
+ * 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: Robert Ancell <[e-mail]>
+ */
+
+#ifndef MIR_DEFAULT_PAUSE_RESUME_LISTENER_H_
+#define MIR_DEFAULT_PAUSE_RESUME_LISTENER_H_
+
+#include "mir/pause_resume_listener.h"
+
+namespace mir
+{
+class DefaultPauseResumeListener : public virtual PauseResumeListener
+{
+public:
+    virtual void paused()
+    {
+    }
+
+    virtual void resumed()
+    {
+    }
+};
+  
+}
+
+#endif /* MIR_DEFAULT_PAUSE_RESUME_LISTENER_H_ */

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2013-09-18 21:19:22 +0000
+++ include/server/mir/default_server_configuration.h	2013-09-26 15:36:41 +0000
@@ -41,10 +41,12 @@
 namespace frontend
 {
 class Shell;
-class Communicator;
+class Connector;
 class ProtobufIpcFactory;
+class SessionCreator;
 class SessionMediatorReport;
 class MessageProcessorReport;
+class MessengerReport;
 class SessionAuthorizer;
 class EventSink;
 class DisplayChanger;
@@ -118,11 +120,12 @@
     /** @name DisplayServer dependencies
      * dependencies of DisplayServer on the rest of the Mir
      *  @{ */
-    virtual std::shared_ptr<frontend::Communicator> the_communicator();
+    virtual std::shared_ptr<frontend::Connector>    the_connector();
     virtual std::shared_ptr<graphics::Display>      the_display();
     virtual std::shared_ptr<compositor::Compositor> the_compositor();
     virtual std::shared_ptr<input::InputManager>    the_input_manager();
     virtual std::shared_ptr<MainLoop>               the_main_loop();
+    virtual std::shared_ptr<PauseResumeListener>    the_pause_resume_listener();
     virtual std::shared_ptr<DisplayChanger>         the_display_changer();
     virtual std::shared_ptr<graphics::Platform>     the_graphics_platform();
     virtual std::shared_ptr<input::InputConfiguration> the_input_configuration();
@@ -163,10 +166,16 @@
      *  @{ */
     virtual std::shared_ptr<frontend::SessionMediatorReport>  the_session_mediator_report();
     virtual std::shared_ptr<frontend::MessageProcessorReport> the_message_processor_report();
+    virtual std::shared_ptr<frontend::MessengerReport>        the_messenger_report();
     virtual std::shared_ptr<frontend::SessionAuthorizer>      the_session_authorizer();
     virtual std::shared_ptr<frontend::Shell>                  the_frontend_shell();
     virtual std::shared_ptr<frontend::EventSink>              the_global_event_sink();
     virtual std::shared_ptr<frontend::DisplayChanger>         the_frontend_display_changer();
+    /** @name frontend configuration - internal dependencies
+     * internal dependencies of frontend
+     *  @{ */
+    virtual std::shared_ptr<frontend::SessionCreator>         the_session_creator();
+    /** @} */
     /** @} */
 
     virtual std::shared_ptr<shell::FocusController> the_focus_controller();
@@ -242,7 +251,7 @@
     virtual std::shared_ptr<shell::MediatingDisplayChanger> the_mediating_display_changer();
     virtual std::shared_ptr<shell::BroadcastingSessionEventSink> the_broadcasting_session_event_sink();
 
-    CachedPtr<frontend::Communicator> communicator;
+    CachedPtr<frontend::Connector>   connector;
     CachedPtr<shell::SessionManager> session_manager;
 
 
@@ -263,8 +272,10 @@
     CachedPtr<frontend::ProtobufIpcFactory>  ipc_factory;
     CachedPtr<frontend::SessionMediatorReport> session_mediator_report;
     CachedPtr<frontend::MessageProcessorReport> message_processor_report;
+    CachedPtr<frontend::MessengerReport> messenger_report;
     CachedPtr<frontend::SessionAuthorizer> session_authorizer;
     CachedPtr<frontend::EventSink> global_event_sink;
+    CachedPtr<frontend::SessionCreator>    session_creator;
     CachedPtr<compositor::RendererFactory> renderer_factory;
     CachedPtr<compositor::BufferStreamFactory> buffer_stream_factory;
     CachedPtr<surfaces::SurfaceStack> surface_stack;
@@ -286,6 +297,7 @@
     CachedPtr<surfaces::SurfaceController> surface_controller;
     CachedPtr<time::TimeSource> time_source;
     CachedPtr<MainLoop> main_loop;
+    CachedPtr<PauseResumeListener> pause_resume_listener;
     CachedPtr<graphics::DisplayConfigurationPolicy> display_configuration_policy;
     CachedPtr<graphics::nested::HostConnection> host_connection;
     CachedPtr<input::NestedInputRelay> nested_input_relay;

=== renamed file 'include/server/mir/frontend/communicator.h' => 'include/server/mir/frontend/connector.h'
--- include/server/mir/frontend/communicator.h	2013-04-25 09:48:54 +0000
+++ include/server/mir/frontend/connector.h	2013-09-26 15:36:41 +0000
@@ -16,29 +16,29 @@
  * Authored by: Thomas Voss <[e-mail]>
  */
 
-#ifndef MIR_FRONTEND_COMMUNICATOR_H_
-#define MIR_FRONTEND_COMMUNICATOR_H_
+#ifndef MIR_FRONTEND_CONNECTOR_H_
+#define MIR_FRONTEND_CONNECTOR_H_
 
 namespace mir
 {
 namespace frontend
 {
-
-class Communicator
+/// Handle client process connections
+class Connector
 {
 public:
-    virtual ~Communicator() {}
-
     virtual void start() = 0;
     virtual void stop() = 0;
 
+    virtual int client_socket_fd() const = 0;
+
 protected:
-    Communicator() = default;
-    Communicator(const Communicator&) = delete;
-    Communicator& operator=(const Communicator&) = delete;
+    Connector() = default;
+    virtual ~Connector() = default;
+    Connector(const Connector&) = delete;
+    Connector& operator=(const Connector&) = delete;
 };
-
-}
-}
-
-#endif // MIR_FRONTEND_COMMUNICATOR_H_
+}
+}
+
+#endif // MIR_FRONTEND_CONNECTOR_H_

=== renamed file 'include/server/mir/frontend/communicator_report.h' => 'include/server/mir/frontend/connector_report.h'
--- include/server/mir/frontend/communicator_report.h	2013-06-19 16:14:40 +0000
+++ include/server/mir/frontend/connector_report.h	2013-09-26 15:36:41 +0000
@@ -16,8 +16,8 @@
  * Authored by: Alan Griffiths <[e-mail]
  */
 
-#ifndef MIR_FRONTEND_COMMUNICATOR_REPORT_H_
-#define MIR_FRONTEND_COMMUNICATOR_REPORT_H_
+#ifndef MIR_FRONTEND_CONNECTOR_REPORT_H_
+#define MIR_FRONTEND_CONNECTOR_REPORT_H_
 
 #include <stdexcept>
 
@@ -26,26 +26,25 @@
 namespace frontend
 {
 
-class CommunicatorReport
+class ConnectorReport
 {
 public:
 
     virtual void error(std::exception const& error) = 0;
 
 protected:
-    virtual ~CommunicatorReport() = default;
-    CommunicatorReport() = default;
-    CommunicatorReport(const CommunicatorReport&) = delete;
-    CommunicatorReport& operator=(const CommunicatorReport&) = delete;
+    virtual ~ConnectorReport() = default;
+    ConnectorReport() = default;
+    ConnectorReport(const ConnectorReport&) = delete;
+    ConnectorReport& operator=(const ConnectorReport&) = delete;
 };
 
-class NullCommunicatorReport : public CommunicatorReport
+class NullConnectorReport : public ConnectorReport
 {
 public:
-
     void error(std::exception const& error);
 };
 }
 }
 
-#endif // MIR_FRONTEND_COMMUNICATOR_REPORT_H_
+#endif // MIR_FRONTEND_CONNECTOR_REPORT_H_

=== modified file 'include/server/mir/frontend/display_changer.h'
--- include/server/mir/frontend/display_changer.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/frontend/display_changer.h	2013-09-26 15:36:41 +0000
@@ -38,6 +38,7 @@
 
     virtual std::shared_ptr<graphics::DisplayConfiguration> active_configuration() = 0;
     virtual void configure(std::shared_ptr<Session> const&, std::shared_ptr<graphics::DisplayConfiguration> const&) = 0;
+    virtual void ensure_display_powered(std::shared_ptr<Session> const& session) = 0;
 
 protected:
     DisplayChanger() = default;

=== added file 'include/server/mir/frontend/messenger_report.h'
--- include/server/mir/frontend/messenger_report.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/frontend/messenger_report.h	2013-09-26 15:36:41 +0000
@@ -0,0 +1,49 @@
+/*
+ * 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: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_FRONTEND_MESSENGER_REPORT_H_
+#define MIR_FRONTEND_MESSENGER_REPORT_H_
+
+#include <string>
+
+namespace mir
+{
+namespace frontend
+{
+
+class MessengerReport
+{
+public:
+    virtual void error(std::string const& error_message) = 0;
+
+protected:
+    virtual ~MessengerReport() = default;
+    MessengerReport() = default;
+    MessengerReport(const MessengerReport&) = delete;
+    MessengerReport& operator=(const MessengerReport&) = delete;
+};
+
+class NullMessengerReport : public MessengerReport
+{
+public:
+    void error(std::string const& error_message);
+};
+}
+}
+
+#endif // MIR_FRONTEND_MESSENGER_REPORT_H_

=== modified file 'include/server/mir/frontend/protobuf_ipc_factory.h'
--- include/server/mir/frontend/protobuf_ipc_factory.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/frontend/protobuf_ipc_factory.h	2013-09-26 15:36:41 +0000
@@ -32,6 +32,7 @@
 class EventSink;
 class ResourceCache;
 class MessageProcessorReport;
+class MessengerReport;
 
 class ProtobufIpcFactory
 {
@@ -39,7 +40,8 @@
     virtual std::shared_ptr<protobuf::DisplayServer> make_ipc_server(
         std::shared_ptr<EventSink> const& sink, bool authorized_to_resize_display) = 0;
     virtual std::shared_ptr<ResourceCache> resource_cache() = 0;
-    virtual std::shared_ptr<MessageProcessorReport> report() = 0;
+    virtual std::shared_ptr<MessageProcessorReport> message_processor_report() = 0;
+    virtual std::shared_ptr<MessengerReport> messenger_report() = 0;
 
 protected:
     ProtobufIpcFactory() {}

=== added file 'include/server/mir/frontend/session_creator.h'
--- include/server/mir/frontend/session_creator.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/frontend/session_creator.h	2013-09-26 15:36:41 +0000
@@ -0,0 +1,44 @@
+/*
+ * 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_FRONTEND_SESSION_CREATOR_H_
+#define MIR_FRONTEND_SESSION_CREATOR_H_
+
+#include <boost/asio.hpp>
+
+#include <memory>
+
+namespace mir
+{
+namespace frontend
+{
+class SessionCreator
+{
+public:
+    virtual void create_session_for(std::shared_ptr<boost::asio::local::stream_protocol::socket> const& socket) = 0;
+
+protected:
+    SessionCreator() = default;
+    virtual ~SessionCreator() noexcept = default;
+    SessionCreator(SessionCreator const&) = delete;
+    SessionCreator& operator=(SessionCreator const&) = delete;
+};
+}
+}
+
+#endif /* MIR_FRONTEND_SESSION_CREATOR_H_ */

=== modified file 'include/server/mir/frontend/session_mediator_report.h'
--- include/server/mir/frontend/session_mediator_report.h	2013-06-12 10:23:43 +0000
+++ include/server/mir/frontend/session_mediator_report.h	2013-09-26 15:36:41 +0000
@@ -46,6 +46,8 @@
 
     virtual void session_configure_surface_called(std::string const& app_name) = 0;
 
+    virtual void session_configure_display_called(std::string const& app_name) = 0;
+
     virtual void session_error(
         std::string const& app_name,
         char const* method,
@@ -69,6 +71,8 @@
 
     virtual void session_configure_surface_called(std::string const& app_name);
 
+    virtual void session_configure_display_called(std::string const& app_name);
+
     virtual void session_error(
         std::string const& app_name,
         char const* method,

=== added file 'include/server/mir/logging/messenger_report.h'
--- include/server/mir/logging/messenger_report.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/logging/messenger_report.h	2013-09-26 15:36:41 +0000
@@ -0,0 +1,49 @@
+/*
+ * 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_LOGGING_MESSENGER_REPORT_H_
+#define MIR_LOGGING_MESSENGER_REPORT_H_
+
+#include "mir/frontend/messenger_report.h"
+
+#include <memory>
+
+namespace mir
+{
+namespace logging
+{
+class Logger;
+
+class MessengerReport : public frontend::MessengerReport
+{
+public:
+    MessengerReport(std::shared_ptr<Logger> const& logger);
+    virtual ~MessengerReport() noexcept(true) = default;
+    
+    void error(std::string const& error_message);
+    
+private:
+    char const* component();
+    std::shared_ptr<Logger> const logger;
+};
+
+}
+}
+
+
+#endif /* MIR_LOGGING_MESSENGER_REPORT_H_ */

=== modified file 'include/server/mir/logging/session_mediator_report.h'
--- include/server/mir/logging/session_mediator_report.h	2013-05-30 03:50:54 +0000
+++ include/server/mir/logging/session_mediator_report.h	2013-09-26 15:36:41 +0000
@@ -49,6 +49,8 @@
 
     virtual void session_configure_surface_called(std::string const& app_name);
 
+    virtual void session_configure_display_called(std::string const& app_name);
+
     virtual void session_error(
         std::string const& app_name,
         char const* method,

=== added file 'include/server/mir/pause_resume_listener.h'
--- include/server/mir/pause_resume_listener.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/pause_resume_listener.h	2013-09-26 15:36:41 +0000
@@ -0,0 +1,40 @@
+/*
+ * 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: Robert Ancell <[e-mail]>
+ */
+
+#ifndef MIR_PAUSE_RESUME_LISTENER_H_
+#define MIR_PAUSE_RESUME_LISTENER_H_
+
+namespace mir
+{
+
+class PauseResumeListener
+{
+public:
+    virtual void paused() = 0;
+    virtual void resumed() = 0;
+
+protected:
+    PauseResumeListener() = default;
+    virtual ~PauseResumeListener() = default;
+    PauseResumeListener(PauseResumeListener const&) = delete;
+    PauseResumeListener& operator=(PauseResumeListener const&) = delete;
+};
+
+}
+
+#endif /* MIR_PAUSE_RESUME_LISTENER_H_ */

=== modified file 'include/server/mir/server_configuration.h'
--- include/server/mir/server_configuration.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/server_configuration.h	2013-09-26 15:36:41 +0000
@@ -28,7 +28,7 @@
 }
 namespace frontend
 {
-class Communicator;
+class Connector;
 class Shell;
 }
 namespace shell
@@ -49,6 +49,7 @@
 }
 
 class MainLoop;
+class PauseResumeListener;
 class DisplayChanger;
 
 class ServerConfiguration
@@ -56,11 +57,12 @@
 public:
     // TODO most of these interfaces are wider DisplayServer needs...
     // TODO ...some or all of them need narrowing
-    virtual std::shared_ptr<frontend::Communicator> the_communicator() = 0;
+    virtual std::shared_ptr<frontend::Connector> the_connector() = 0;
     virtual std::shared_ptr<graphics::Display> the_display() = 0;
     virtual std::shared_ptr<compositor::Compositor> the_compositor() = 0;
     virtual std::shared_ptr<input::InputManager> the_input_manager() = 0;
     virtual std::shared_ptr<MainLoop> the_main_loop() = 0;
+    virtual std::shared_ptr<PauseResumeListener> the_pause_resume_listener() = 0;
     virtual std::shared_ptr<DisplayChanger> the_display_changer() = 0;
     virtual std::shared_ptr<graphics::Platform>  the_graphics_platform() = 0;
     virtual std::shared_ptr<input::InputConfiguration> the_input_configuration() = 0;

=== modified file 'include/server/mir/shell/mediating_display_changer.h'
--- include/server/mir/shell/mediating_display_changer.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/shell/mediating_display_changer.h	2013-09-26 15:36:41 +0000
@@ -57,6 +57,8 @@
     void configure(std::shared_ptr<frontend::Session> const& session,
                    std::shared_ptr<graphics::DisplayConfiguration> const& conf);
 
+    void ensure_display_powered(std::shared_ptr<frontend::Session> const& session);
+
     /* From mir::DisplayChanger */
     void configure_for_hardware_change(
         std::shared_ptr<graphics::DisplayConfiguration> const& conf,

=== modified file 'include/server/mir/shell/unauthorized_display_changer.h'
--- include/server/mir/shell/unauthorized_display_changer.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/shell/unauthorized_display_changer.h	2013-09-26 15:36:41 +0000
@@ -34,6 +34,8 @@
     std::shared_ptr<graphics::DisplayConfiguration> active_configuration();
     void configure(std::shared_ptr<frontend::Session> const&, std::shared_ptr<graphics::DisplayConfiguration> const&);
 
+    void ensure_display_powered(std::shared_ptr<frontend::Session> const& session);
+
 private:
     std::shared_ptr<frontend::DisplayChanger> const changer;
 };

=== renamed file 'src/shared/graphics/android/syncfence.h' => 'include/shared/mir/graphics/android/syncfence.h'
--- src/shared/graphics/android/syncfence.h	2013-04-24 05:22:20 +0000
+++ include/shared/mir/graphics/android/syncfence.h	2013-09-26 15:36:41 +0000
@@ -20,9 +20,6 @@
 
 #include "mir/graphics/android/sync_object.h"
 
-#include <memory>
-#define SYNC_IOC_WAIT 0x40043E00
-
 namespace mir
 {
 namespace graphics
@@ -30,23 +27,11 @@
 namespace android
 {
 
-class IoctlWrapper
-{
-public:
-    virtual ~IoctlWrapper() {}
-    virtual int ioctl(int fd, unsigned long int request, int* timeout) const = 0;
-    virtual int close(int fd) const = 0;
-
-protected:
-    IoctlWrapper() = default;
-    IoctlWrapper(IoctlWrapper const&) = delete;
-    IoctlWrapper& operator=(IoctlWrapper const&) = delete;
-};
-
 class SyncFence : public SyncObject
 {
 public:
-    SyncFence(int fd, std::shared_ptr<IoctlWrapper> const& wrapper);
+    SyncFence();
+    SyncFence(int fd);
     ~SyncFence() noexcept;
 
     void wait();
@@ -54,8 +39,6 @@
 private:
     SyncFence(SyncFence const&) = delete;
     SyncFence& operator=(SyncFence const&) = delete;
-
-    std::shared_ptr<IoctlWrapper> const ioctl_wrapper;
     int const fence_fd;
 };
 

=== modified file 'include/shared/mir_toolkit/client_types.h'
--- include/shared/mir_toolkit/client_types.h	2013-09-11 17:00:39 +0000
+++ include/shared/mir_toolkit/client_types.h	2013-09-26 15:36:41 +0000
@@ -22,6 +22,7 @@
 #define MIR_TOOLKIT_CLIENT_TYPES_H_
 
 #include <mir_toolkit/event.h>
+#include <mir_toolkit/common.h>
 
 #include <stddef.h>
 
@@ -229,7 +230,7 @@
     uint32_t vertical_resolution;
     uint32_t horizontal_resolution;
     double refresh_rate;
-}MirDisplayMode;
+} MirDisplayMode;
 
 enum { mir_display_output_id_invalid = 0 };
 
@@ -255,6 +256,8 @@
 
     uint32_t physical_width_mm;
     uint32_t physical_height_mm;
+    
+    MirPowerMode power_mode;
 } MirDisplayOutput;
 
 typedef struct MirDisplayConfiguration

=== modified file 'include/shared/mir_toolkit/common.h'
--- include/shared/mir_toolkit/common.h	2013-09-11 17:00:39 +0000
+++ include/shared/mir_toolkit/common.h	2013-09-26 15:36:41 +0000
@@ -78,6 +78,14 @@
     mir_lifecycle_state_will_suspend,
     mir_lifecycle_state_resumed
 } MirLifecycleState;
+
+typedef enum MirPowerMode
+{
+    mir_power_mode_on, /* Display in use. */
+    mir_power_mode_standby, /* Blanked, low power. */
+    mir_power_mode_suspend, /* Blanked, lowest power. */
+    mir_power_mode_off /* Powered down. */
+} MirPowerMode;
 /**@}*/
 
 #endif

=== modified file 'include/test/mir_test/test_protobuf_server.h'
--- include/test/mir_test/test_protobuf_server.h	2013-06-19 16:14:40 +0000
+++ include/test/mir_test/test_protobuf_server.h	2013-09-26 15:36:41 +0000
@@ -25,8 +25,8 @@
 {
 namespace frontend
 {
-class Communicator;
-class CommunicatorReport;
+class Connector;
+class ConnectorReport;
 }
 
 namespace protobuf
@@ -45,10 +45,10 @@
     TestProtobufServer(
         std::string const& socket_name,
         std::shared_ptr<protobuf::DisplayServer> const& tool,
-        std::shared_ptr<frontend::CommunicatorReport> const& report);
+        std::shared_ptr<frontend::ConnectorReport> const& report);
 
     // "Server" side
-    std::shared_ptr<frontend::Communicator> const comm;
+    std::shared_ptr<frontend::Connector> const comm;
 };
 }
 }

=== modified file 'include/test/mir_test_doubles/mock_display_changer.h'
--- include/test/mir_test_doubles/mock_display_changer.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/mock_display_changer.h	2013-09-26 15:36:41 +0000
@@ -35,6 +35,7 @@
     MOCK_METHOD0(active_configuration, std::shared_ptr<graphics::DisplayConfiguration>());
     MOCK_METHOD2(configure,
         void(std::shared_ptr<frontend::Session> const&, std::shared_ptr<graphics::DisplayConfiguration> const&));
+    MOCK_METHOD1(ensure_display_powered, void(std::shared_ptr<frontend::Session> const&));
 };
 
 }

=== modified file 'include/test/mir_test_doubles/mock_display_support_provider.h'
--- include/test/mir_test_doubles/mock_display_support_provider.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/mock_display_support_provider.h	2013-09-26 15:36:41 +0000
@@ -37,6 +37,7 @@
     MOCK_CONST_METHOD0(number_of_framebuffers_available, unsigned int());
     MOCK_METHOD1(set_next_frontbuffer, void(std::shared_ptr<mir::graphics::Buffer> const&));
     MOCK_METHOD1(sync_to_display, void(bool));
+    MOCK_METHOD1(blank_or_unblank_screen, void(bool));
 };
 }
 }

=== modified file 'include/test/mir_test_doubles/mock_hwc_interface.h'
--- include/test/mir_test_doubles/mock_hwc_interface.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/mock_hwc_interface.h	2013-09-26 15:36:41 +0000
@@ -41,6 +41,7 @@
     MOCK_CONST_METHOD0(number_of_framebuffers_available, unsigned int());
     MOCK_METHOD1(set_next_frontbuffer, void(std::shared_ptr<mir::graphics::Buffer> const&));
     MOCK_METHOD1(sync_to_display, void(bool));
+    MOCK_METHOD1(blank_or_unblank_screen, void(bool));
 };
 
 }

=== renamed file 'include/test/mir_test_doubles/mock_hwc_organizer.h' => 'include/test/mir_test_doubles/mock_hwc_layerlist.h'
--- include/test/mir_test_doubles/mock_hwc_organizer.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/mock_hwc_layerlist.h	2013-09-26 15:36:41 +0000
@@ -16,8 +16,8 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
-#ifndef MIR_TEST_DOUBLES_MOCK_HWC_ORGANIZER_H_
-#define MIR_TEST_DOUBLES_MOCK_HWC_ORGANIZER_H_
+#ifndef MIR_TEST_DOUBLES_MOCK_HWC_LAYERLIST_H_
+#define MIR_TEST_DOUBLES_MOCK_HWC_LAYERLIST_H_
 
 #include "src/server/graphics/android/hwc_layerlist.h"
 
@@ -30,14 +30,14 @@
 namespace doubles
 {
 
-struct MockHWCOrganizer : public graphics::android::HWCLayerOrganizer
+struct MockHWCLayerList : public graphics::android::HWCLayerList
 {
-    ~MockHWCOrganizer() noexcept {}
-    MOCK_CONST_METHOD0(native_list, graphics::android::LayerList const&());
+    ~MockHWCLayerList() noexcept {}
+    MOCK_CONST_METHOD0(native_list, hwc_display_contents_1_t*());
     MOCK_METHOD1(set_fb_target, void(std::shared_ptr<graphics::Buffer> const&));
 };
 
 }
 }
 }
-#endif /* MIR_TEST_DOUBLES_MOCK_HWC_ORGANIZER_H_ */
+#endif /* MIR_TEST_DOUBLES_MOCK_HWC_LAYERLIST_H_ */

=== added file 'include/test/mir_test_doubles/mock_pause_resume_listener.h'
--- include/test/mir_test_doubles/mock_pause_resume_listener.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_pause_resume_listener.h	2013-09-26 15:36:41 +0000
@@ -0,0 +1,44 @@
+/*
+ * 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: Robert Ancell <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_MOCK_PAUSE_RESUME_LISTENER_H_
+#define MIR_TEST_DOUBLES_MOCK_PAUSE_RESUME_LISTENER_H_
+
+#include "mir/pause_resume_listener.h"
+
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+class MockPauseResumeListener : public mir::PauseResumeListener
+{
+public:
+    MOCK_METHOD0(paused, void());
+    MOCK_METHOD0(resumed, void());
+};
+
+}
+}
+}
+
+#endif /* MIR_TEST_DOUBLES_MOCK_PAUSE_RESUME_LISTENER_H_ */

=== modified file 'include/test/mir_test_doubles/null_display_changer.h'
--- include/test/mir_test_doubles/null_display_changer.h	2013-09-09 19:07:09 +0000
+++ include/test/mir_test_doubles/null_display_changer.h	2013-09-26 15:36:41 +0000
@@ -39,6 +39,9 @@
     virtual void configure(std::shared_ptr<frontend::Session> const&, std::shared_ptr<graphics::DisplayConfiguration> const&)
     {
     }
+    virtual void ensure_display_powered(std::shared_ptr<frontend::Session> const&)
+    {
+    }
 };
 }
 }

=== removed file 'include/test/mir_test_doubles/null_display_config.h'
--- include/test/mir_test_doubles/null_display_config.h	2013-09-11 17:00:39 +0000
+++ include/test/mir_test_doubles/null_display_config.h	1970-01-01 00:00:00 +0000
@@ -1,51 +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: Kevin DuBois <[e-mail]>
- */
-
-#ifndef MIR_TEST_DOUBLES_NULL_DISPLAY_CONFIG_H_
-#define MIR_TEST_DOUBLES_NULL_DISPLAY_CONFIG_H_
-
-#include "mir/graphics/display_configuration.h"
-
-namespace mir
-{
-namespace test
-{
-namespace doubles
-{
-
-struct NullDisplayConfig : public graphics::DisplayConfiguration
-{
-    NullDisplayConfig()
-    {
-    }
-    virtual void for_each_card(std::function<void(graphics::DisplayConfigurationCard const&)>) const
-    {
-    }
-    virtual void for_each_output(std::function<void(graphics::DisplayConfigurationOutput const&)>) const
-    {
-    }
-    virtual void configure_output(graphics::DisplayConfigurationOutputId, bool, geometry::Point, size_t)
-    {
-    }
-};
-
-}
-}
-}
-
-#endif /*MIR_TEST_DOUBLES_NULL_DISPLAY_CONFIG_H_ */

=== modified file 'include/test/mir_test_doubles/null_display_configuration.h'
--- include/test/mir_test_doubles/null_display_configuration.h	2013-09-11 17:00:39 +0000
+++ include/test/mir_test_doubles/null_display_configuration.h	2013-09-26 15:36:41 +0000
@@ -35,7 +35,7 @@
     void for_each_output(std::function<void(graphics::DisplayConfigurationOutput const&)>) const
     {
     }
-    void configure_output(graphics::DisplayConfigurationOutputId, bool, geometry::Point, size_t)
+    void configure_output(graphics::DisplayConfigurationOutputId, bool, geometry::Point, size_t, MirPowerMode) override
     {
     }
 };

=== modified file 'include/test/mir_test_doubles/stub_display_configuration.h'
--- include/test/mir_test_doubles/stub_display_configuration.h	2013-09-11 17:00:39 +0000
+++ include/test/mir_test_doubles/stub_display_configuration.h	2013-09-26 15:36:41 +0000
@@ -72,7 +72,8 @@
                 ((i % 2) == 0),
                 ((i % 2) == 1),
                 top_left,
-                mode_index, 1u
+                mode_index, 1u,
+                mir_power_mode_off
             };
 
             outputs.push_back(output);
@@ -99,7 +100,7 @@
                 graphics::DisplayConfigurationOutputType::vga,
                 std::vector<geometry::PixelFormat>{geometry::PixelFormat::abgr_8888},
                 {{rect.size, 60.0}},
-                0, geometry::Size{}, true, true, rect.top_left, 0, 0
+                0, geometry::Size{}, true, true, rect.top_left, 0, 0, mir_power_mode_on
             };
 
             outputs.push_back(output);
@@ -128,7 +129,7 @@
         }
     }
 
-    void configure_output(graphics::DisplayConfigurationOutputId, bool, geometry::Point, size_t)
+    void configure_output(graphics::DisplayConfigurationOutputId, bool, geometry::Point, size_t, MirPowerMode)
     {
     }
 

=== added file 'include/test/mir_test_doubles/stub_display_support_provider.h'
--- include/test/mir_test_doubles/stub_display_support_provider.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_display_support_provider.h	2013-09-26 15:36:41 +0000
@@ -0,0 +1,45 @@
+/*
+ * 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/>.
+ *
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_DISPLAY_SUPPORT_PROVIDER_H_
+#define MIR_TEST_DOUBLES_STUB_DISPLAY_SUPPORT_PROVIDER_H_
+
+#include "src/server/graphics/android/display_support_provider.h"
+ 
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct StubDisplaySupportProvider : public graphics::android::DisplaySupportProvider
+{
+    ~StubDisplaySupportProvider() noexcept {}
+
+    geometry::Size display_size() const { return geometry::Size(); }
+    geometry::PixelFormat display_format() const { return geometry::PixelFormat(); }
+    unsigned int number_of_framebuffers_available() const { return 0; }
+    void set_next_frontbuffer(std::shared_ptr<mir::graphics::Buffer> const&) {}
+    void sync_to_display(bool) {}
+    void blank_or_unblank_screen(bool) {}
+};
+
+}
+}
+}
+#endif /* MIR_TEST_DOUBLES_STUB_DISPLAY_SUPPORT_PROVIDER_H_ */

=== modified file 'include/test/mir_test_doubles/stub_ipc_factory.h'
--- include/test/mir_test_doubles/stub_ipc_factory.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_doubles/stub_ipc_factory.h	2013-09-26 15:36:41 +0000
@@ -24,6 +24,7 @@
 #include "mir/frontend/protobuf_ipc_factory.h"
 #include "mir/frontend/resource_cache.h"
 #include "mir/frontend/null_message_processor_report.h"
+#include "mir/frontend/messenger_report.h"
 
 namespace mir
 {
@@ -53,10 +54,14 @@
         return cache;
     }
 
-    virtual std::shared_ptr<frontend::MessageProcessorReport> report()
+    virtual std::shared_ptr<frontend::MessageProcessorReport> message_processor_report()
     {
         return std::make_shared<frontend::NullMessageProcessorReport>();
     }
+    virtual std::shared_ptr<frontend::MessengerReport> messenger_report()
+    {
+        return std::make_shared<frontend::NullMessengerReport>();
+    }
 
     std::shared_ptr<protobuf::DisplayServer> server;
     std::shared_ptr<frontend::ResourceCache> const cache;

=== modified file 'include/test/mir_test_framework/cross_process_sync.h'
--- include/test/mir_test_framework/cross_process_sync.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_framework/cross_process_sync.h	2013-09-26 15:36:41 +0000
@@ -36,14 +36,15 @@
 
     // Try to signal the other side that we are ready for at most duration milliseconds.
     // Throws a std::runtime_error if not successful.
-    void try_signal_ready_for(
-        const std::chrono::milliseconds& duration = std::chrono::milliseconds(2000));
+    void try_signal_ready_for(const std::chrono::milliseconds& duration);
+
+    void try_signal_ready_for();
 
     // Wait for the other sides to signal readiness for at most duration milliseconds.
     // Returns the number of ready signals that have been collected since creation.
     // Throws std::runtime_error if not successful.
-    unsigned int wait_for_signal_ready_for(
-        const std::chrono::milliseconds& duration = std::chrono::milliseconds(2000));
+    unsigned int wait_for_signal_ready_for(const std::chrono::milliseconds& duration);
+    unsigned int wait_for_signal_ready_for();
   
     void signal_ready();
     unsigned int wait_for_signal_ready();

=== modified file 'src/client/CMakeLists.txt'
--- src/client/CMakeLists.txt	2013-09-11 17:00:39 +0000
+++ src/client/CMakeLists.txt	2013-09-26 15:36:41 +0000
@@ -68,7 +68,7 @@
   ${CLIENT_SOURCES}
 )
 
-set(MIRCLIENT_ABI 2)
+set(MIRCLIENT_ABI 3)
 
 set_target_properties(
   mirclient

=== modified file 'src/client/display_configuration.cpp'
--- src/client/display_configuration.cpp	2013-08-28 03:41:48 +0000
+++ src/client/display_configuration.cpp	2013-09-26 15:36:41 +0000
@@ -96,6 +96,7 @@
     output.used = msg.used();
     output.physical_width_mm = msg.physical_width_mm();
     output.physical_height_mm = msg.physical_height_mm();
+    output.power_mode = static_cast<MirPowerMode>(msg.power_mode());
 }
 
 }

=== modified file 'src/client/mir_connection.cpp'
--- src/client/mir_connection.cpp	2013-09-12 08:32:02 +0000
+++ src/client/mir_connection.cpp	2013-09-26 15:36:41 +0000
@@ -434,6 +434,7 @@
         display_request->set_current_mode(output.current_mode); 
         display_request->set_position_x(output.position_x); 
         display_request->set_position_y(output.position_y); 
+        display_request->set_power_mode(output.power_mode);
     }
 
     server.configure_display(0, &request, &display_configuration_response,

=== modified file 'src/client/rpc/make_socket_rpc_channel.cpp'
--- src/client/rpc/make_socket_rpc_channel.cpp	2013-08-28 03:41:48 +0000
+++ src/client/rpc/make_socket_rpc_channel.cpp	2013-09-26 15:36:41 +0000
@@ -19,15 +19,38 @@
 #include "make_rpc_channel.h"
 #include "mir_socket_rpc_channel.h"
 
+#include <cstring>
+
 namespace mcl = mir::client;
 namespace mclr = mir::client::rpc;
 
+namespace
+{
+struct Prefix
+{
+    template<int Size>
+    Prefix(char const (&prefix)[Size]) : size(Size-1), prefix(prefix) {}
+
+    bool is_start_of(std::string const& name) const
+    { return !strncmp(name.c_str(), prefix, size); }
+
+    int const size;
+    char const* const prefix;
+} const fd_prefix("fd://");
+}
+
 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,
                        std::shared_ptr<mcl::LifecycleControl> const& lifecycle_control)
-{ 
+{
+    if (fd_prefix.is_start_of(name))
+    {
+        auto const fd = atoi(name.c_str()+fd_prefix.size);
+        return std::make_shared<MirSocketRpcChannel>(fd, map, disp_conf, rpc_report, lifecycle_control);
+    }
+
     return std::make_shared<MirSocketRpcChannel>(name, map, disp_conf, rpc_report, lifecycle_control);
 }

=== modified file 'src/client/rpc/mir_socket_rpc_channel.cpp'
--- src/client/rpc/mir_socket_rpc_channel.cpp	2013-08-28 03:41:48 +0000
+++ src/client/rpc/mir_socket_rpc_channel.cpp	2013-09-26 15:36:41 +0000
@@ -55,14 +55,35 @@
     rpc_report(rpc_report),
     pending_calls(rpc_report),
     work(io_service),
-    endpoint(endpoint),
     socket(io_service),
     surface_map(surface_map),
     display_configuration(disp_config),
     lifecycle_control(lifecycle_control)
 {
     socket.connect(endpoint);
-
+    init();
+}
+
+mclr::MirSocketRpcChannel::MirSocketRpcChannel(
+    int native_socket,
+    std::shared_ptr<mcl::SurfaceMap> const& surface_map,
+    std::shared_ptr<DisplayConfiguration> const& disp_config,
+    std::shared_ptr<RpcReport> const& rpc_report,
+    std::shared_ptr<LifecycleControl> const& lifecycle_control) :
+    rpc_report(rpc_report),
+    pending_calls(rpc_report),
+    work(io_service),
+    socket(io_service),
+    surface_map(surface_map),
+    display_configuration(disp_config),
+    lifecycle_control(lifecycle_control)
+{
+    socket.assign(boost::asio::local::stream_protocol(), native_socket);
+    init();
+}
+
+void mclr::MirSocketRpcChannel::init()
+{
     auto run_io_service = boost::bind(&boost::asio::io_service::run, &io_service);
 
     // Our IO threads must not recieve any signals
@@ -74,9 +95,8 @@
         BOOST_THROW_EXCEPTION(
             boost::enable_error_info(
                 std::runtime_error("Failed to block signals on IO thread")) << boost::errinfo_errno(error));
-            
 
-    io_service_thread = std::move(std::thread(run_io_service));
+    io_service_thread = std::thread(run_io_service);
 
     // Restore previous signals.
     if ((error = pthread_sigmask(SIG_SETMASK, &old_mask, NULL)))

=== modified file 'src/client/rpc/mir_socket_rpc_channel.h'
--- src/client/rpc/mir_socket_rpc_channel.h	2013-08-28 03:41:48 +0000
+++ src/client/rpc/mir_socket_rpc_channel.h	2013-09-26 15:36:41 +0000
@@ -57,9 +57,17 @@
                         std::shared_ptr<DisplayConfiguration> const& disp_config,
                         std::shared_ptr<RpcReport> const& rpc_report,
                         std::shared_ptr<LifecycleControl> const& lifecycle_control);
+
+    MirSocketRpcChannel(int native_socket,
+                        std::shared_ptr<SurfaceMap> const& surface_map,
+                        std::shared_ptr<DisplayConfiguration> const& disp_config,
+                        std::shared_ptr<RpcReport> const& rpc_report,
+                        std::shared_ptr<LifecycleControl> const& lifecycle_control);
     ~MirSocketRpcChannel();
 
 private:
+    void init();
+
     virtual void CallMethod(const google::protobuf::MethodDescriptor* method, google::protobuf::RpcController*,
         const google::protobuf::Message* parameters, google::protobuf::Message* response,
         google::protobuf::Closure* complete);
@@ -68,7 +76,6 @@
     std::thread io_service_thread;
     boost::asio::io_service io_service;
     boost::asio::io_service::work work;
-    boost::asio::local::stream_protocol::endpoint endpoint;
     boost::asio::local::stream_protocol::socket socket;
 
     static size_t const size_of_header = 2;

=== modified file 'src/platform/graphics/default_display_configuration_policy.cpp'
--- src/platform/graphics/default_display_configuration_policy.cpp	2013-09-11 17:00:39 +0000
+++ src/platform/graphics/default_display_configuration_policy.cpp	2013-09-26 15:36:41 +0000
@@ -24,6 +24,8 @@
 
 void mg::DefaultDisplayConfigurationPolicy::apply_to(DisplayConfiguration& conf)
 {
+    static MirPowerMode const default_power_state = mir_power_mode_on;
+
     conf.for_each_output(
         [&conf](DisplayConfigurationOutput const& conf_output)
         {
@@ -34,12 +36,12 @@
                     preferred_mode_index = 0;
 
                 conf.configure_output(conf_output.id, true, geom::Point(),
-                                      preferred_mode_index);
+                                      preferred_mode_index, default_power_state);
             }
             else
             {
                 conf.configure_output(conf_output.id, false, conf_output.top_left,
-                                      conf_output.current_mode_index);
+                                      conf_output.current_mode_index, default_power_state);
             }
         });
 }

=== modified file 'src/server/CMakeLists.txt'
--- src/server/CMakeLists.txt	2013-09-18 13:59:53 +0000
+++ src/server/CMakeLists.txt	2013-09-26 15:36:41 +0000
@@ -88,7 +88,7 @@
   )
 endif()
 
-set(MIRSERVER_ABI 3)
+set(MIRSERVER_ABI 4)
 
 set_target_properties(
   mirserver

=== modified file 'src/server/compositor/default_display_buffer_compositor.cpp'
--- src/server/compositor/default_display_buffer_compositor.cpp	2013-08-29 09:00:55 +0000
+++ src/server/compositor/default_display_buffer_compositor.cpp	2013-09-26 15:36:41 +0000
@@ -75,10 +75,6 @@
 
 void mc::DefaultDisplayBufferCompositor::composite()
 {
-    static bool got_bypass_env = false;
-    static bool bypass_env = true;
-    bool bypassed = false;
-
     /*
      * Increment frame counts for each tick of the fastest instance of
      * DefaultDisplayBufferCompositor. This means for the fastest refresh
@@ -93,14 +89,8 @@
             local_frameno = global_frameno;
     }
 
-    if (!got_bypass_env)
-    {
-        const char *env = getenv("MIR_BYPASS");
-        if (env != NULL)
-            bypass_env = env[0] != '0';
-
-        got_bypass_env = true;
-    }
+    static bool const bypass_env{[]{ auto const env = getenv("MIR_BYPASS"); return !env || env[0] != '0'; }()};
+    bool bypassed = false;
 
     if (bypass_env && display_buffer.can_bypass())
     {

=== modified file 'src/server/default_server_configuration.cpp'
--- src/server/default_server_configuration.cpp	2013-09-19 12:26:41 +0000
+++ src/server/default_server_configuration.cpp	2013-09-26 15:36:41 +0000
@@ -19,6 +19,7 @@
 #include "mir/default_server_configuration.h"
 #include "mir/abnormal_exit.h"
 #include "mir/asio_main_loop.h"
+#include "mir/default_pause_resume_listener.h"
 #include "mir/shared_library.h"
 
 #include "mir/options/program_option.h"
@@ -29,6 +30,7 @@
 #include "mir/frontend/protobuf_ipc_factory.h"
 #include "mir/frontend/session_mediator_report.h"
 #include "mir/frontend/null_message_processor_report.h"
+#include "mir/frontend/messenger_report.h"
 #include "mir/frontend/session_mediator.h"
 #include "mir/frontend/session_authorizer.h"
 #include "mir/frontend/global_event_sender.h"
@@ -74,6 +76,7 @@
 #include "mir/logging/session_mediator_report.h"
 #include "mir/logging/message_processor_report.h"
 #include "mir/logging/display_report.h"
+#include "mir/logging/messenger_report.h"
 #include "mir/lttng/message_processor_report.h"
 #include "mir/lttng/input_report.h"
 #include "mir/shell/surface_source.h"
@@ -112,13 +115,15 @@
     explicit DefaultIpcFactory(
         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<mf::MessageProcessorReport> const& mp_report,
+        std::shared_ptr<mf::MessengerReport> const& messenger_report,
         std::shared_ptr<mg::Platform> const& graphics_platform,
         std::shared_ptr<mf::DisplayChanger> const& display_changer,
         std::shared_ptr<mg::GraphicBufferAllocator> const& buffer_allocator) :
         shell(shell),
         sm_report(sm_report),
-        mp_report(mr_report),
+        mp_report(mp_report),
+        msger_report(messenger_report),
         cache(std::make_shared<mf::ResourceCache>()),
         graphics_platform(graphics_platform),
         display_changer(display_changer),
@@ -130,6 +135,7 @@
     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::MessengerReport> const msger_report;
     std::shared_ptr<mf::ResourceCache> const cache;
     std::shared_ptr<mg::Platform> const graphics_platform;
     std::shared_ptr<mf::DisplayChanger> const display_changer;
@@ -163,15 +169,21 @@
         return cache;
     }
 
-    virtual std::shared_ptr<mf::MessageProcessorReport> report()
+    virtual std::shared_ptr<mf::MessageProcessorReport> message_processor_report()
     {
         return mp_report;
     }
+    virtual std::shared_ptr<mf::MessengerReport> messenger_report()
+    {
+        return msger_report;
+    }
 };
 
 char const* const server_socket_opt           = "file";
+char const* const no_server_socket_opt        = "no-file";
 char const* const session_mediator_report_opt = "session-mediator-report";
 char const* const msg_processor_report_opt    = "msg-processor-report";
+char const* const messenger_report_opt        = "messenger-report";
 char const* const display_report_opt          = "display-report";
 char const* const legacy_input_report_opt     = "legacy-input-report";
 char const* const input_report_opt            = "input-report";
@@ -254,6 +266,7 @@
             "Host socket filename. [string:default={$MIR_SOCKET,/tmp/mir_socket}]")
         ("file,f", po::value<std::string>(),
             "Socket filename. [string:default=/tmp/mir_socket]")
+        (no_server_socket_opt, "Do not provide a socket filename for client connections")
         (platform_graphics_lib, po::value<std::string>(),
             "Library to use for platform graphics support [default=libmirplatformgraphics.so]")
         ("enable-input,i", po::value<bool>(),
@@ -821,6 +834,7 @@
                 shell,
                 the_session_mediator_report(),
                 the_message_processor_report(),
+                the_messenger_report(),
                 the_graphics_platform(),
                 the_frontend_display_changer(), allocator);
         });
@@ -887,6 +901,23 @@
         });
 }
 
+std::shared_ptr<mf::MessengerReport>
+mir::DefaultServerConfiguration::the_messenger_report()
+{
+    return messenger_report(
+        [this]() -> std::shared_ptr<mf::MessengerReport>
+        {
+            auto report_opt = the_options()->get(messenger_report_opt, off_opt_value);
+            if (report_opt == log_opt_value)
+            {
+                return std::make_shared<ml::MessengerReport>(the_logger());
+            }
+            else
+            {
+                return std::make_shared<mf::NullMessengerReport>();
+            }
+        });
+}
 
 std::shared_ptr<ml::Logger> mir::DefaultServerConfiguration::the_logger()
 {
@@ -949,6 +980,16 @@
         });
 }
 
+
+std::shared_ptr<mir::PauseResumeListener> mir::DefaultServerConfiguration::the_pause_resume_listener()
+{
+    return pause_resume_listener(
+        []()
+        {
+            return std::make_shared<mir::DefaultPauseResumeListener>();
+        });
+}
+
 std::shared_ptr<mg::DisplayConfigurationPolicy>
 mir::DefaultServerConfiguration::the_display_configuration_policy()
 {

=== modified file 'src/server/display_server.cpp'
--- src/server/display_server.cpp	2013-08-28 03:41:48 +0000
+++ src/server/display_server.cpp	2013-09-26 15:36:41 +0000
@@ -21,10 +21,11 @@
 #include "mir/display_server.h"
 #include "mir/server_configuration.h"
 #include "mir/main_loop.h"
+#include "mir/pause_resume_listener.h"
 #include "mir/display_changer.h"
 
 #include "mir/compositor/compositor.h"
-#include "mir/frontend/communicator.h"
+#include "mir/frontend/connector.h"
 #include "mir/graphics/display.h"
 #include "mir/input/input_manager.h"
 
@@ -71,9 +72,10 @@
           display{config.the_display()},
           input_configuration{config.the_input_configuration()},
           compositor{config.the_compositor()},
-          communicator{config.the_communicator()},
+          connector{config.the_connector()},
           input_manager{config.the_input_manager()},
           main_loop{config.the_main_loop()},
+          pause_resume_listener{config.the_pause_resume_listener()},
           display_changer{config.the_display_changer()},
           paused{false},
           configure_display_on_resume{false}
@@ -101,8 +103,8 @@
                 [this] { compositor->start(); }};
 
             TryButRevertIfUnwinding comm{
-                [this] { communicator->stop(); },
-                [this] { communicator->start(); }};
+                [this] { connector->stop(); },
+                [this] { connector->start(); }};
 
             display->pause();
 
@@ -113,6 +115,8 @@
             return false;
         }
 
+        pause_resume_listener->paused();
+
         return true;
     }
 
@@ -125,8 +129,8 @@
                 [this] { display->pause(); }};
 
             TryButRevertIfUnwinding comm{
-                [this] { communicator->start(); },
-                [this] { communicator->stop(); }};
+                [this] { connector->start(); },
+                [this] { connector->stop(); }};
 
             if (configure_display_on_resume)
             {
@@ -149,6 +153,8 @@
             return false;
         }
 
+        pause_resume_listener->resumed();
+
         return true;
     }
 
@@ -170,9 +176,10 @@
     std::shared_ptr<mg::Display> const display;
     std::shared_ptr<input::InputConfiguration> const input_configuration;
     std::shared_ptr<mc::Compositor> const compositor;
-    std::shared_ptr<mf::Communicator> const communicator;
+    std::shared_ptr<mf::Connector> const connector;
     std::shared_ptr<mi::InputManager> const input_manager;
     std::shared_ptr<mir::MainLoop> const main_loop;
+    std::shared_ptr<mir::PauseResumeListener> const pause_resume_listener;
     std::shared_ptr<mir::DisplayChanger> const display_changer;
     bool paused;
     bool configure_display_on_resume;
@@ -194,7 +201,7 @@
 
 void mir::DisplayServer::run()
 {
-    p->communicator->start();
+    p->connector->start();
     p->compositor->start();
     p->input_manager->start();
 
@@ -202,7 +209,7 @@
 
     p->input_manager->stop();
     p->compositor->stop();
-    p->communicator->stop();
+    p->connector->stop();
 }
 
 void mir::DisplayServer::stop()

=== modified file 'src/server/frontend/CMakeLists.txt'
--- src/server/frontend/CMakeLists.txt	2013-08-28 03:41:48 +0000
+++ src/server/frontend/CMakeLists.txt	2013-09-26 15:36:41 +0000
@@ -5,24 +5,24 @@
   session_mediator.cpp
   null_session_mediator_report.cpp
   null_message_processor_report.cpp
+  null_messenger_report.cpp
   protobuf_message_processor.cpp
   protobuf_buffer_packer.cpp
   null_message_processor.cpp
   global_event_sender.cpp
-
+  published_socket_connector.cpp
+  protobuf_session_creator.cpp
+  socket_session.cpp
   resource_cache.cpp
   socket_messenger.cpp
   event_sender.cpp
   surface.cpp
+
+  default_configuration.cpp
+
   ${PROTO_HDRS}
 )
 
-list(APPEND FRONTEND_SOURCES
-  protobuf_socket_communicator.cpp
-  make_protobuf_socket_communicator.cpp
-  socket_session.cpp
-)
-
 if (MIR_PLATFORM STREQUAL "android")
   list(APPEND FRONTEND_SOURCES session_mediator_android.cpp)
 elseif (MIR_PLATFORM STREQUAL "gbm")

=== renamed file 'src/server/frontend/make_protobuf_socket_communicator.cpp' => 'src/server/frontend/default_configuration.cpp'
--- src/server/frontend/make_protobuf_socket_communicator.cpp	2013-08-28 03:41:48 +0000
+++ src/server/frontend/default_configuration.cpp	2013-09-26 15:36:41 +0000
@@ -17,39 +17,67 @@
  */
 
 #include "mir/default_server_configuration.h"
+#include "protobuf_session_creator.h"
+
 #include "mir/options/option.h"
 #include "mir/frontend/shell.h"
 #include "mir/shell/session_container.h"
 #include "mir/shell/session.h"
-#include "protobuf_socket_communicator.h"
-#include "mir/frontend/communicator_report.h"
+#include "published_socket_connector.h"
+#include "mir/frontend/connector_report.h"
 
 namespace mf = mir::frontend;
-namespace mg = mir::graphics;
-namespace mc = mir::compositor;
 namespace msh = mir::shell;
 
-std::shared_ptr<mf::Communicator>
-mir::DefaultServerConfiguration::the_communicator()
-{
-    return communicator(
-        [&,this]() -> std::shared_ptr<mf::Communicator>
+namespace
+{
+char const* const no_server_socket_opt        = "no-file";
+}
+
+std::shared_ptr<mf::SessionCreator>
+mir::DefaultServerConfiguration::the_session_creator()
+{
+    return session_creator([this]
+        {
+            return std::make_shared<mf::ProtobufSessionCreator>(
+                the_ipc_factory(the_frontend_shell(), the_buffer_allocator()),
+                the_session_authorizer());
+        });
+}
+
+std::shared_ptr<mf::Connector>
+mir::DefaultServerConfiguration::the_connector()
+{
+    return connector(
+        [&,this]() -> std::shared_ptr<mf::Connector>
         {
             auto const threads = the_options()->get("ipc-thread-pool", 10);
             auto shell_sessions = the_shell_session_container();
-            return std::make_shared<mf::ProtobufSocketCommunicator>(
-                the_socket_file(),
-                the_ipc_factory(the_frontend_shell(), the_buffer_allocator()),
-                the_session_authorizer(),
-                threads,
-                [shell_sessions]
+            auto const& force_requests_to_complete = [shell_sessions]
+            {
+                shell_sessions->for_each([](std::shared_ptr<msh::Session> const& session)
                 {
-                    shell_sessions->for_each([](std::shared_ptr<msh::Session> const& session)
-                    {
-                        session->force_requests_to_complete();
-                    });
-                },
-                std::make_shared<mf::NullCommunicatorReport>());
+                    session->force_requests_to_complete();
+                });
+            };
+
+            if (the_options()->is_set(no_server_socket_opt))
+            {
+                return std::make_shared<mf::BasicConnector>(
+                    the_session_creator(),
+                    threads,
+                    force_requests_to_complete,
+                    std::make_shared<mf::NullConnectorReport>());
+            }
+            else
+            {
+                return std::make_shared<mf::PublishedSocketConnector>(
+                    the_socket_file(),
+                    the_session_creator(),
+                    threads,
+                    force_requests_to_complete,
+                    std::make_shared<mf::NullConnectorReport>());
+            }
         });
 }
 

=== added file 'src/server/frontend/null_messenger_report.cpp'
--- src/server/frontend/null_messenger_report.cpp	1970-01-01 00:00:00 +0000
+++ src/server/frontend/null_messenger_report.cpp	2013-09-26 15:36:41 +0000
@@ -0,0 +1,25 @@
+/*
+ * 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: Robert Carr <[e-mail]>
+ */
+
+#include "mir/frontend/messenger_report.h"
+
+namespace mf = mir::frontend;
+
+void mf::NullMessengerReport::error(std::string const&)
+{
+}

=== modified file 'src/server/frontend/null_session_mediator_report.cpp'
--- src/server/frontend/null_session_mediator_report.cpp	2013-05-30 03:50:54 +0000
+++ src/server/frontend/null_session_mediator_report.cpp	2013-09-26 15:36:41 +0000
@@ -46,6 +46,10 @@
 {
 }
 
+void mir::frontend::NullSessionMediatorReport::session_configure_display_called(std::string const&)
+{
+}
+
 void mir::frontend::NullSessionMediatorReport::session_error(
         std::string const&,
         char const* ,

=== modified file 'src/server/frontend/protobuf_buffer_packer.cpp'
--- src/server/frontend/protobuf_buffer_packer.cpp	2013-09-12 08:05:56 +0000
+++ src/server/frontend/protobuf_buffer_packer.cpp	2013-09-26 15:36:41 +0000
@@ -65,6 +65,7 @@
     protobuf_output.set_position_y(display_output.top_left.y.as_uint32_t());
     protobuf_output.set_current_mode(display_output.current_mode_index);
     protobuf_output.set_current_format(display_output.current_format_index);
+    protobuf_output.set_power_mode(static_cast<uint32_t>(display_output.power_mode));
 }
 
 }

=== added file 'src/server/frontend/protobuf_session_creator.cpp'
--- src/server/frontend/protobuf_session_creator.cpp	1970-01-01 00:00:00 +0000
+++ src/server/frontend/protobuf_session_creator.cpp	2013-09-26 15:36:41 +0000
@@ -0,0 +1,73 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alan Griffiths <[e-mail]>
+ */
+
+#include "protobuf_session_creator.h"
+
+#include "event_sender.h"
+#include "protobuf_message_processor.h"
+#include "socket_messenger.h"
+#include "socket_session.h"
+
+#include "mir/frontend/protobuf_ipc_factory.h"
+#include "mir/frontend/session_authorizer.h"
+#include "mir/protobuf/google_protobuf_guard.h"
+
+namespace mf = mir::frontend;
+namespace mfd = mir::frontend::detail;
+namespace ba = boost::asio;
+
+mf::ProtobufSessionCreator::ProtobufSessionCreator(
+    std::shared_ptr<ProtobufIpcFactory> const& ipc_factory,
+    std::shared_ptr<mf::SessionAuthorizer> const& session_authorizer)
+:   ipc_factory(ipc_factory),
+    session_authorizer(session_authorizer),
+    next_session_id(0),
+    connected_sessions(std::make_shared<mfd::ConnectedSessions<mfd::SocketSession>>())
+{
+}
+
+mf::ProtobufSessionCreator::~ProtobufSessionCreator() noexcept
+{
+    connected_sessions->clear();
+}
+
+int mf::ProtobufSessionCreator::next_id()
+{
+    return next_session_id.fetch_add(1);
+}
+
+void mf::ProtobufSessionCreator::create_session_for(std::shared_ptr<ba::local::stream_protocol::socket> const& socket)
+{
+    auto const messenger = std::make_shared<detail::SocketMessenger>(socket, ipc_factory->messenger_report());
+    auto const client_pid = messenger->client_pid();
+
+    if (session_authorizer->connection_is_allowed(client_pid))
+    {
+        auto const authorized_to_resize_display = session_authorizer->configure_display_is_allowed(client_pid);
+        auto const event_sink = std::make_shared<detail::EventSender>(messenger);
+        auto const msg_processor = std::make_shared<detail::ProtobufMessageProcessor>(
+            messenger,
+            ipc_factory->make_ipc_server(event_sink, authorized_to_resize_display),
+            ipc_factory->resource_cache(),
+            ipc_factory->message_processor_report());
+
+        const auto& session = std::make_shared<mfd::SocketSession>(messenger, next_id(), connected_sessions, msg_processor);
+        connected_sessions->add(session);
+        session->read_next_message();
+    }
+}

=== added file 'src/server/frontend/protobuf_session_creator.h'
--- src/server/frontend/protobuf_session_creator.h	1970-01-01 00:00:00 +0000
+++ src/server/frontend/protobuf_session_creator.h	2013-09-26 15:36:41 +0000
@@ -0,0 +1,60 @@
+/*
+ * 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_FRONTEND_PROTOBUF_SESSION_CREATOR_H_
+#define MIR_FRONTEND_PROTOBUF_SESSION_CREATOR_H_
+
+#include "mir/frontend/session_creator.h"
+#include "connected_sessions.h"
+
+#include <atomic>
+
+namespace mir
+{
+namespace frontend
+{
+class ProtobufIpcFactory;
+class SessionAuthorizer;
+
+namespace detail
+{
+struct SocketSession;
+}
+
+class ProtobufSessionCreator : public SessionCreator
+{
+public:
+    ProtobufSessionCreator(
+        std::shared_ptr<ProtobufIpcFactory> const& ipc_factory,
+        std::shared_ptr<SessionAuthorizer> const& session_authorizer);
+    ~ProtobufSessionCreator() noexcept;
+
+    void create_session_for(std::shared_ptr<boost::asio::local::stream_protocol::socket> const& socket);
+
+private:
+    int next_id();
+
+    std::shared_ptr<ProtobufIpcFactory> const ipc_factory;
+    std::shared_ptr<SessionAuthorizer> const session_authorizer;
+    std::atomic<int> next_session_id;
+    std::shared_ptr<detail::ConnectedSessions<detail::SocketSession>> const connected_sessions;
+};
+}
+}
+
+#endif /* MIR_FRONTEND_PROTOBUF_SESSION_CREATOR_H_ */

=== renamed file 'src/server/frontend/protobuf_socket_communicator.cpp' => 'src/server/frontend/published_socket_connector.cpp'
--- src/server/frontend/protobuf_socket_communicator.cpp	2013-08-28 03:41:48 +0000
+++ src/server/frontend/published_socket_connector.cpp	2013-09-26 15:36:41 +0000
@@ -16,67 +16,78 @@
  * Authored by: Thomas Guest <[e-mail]>
  */
 
-#include "protobuf_socket_communicator.h"
-#include "protobuf_message_processor.h"
-#include "socket_session.h"
+#include "published_socket_connector.h"
+#include "protobuf_session_creator.h"
 
-#include "mir/frontend/communicator_report.h"
-#include "mir/frontend/protobuf_ipc_factory.h"
-#include "mir/frontend/session_authorizer.h"
-#include "socket_messenger.h"
-#include "event_sender.h"
-#include "mir/protobuf/google_protobuf_guard.h"
+#include "mir/frontend/connector_report.h"
 
 #include <boost/signals2.hpp>
+#include <boost/exception/errinfo_errno.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <sys/socket.h>
 
 namespace mf = mir::frontend;
 namespace mfd = mir::frontend::detail;
 namespace ba = boost::asio;
 
-mf::ProtobufSocketCommunicator::ProtobufSocketCommunicator(
-    std::string const& socket_file,
-    std::shared_ptr<ProtobufIpcFactory> const& ipc_factory,
-    std::shared_ptr<mf::SessionAuthorizer> const& session_authorizer,
+mf::PublishedSocketConnector::PublishedSocketConnector(
+    const std::string& socket_file,
+    std::shared_ptr<SessionCreator> const& session_creator,
     int threads,
     std::function<void()> const& force_requests_to_complete,
-    std::shared_ptr<CommunicatorReport> const& report)
-:   socket_file((std::remove(socket_file.c_str()), socket_file)),
-    acceptor(io_service, socket_file),
-    io_service_threads(threads),
-    ipc_factory(ipc_factory),
-    session_authorizer(session_authorizer),
-    next_session_id(0),
-    connected_sessions(std::make_shared<mfd::ConnectedSessions<mfd::SocketSession>>()),
-    force_requests_to_complete(force_requests_to_complete),
-    report(report)
+    std::shared_ptr<ConnectorReport> const& report)
+:   BasicConnector(session_creator, threads, force_requests_to_complete, report),
+    socket_file(socket_file),
+    acceptor(io_service, socket_file)
 {
     start_accept();
 }
 
-void mf::ProtobufSocketCommunicator::start_accept()
+mf::PublishedSocketConnector::~PublishedSocketConnector() noexcept
+{
+    std::remove(socket_file.c_str());
+}
+
+void mf::PublishedSocketConnector::start_accept()
 {
     auto socket = std::make_shared<boost::asio::local::stream_protocol::socket>(io_service);
 
     acceptor.async_accept(
         *socket,
         boost::bind(
-            &ProtobufSocketCommunicator::on_new_connection,
+            &PublishedSocketConnector::on_new_connection,
             this,
             socket,
             ba::placeholders::error));
 }
 
-int mf::ProtobufSocketCommunicator::next_id()
-{
-    int id = next_session_id.load();
-    while (!next_session_id.compare_exchange_weak(id, id + 1)) std::this_thread::yield();
-    return id;
-}
-
-
-void mf::ProtobufSocketCommunicator::start()
-{
-    auto run_io_service = [&]
+void mf::PublishedSocketConnector::on_new_connection(
+    std::shared_ptr<boost::asio::local::stream_protocol::socket> const& socket,
+    boost::system::error_code const& ec)
+{
+    if (!ec)
+    {
+        create_session_for(socket);
+    }
+    start_accept();
+}
+
+mf::BasicConnector::BasicConnector(
+    std::shared_ptr<SessionCreator> const& session_creator,
+    int threads,
+    std::function<void()> const& force_requests_to_complete,
+    std::shared_ptr<ConnectorReport> const& report)
+:   io_service_threads(threads),
+    force_requests_to_complete(force_requests_to_complete),
+    report(report),
+    session_creator{session_creator}
+{
+}
+
+void mf::BasicConnector::start()
+{
+    auto run_io_service = [this]
     {
         while (true)
         try
@@ -92,16 +103,16 @@
 
     for (auto& thread : io_service_threads)
     {
-        thread = std::move(std::thread(run_io_service));
+        thread = std::thread(run_io_service);
     }
 }
 
-void mf::ProtobufSocketCommunicator::stop()
+void mf::BasicConnector::stop()
 {
     /* Stop processing new requests */
     io_service.stop();
 
-    /* 
+    /*
      * Ensure that any pending requests will complete (i.e., that they
      * will not block indefinitely waiting for a resource from the server)
      */
@@ -120,44 +131,36 @@
     io_service.reset();
 }
 
-mf::ProtobufSocketCommunicator::~ProtobufSocketCommunicator()
+void mf::BasicConnector::create_session_for(std::shared_ptr<boost::asio::local::stream_protocol::socket> const& server_socket) const
+{
+    session_creator->create_session_for(server_socket);
+}
+
+int mf::BasicConnector::client_socket_fd() const
+{
+    enum { server, client, size };
+    int socket_fd[size];
+
+    if (socketpair(AF_LOCAL, SOCK_STREAM, 0, socket_fd))
+    {
+        BOOST_THROW_EXCEPTION(
+            boost::enable_error_info(
+                std::runtime_error("Could not create socket pair")) << boost::errinfo_errno(errno));
+    }
+
+    auto const server_socket = std::make_shared<boost::asio::local::stream_protocol::socket>(
+        io_service, boost::asio::local::stream_protocol(), socket_fd[server]);
+
+    create_session_for(server_socket);
+
+    return socket_fd[client];
+}
+
+mf::BasicConnector::~BasicConnector() noexcept
 {
     stop();
-
-    connected_sessions->clear();
-
-    std::remove(socket_file.c_str());
-}
-
-void mf::ProtobufSocketCommunicator::on_new_connection(
-    std::shared_ptr<boost::asio::local::stream_protocol::socket> const& socket,
-    boost::system::error_code const& ec)
-{
-    if (!ec)
-    {
-        auto messenger = std::make_shared<detail::SocketMessenger>(socket);
-        auto client_pid = messenger->client_pid(); 
-        if (session_authorizer->connection_is_allowed(client_pid))
-        {
-            auto authorized_to_resize_display = session_authorizer->configure_display_is_allowed(client_pid);
-            auto event_sink = std::make_shared<detail::EventSender>(messenger);
-            auto msg_processor = std::make_shared<detail::ProtobufMessageProcessor>(
-                messenger,
-                ipc_factory->make_ipc_server(event_sink, authorized_to_resize_display),
-                ipc_factory->resource_cache(),
-                ipc_factory->report());
-            auto const& session = std::make_shared<mfd::SocketSession>(
-                messenger,
-                next_id(),
-                connected_sessions,
-                msg_processor);
-            connected_sessions->add(session);
-            session->read_next_message();
-        }
-    }
-    start_accept();
-}
-
-void mf::NullCommunicatorReport::error(std::exception const& /*error*/)
+}
+
+void mf::NullConnectorReport::error(std::exception const& /*error*/)
 {
 }

=== renamed file 'src/server/frontend/protobuf_socket_communicator.h' => 'src/server/frontend/published_socket_connector.h'
--- src/server/frontend/protobuf_socket_communicator.h	2013-08-28 03:41:48 +0000
+++ src/server/frontend/published_socket_connector.h	2013-09-26 15:36:41 +0000
@@ -19,13 +19,10 @@
 #ifndef MIR_FRONTEND_PROTOBUF_ASIO_COMMUNICATOR_H_
 #define MIR_FRONTEND_PROTOBUF_ASIO_COMMUNICATOR_H_
 
-#include "connected_sessions.h"
-
-#include "mir/frontend/communicator.h"
+#include "mir/frontend/connector.h"
 
 #include <boost/asio.hpp>
 
-#include <atomic>
 #include <thread>
 #include <string>
 #include <vector>
@@ -43,52 +40,54 @@
 {
 namespace frontend
 {
-class ResourceCache;
-class ProtobufIpcFactory;
-class SessionAuthorizer;
-
-namespace detail
-{
-struct SocketSession;
-class MessageSender;
-}
-
-class CommunicatorReport;
-
-class ProtobufSocketCommunicator : public Communicator
-{
-public:
-    // Create communicator based on Boost asio and Google protobufs
-    // using the supplied socket.
-    explicit ProtobufSocketCommunicator(
+class SessionCreator;
+class ConnectorReport;
+
+/// provides a client-side socket fd for each connection
+class BasicConnector : public Connector
+{
+public:
+    explicit BasicConnector(
+        std::shared_ptr<SessionCreator> const& session_creator,
+        int threads,
+        std::function<void()> const& force_requests_to_complete,
+        std::shared_ptr<ConnectorReport> const& report);
+    ~BasicConnector() noexcept;
+    void start() override;
+    void stop() override;
+    int client_socket_fd() const override;
+
+protected:
+    void create_session_for(std::shared_ptr<boost::asio::local::stream_protocol::socket> const& server_socket) const;
+    boost::asio::io_service mutable io_service;
+
+private:
+    std::vector<std::thread> io_service_threads;
+    std::function<void()> const force_requests_to_complete;
+    std::shared_ptr<ConnectorReport> const report;
+    std::shared_ptr<SessionCreator> const session_creator;
+};
+
+/// Accept connections over a published socket
+class PublishedSocketConnector : public BasicConnector
+{
+public:
+    explicit PublishedSocketConnector(
         const std::string& socket_file,
-        std::shared_ptr<ProtobufIpcFactory> const& ipc_factory,
-        std::shared_ptr<SessionAuthorizer> const& session_authorizer,
+        std::shared_ptr<SessionCreator> const& session_creator,
         int threads,
         std::function<void()> const& force_requests_to_complete,
-        std::shared_ptr<CommunicatorReport> const& report);
-    ~ProtobufSocketCommunicator();
-    void start();
-    void stop();
+        std::shared_ptr<ConnectorReport> const& report);
+    ~PublishedSocketConnector() noexcept;
 
 private:
     void start_accept();
     void on_new_connection(std::shared_ptr<boost::asio::local::stream_protocol::socket> const& socket,
                            boost::system::error_code const& ec);
-    int next_id();
 
     const std::string socket_file;
-    boost::asio::io_service io_service;
     boost::asio::local::stream_protocol::acceptor acceptor;
-    std::vector<std::thread> io_service_threads;
-    std::shared_ptr<ProtobufIpcFactory> const ipc_factory;
-    std::shared_ptr<SessionAuthorizer> const session_authorizer;
-    std::atomic<int> next_session_id;
-    std::shared_ptr<detail::ConnectedSessions<detail::SocketSession>> const connected_sessions;
-    std::function<void()> const force_requests_to_complete;
-    std::shared_ptr<CommunicatorReport> const report;
 };
-
 }
 }
 

=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2013-09-11 17:00:39 +0000
+++ src/server/frontend/session_mediator.cpp	2013-09-26 15:36:41 +0000
@@ -181,6 +181,12 @@
             BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
 
         report->session_next_buffer_called(session->name());
+        
+        // We ensure the client has not powered down the outputs, so that
+        // swap_buffer will not block indefinitely, leaving the client
+        // in a position where it can not turn back on the
+        // outputs.
+        display_changer->ensure_display_powered(session);
 
         auto surface = session->get_surface(SurfaceId(request->value()));
 
@@ -292,6 +298,8 @@
         if (session.get() == nullptr)
             BOOST_THROW_EXCEPTION(std::logic_error("Invalid application session"));
 
+        report->session_configure_display_called(session->name());
+
         auto config = display_changer->active_configuration();
         for (auto i=0; i < request->display_output_size(); i++)
         {   
@@ -299,7 +307,7 @@
             mg::DisplayConfigurationOutputId output_id{static_cast<int>(output.output_id())};
             config->configure_output(output_id, output.used(),
                                      geom::Point{output.position_x(), output.position_y()},
-                                     output.current_mode());
+                                     output.current_mode(), static_cast<MirPowerMode>(output.power_mode()));
         }
 
         display_changer->configure(session, config);

=== modified file 'src/server/frontend/socket_messenger.cpp'
--- src/server/frontend/socket_messenger.cpp	2013-09-20 14:17:55 +0000
+++ src/server/frontend/socket_messenger.cpp	2013-09-26 15:36:41 +0000
@@ -18,13 +18,16 @@
 
 #include "socket_messenger.h"
 #include "mir/frontend/client_constants.h"
+#include "mir/frontend/messenger_report.h"
 
 namespace mfd = mir::frontend::detail;
 namespace bs = boost::system;
 namespace ba = boost::asio;
 
-mfd::SocketMessenger::SocketMessenger(std::shared_ptr<ba::local::stream_protocol::socket> const& socket)
-    : socket(socket)
+mfd::SocketMessenger::SocketMessenger(std::shared_ptr<ba::local::stream_protocol::socket> const& socket,
+                                      std::shared_ptr<MessengerReport> const& report)
+    : socket(socket),
+      report(report)
 {
     whole_message.reserve(serialization_buffer_size);
 }
@@ -59,14 +62,14 @@
     // function has completed (if it would be executed asynchronously.
     // NOTE: we rely on this synchronous behavior as per the comment in
     // mf::SessionMediator::create_surface
-    try
-    {
-        ba::write(*socket, ba::buffer(whole_message));
-    }
-    catch (std::exception &)
-    {
-        // Don't care
-    }
+
+    boost::system::error_code err;
+    ba::write(*socket, ba::buffer(whole_message), err);
+    if (!err)
+    {
+        report->error(err.message());
+    }
+
 }
 
 void mfd::SocketMessenger::send_fds(std::vector<int32_t> const& fds)

=== modified file 'src/server/frontend/socket_messenger.h'
--- src/server/frontend/socket_messenger.h	2013-08-28 03:41:48 +0000
+++ src/server/frontend/socket_messenger.h	2013-09-26 15:36:41 +0000
@@ -26,13 +26,16 @@
 {
 namespace frontend
 {
+class MessengerReport;
+
 namespace detail
 {
 class SocketMessenger : public MessageSender,
                         public MessageReceiver
 {
 public:
-    SocketMessenger(std::shared_ptr<boost::asio::local::stream_protocol::socket> const& socket);
+    SocketMessenger(std::shared_ptr<boost::asio::local::stream_protocol::socket> const& socket,
+                    std::shared_ptr<frontend::MessengerReport> const& report);
 
     void send(std::string const& body);
     void send_fds(std::vector<int32_t> const& fds);
@@ -42,6 +45,8 @@
 
 private:
     std::shared_ptr<boost::asio::local::stream_protocol::socket> socket;
+    std::shared_ptr<MessengerReport> const report;
+
     std::vector<char> whole_message;
 };
 }

=== modified file 'src/server/graphics/android/CMakeLists.txt'
--- src/server/graphics/android/CMakeLists.txt	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/CMakeLists.txt	2013-09-26 15:36:41 +0000
@@ -11,6 +11,7 @@
   android_buffer_allocator.cpp
   buffer.cpp
   android_display.cpp
+  android_display_configuration.cpp
   gpu_hwc_android_display_buffer_factory.cpp
   hwc_layerlist.cpp
   hwc10_device.cpp

=== modified file 'src/server/graphics/android/android_display.cpp'
--- src/server/graphics/android/android_display.cpp	2013-09-11 17:00:39 +0000
+++ src/server/graphics/android/android_display.cpp	2013-09-26 15:36:41 +0000
@@ -24,6 +24,7 @@
 #include "mir/graphics/egl_resources.h"
 #include "android_display.h"
 #include "android_display_buffer_factory.h"
+#include "display_support_provider.h"
 #include "mir/geometry/rectangle.h"
 
 #include <boost/throw_exception.hpp>
@@ -50,45 +51,6 @@
     EGL_NONE
 };
 
-class AndroidDisplayConfiguration : public mg::DisplayConfiguration
-{
-public:
-    AndroidDisplayConfiguration(geom::Size const& display_size)
-        : configuration{mg::DisplayConfigurationOutputId{1},
-                        mg::DisplayConfigurationCardId{0},
-                        mg::DisplayConfigurationOutputType::lvds,
-                        {geom::PixelFormat::abgr_8888},
-                        {mg::DisplayConfigurationMode{display_size,0.0f}},
-                        0,
-                        geom::Size{0,0},
-                        true,
-                        true,
-                        geom::Point{0,0},
-                        0, 0},
-          card{mg::DisplayConfigurationCardId{0}, 1}
-    {
-    }
-
-    void for_each_card(std::function<void(mg::DisplayConfigurationCard const&)> f) const
-    {
-        f(card);
-    }
-
-    void for_each_output(std::function<void(mg::DisplayConfigurationOutput const&)> f) const
-    {
-        f(configuration);
-    }
-
-    void configure_output(mg::DisplayConfigurationOutputId, bool, geom::Point, size_t)
-    {
-        BOOST_THROW_EXCEPTION(std::runtime_error("cannot configure output\n"));
-    }
-
-private:
-    mg::DisplayConfigurationOutput const configuration;
-    mg::DisplayConfigurationCard const card;
-};
-
 EGLDisplay create_and_initialize_display()
 {
     EGLint major, minor;
@@ -149,6 +111,7 @@
 
 mga::AndroidDisplay::AndroidDisplay(const std::shared_ptr<AndroidFramebufferWindowQuery>& native_win,
                                     std::shared_ptr<AndroidDisplayBufferFactory> const& db_factory,
+                                    std::shared_ptr<DisplaySupportProvider> const& display_provider,
                                     std::shared_ptr<DisplayReport> const& display_report)
     : native_window{native_win},
       egl_display{create_and_initialize_display()},
@@ -160,7 +123,9 @@
                         eglCreatePbufferSurface(egl_display, egl_config,
                                                 dummy_pbuffer_attribs)},
       display_buffer{db_factory->create_display_buffer(
-                         native_window, egl_display, egl_context_shared)}
+          native_window, egl_display, egl_context_shared)},
+      display_provider(display_provider),
+      current_configuration{display_buffer->view_area().size}
 {
     display_report->report_successful_setup_of_native_resources();
 
@@ -186,11 +151,20 @@
 
 std::shared_ptr<mg::DisplayConfiguration> mga::AndroidDisplay::configuration()
 {
-    return std::make_shared<AndroidDisplayConfiguration>(display_buffer->view_area().size);
+    return std::make_shared<mga::AndroidDisplayConfiguration>(current_configuration);
 }
 
-void mga::AndroidDisplay::configure(mg::DisplayConfiguration const&)
+void mga::AndroidDisplay::configure(mg::DisplayConfiguration const& configuration)
 {
+    configuration.for_each_output([&](mg::DisplayConfigurationOutput const& output) -> void
+    {
+        // TODO: Properly support multiple outputs
+        if (output.power_mode == mir_power_mode_on)
+            display_provider->blank_or_unblank_screen(false);
+        else
+            display_provider->blank_or_unblank_screen(true);
+    });
+    current_configuration = dynamic_cast<mga::AndroidDisplayConfiguration const&>(configuration);
 }
 
 void mga::AndroidDisplay::register_configuration_change_handler(

=== modified file 'src/server/graphics/android/android_display.h'
--- src/server/graphics/android/android_display.h	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/android_display.h	2013-09-26 15:36:41 +0000
@@ -22,6 +22,7 @@
 #include "mir/graphics/display.h"
 #include "mir/graphics/egl_resources.h"
 #include "android_framebuffer_window.h"
+#include "android_display_configuration.h"
 
 #include <EGL/egl.h>
 #include <memory>
@@ -38,12 +39,14 @@
 {
 
 class AndroidDisplayBufferFactory;
+class DisplaySupportProvider;
 
 class AndroidDisplay : public Display
 {
 public:
     explicit AndroidDisplay(std::shared_ptr<AndroidFramebufferWindowQuery> const&,
                             std::shared_ptr<AndroidDisplayBufferFactory> const&,
+                            std::shared_ptr<DisplaySupportProvider> const&,
                             std::shared_ptr<DisplayReport> const&);
     ~AndroidDisplay();
 
@@ -74,6 +77,9 @@
     EGLContextStore const egl_context_shared;
     EGLSurfaceStore const egl_surface_dummy;
     std::unique_ptr<DisplayBuffer> display_buffer;
+    std::shared_ptr<DisplaySupportProvider> display_provider;
+    
+    AndroidDisplayConfiguration current_configuration;
 };
 
 }

=== modified file 'src/server/graphics/android/android_display_allocator.cpp'
--- src/server/graphics/android/android_display_allocator.cpp	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/android_display_allocator.cpp	2013-09-26 15:36:41 +0000
@@ -21,17 +21,20 @@
 #include "android_framebuffer_window.h"
 #include "gpu_android_display_buffer_factory.h"
 #include "hwc_android_display_buffer_factory.h"
+#include "hwc_device.h"
+#include "fb_device.h"
 
 namespace mg=mir::graphics;
 namespace mga=mir::graphics::android;
 
 std::shared_ptr<mga::AndroidDisplay> mga::AndroidDisplayAllocator::create_gpu_display(
     std::shared_ptr<ANativeWindow> const& native_window,
+    std::shared_ptr<DisplaySupportProvider> const& display_provider,
     std::shared_ptr<DisplayReport> const& display_report) const
 {
     auto window = std::make_shared<mga::AndroidFramebufferWindow>(native_window);
     auto db_factory = std::make_shared<mga::GPUAndroidDisplayBufferFactory>();
-    return std::make_shared<AndroidDisplay>(window, db_factory, display_report);
+    return std::make_shared<AndroidDisplay>(window, db_factory, display_provider, display_report);
 }
 
 std::shared_ptr<mga::AndroidDisplay> mga::AndroidDisplayAllocator::create_hwc_display(
@@ -41,5 +44,5 @@
 {
     auto window = std::make_shared<mga::AndroidFramebufferWindow>(anw);
     auto db_factory = std::make_shared<mga::HWCAndroidDisplayBufferFactory>(hwc_device);
-    return std::make_shared<AndroidDisplay>(window, db_factory, display_report);
+    return std::make_shared<AndroidDisplay>(window, db_factory, hwc_device, display_report);
 }

=== modified file 'src/server/graphics/android/android_display_allocator.h'
--- src/server/graphics/android/android_display_allocator.h	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/android_display_allocator.h	2013-09-26 15:36:41 +0000
@@ -33,6 +33,7 @@
 public:
     std::shared_ptr<AndroidDisplay> create_gpu_display(
         std::shared_ptr<ANativeWindow> const&,
+        std::shared_ptr<DisplaySupportProvider> const&,
         std::shared_ptr<DisplayReport> const&) const;
 
     std::shared_ptr<AndroidDisplay> create_hwc_display(

=== added file 'src/server/graphics/android/android_display_configuration.cpp'
--- src/server/graphics/android/android_display_configuration.cpp	1970-01-01 00:00:00 +0000
+++ src/server/graphics/android/android_display_configuration.cpp	2013-09-26 15:36:41 +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/>.
+ */
+
+#include "android_display_configuration.h"
+
+namespace mg = mir::graphics;
+namespace mga = mg::android;
+namespace geom = mir::geometry;
+
+mga::AndroidDisplayConfiguration::AndroidDisplayConfiguration(geom::Size const& display_size)
+        : configuration{mg::DisplayConfigurationOutputId{1},
+                        mg::DisplayConfigurationCardId{0},
+                        mg::DisplayConfigurationOutputType::lvds,
+                        {geom::PixelFormat::abgr_8888},
+                        {mg::DisplayConfigurationMode{display_size,0.0f}},
+                        0,
+                        geom::Size{0,0},
+                        true,
+                        true,
+                        geom::Point{0,0},
+                        0, 0, mir_power_mode_on},
+          card{mg::DisplayConfigurationCardId{0}, 1}
+{
+}
+
+mga::AndroidDisplayConfiguration::AndroidDisplayConfiguration(AndroidDisplayConfiguration const& other)
+    : DisplayConfiguration(), configuration(other.configuration),
+      card(other.card)
+{
+}
+
+mga::AndroidDisplayConfiguration& mga::AndroidDisplayConfiguration::operator=(AndroidDisplayConfiguration const& other)
+{
+    if (&other != this)
+    {
+        configuration = other.configuration;
+        card = other.card;
+    }
+    return *this;
+}
+
+void mga::AndroidDisplayConfiguration::for_each_card(std::function<void(mg::DisplayConfigurationCard const&)> f) const
+{
+    f(card);
+}
+
+void mga::AndroidDisplayConfiguration::for_each_output(std::function<void(mg::DisplayConfigurationOutput const&)> f) const
+{
+    f(configuration);
+}
+
+void mga::AndroidDisplayConfiguration::configure_output(mg::DisplayConfigurationOutputId, bool, geom::Point, size_t, MirPowerMode power_mode)
+{
+    configuration.power_mode = power_mode;
+}

=== added file 'src/server/graphics/android/android_display_configuration.h'
--- src/server/graphics/android/android_display_configuration.h	1970-01-01 00:00:00 +0000
+++ src/server/graphics/android/android_display_configuration.h	2013-09-26 15:36:41 +0000
@@ -0,0 +1,51 @@
+/*
+ * 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/>.
+ */
+
+#ifndef MIR_GRAPHICS_ANDROID_ANDROID_DISPLAY_CONFIGURATION_H_
+#define MIR_GRAPHICS_ANDROID_ANDROID_DISPLAY_CONFIGURATION_H_
+
+#include "mir/graphics/display_configuration.h"
+
+namespace mir
+{
+namespace graphics
+{
+namespace android
+{
+
+class AndroidDisplayConfiguration : public graphics::DisplayConfiguration
+{
+public:
+    AndroidDisplayConfiguration(geometry::Size const& display_size);
+    AndroidDisplayConfiguration(AndroidDisplayConfiguration const& other);
+    AndroidDisplayConfiguration& operator=(AndroidDisplayConfiguration const& other);
+    
+    virtual ~AndroidDisplayConfiguration() = default;
+
+    void for_each_card(std::function<void(DisplayConfigurationCard const&)> f) const;
+    void for_each_output(std::function<void(DisplayConfigurationOutput const&)> f) const;
+    void configure_output(DisplayConfigurationOutputId, bool, geometry::Point, size_t, MirPowerMode power_mode);
+
+private:
+    DisplayConfigurationOutput configuration;
+    DisplayConfigurationCard card;
+};
+
+
+}
+}
+}
+#endif /* MIR_GRAPHICS_ANDROID_ANDROID_DISPLAY_CONFIGURATION_H_ */

=== modified file 'src/server/graphics/android/android_display_factory.cpp'
--- src/server/graphics/android/android_display_factory.cpp	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/android_display_factory.cpp	2013-09-26 15:36:41 +0000
@@ -100,7 +100,7 @@
     else
     {
         auto fb_native_win = fb_factory->create_fb_native_window(fb_dev);
-        display = display_factory->create_gpu_display(fb_native_win, display_report);
+        display = display_factory->create_gpu_display(fb_native_win, fb_dev, display_report);
         display_report->report_gpu_composition_in_use();
     }
 

=== modified file 'src/server/graphics/android/android_hwc_factory.cpp'
--- src/server/graphics/android/android_hwc_factory.cpp	2013-05-16 18:56:32 +0000
+++ src/server/graphics/android/android_hwc_factory.cpp	2013-09-26 15:36:41 +0000
@@ -28,7 +28,7 @@
     std::shared_ptr<hwc_composer_device_1> const& hwc_device,
     std::shared_ptr<mga::DisplaySupportProvider> const& fb_device) const
 {
-    auto layer_list = std::make_shared<mga::HWCLayerList>();
+    auto layer_list = std::make_shared<mga::LayerList>();
     auto syncer = std::make_shared<mga::HWCVsync>();
     return std::make_shared<mga::HWC11Device>(hwc_device, layer_list, fb_device, syncer);
 }

=== modified file 'src/server/graphics/android/display_allocator.h'
--- src/server/graphics/android/display_allocator.h	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/display_allocator.h	2013-09-26 15:36:41 +0000
@@ -33,6 +33,8 @@
 class AndroidDisplay;
 class HWCDevice;
 class HWCDisplay;
+class DisplaySupportProvider;
+
 class DisplayAllocator
 {
 public:
@@ -41,6 +43,7 @@
 
     virtual std::shared_ptr<AndroidDisplay> create_gpu_display(
         std::shared_ptr<ANativeWindow> const&,
+        std::shared_ptr<DisplaySupportProvider> const&,
         std::shared_ptr<DisplayReport> const&) const = 0;
 
     virtual std::shared_ptr<AndroidDisplay> create_hwc_display(

=== modified file 'src/server/graphics/android/display_support_provider.h'
--- src/server/graphics/android/display_support_provider.h	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/display_support_provider.h	2013-09-26 15:36:41 +0000
@@ -44,6 +44,8 @@
     //post immediately, or be deferred.
     virtual void set_next_frontbuffer(std::shared_ptr<graphics::Buffer> const& buffer) = 0;
     virtual void sync_to_display(bool sync) = 0;
+    
+    virtual void blank_or_unblank_screen(bool blank) = 0;
 protected:
     DisplaySupportProvider() = default;
     DisplaySupportProvider& operator=(DisplaySupportProvider const&) = delete;

=== modified file 'src/server/graphics/android/fb_device.cpp'
--- src/server/graphics/android/fb_device.cpp	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/fb_device.cpp	2013-09-26 15:36:41 +0000
@@ -78,3 +78,9 @@
         fb_device->setSwapInterval(fb_device.get(), 0);
     }
 }
+
+void mga::FBDevice::blank_or_unblank_screen(bool blank)
+{
+    // TODO: Implement
+    (void) blank;
+}

=== modified file 'src/server/graphics/android/fb_device.h'
--- src/server/graphics/android/fb_device.h	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/fb_device.h	2013-09-26 15:36:41 +0000
@@ -41,6 +41,8 @@
 
     void set_next_frontbuffer(std::shared_ptr<graphics::Buffer> const& buffer);
     void sync_to_display(bool sync);
+    
+    void blank_or_unblank_screen(bool blank);
 private:
     std::shared_ptr<framebuffer_device_t> const fb_device;
 };

=== modified file 'src/server/graphics/android/gpu_hwc_android_display_buffer_factory.cpp'
--- src/server/graphics/android/gpu_hwc_android_display_buffer_factory.cpp	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/gpu_hwc_android_display_buffer_factory.cpp	2013-09-26 15:36:41 +0000
@@ -110,7 +110,7 @@
     {
         return false;
     }
-
+    
 protected:
     std::shared_ptr<mga::AndroidFramebufferWindowQuery> const native_window;
     EGLDisplay const egl_display;
@@ -126,7 +126,8 @@
                      EGLContext egl_context_shared,
                      std::shared_ptr<mga::HWCDevice> const& hwc_device)
         : GPUDisplayBuffer{native_win, egl_display, egl_context_shared},
-          hwc_device{hwc_device}
+          hwc_device{hwc_device},
+          blanked(false)
     {
     }
 
@@ -144,6 +145,8 @@
 
 private:
     std::shared_ptr<mga::HWCDevice> const hwc_device;
+    
+    bool blanked;
 };
 
 }

=== modified file 'src/server/graphics/android/hwc10_device.cpp'
--- src/server/graphics/android/hwc10_device.cpp	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/hwc10_device.cpp	2013-09-26 15:36:41 +0000
@@ -62,6 +62,8 @@
 
 void mga::HWC10Device::commit_frame(EGLDisplay dpy, EGLSurface sur)
 {
+    auto lg = lock_unblanked();
+
     hwc_display_contents_1 display_contents;
     display_contents.dpy = dpy;
     display_contents.sur = sur;

=== modified file 'src/server/graphics/android/hwc10_device.h'
--- src/server/graphics/android/hwc10_device.h	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/hwc10_device.h	2013-09-26 15:36:41 +0000
@@ -26,7 +26,6 @@
 {
 namespace android
 {
-class HWCLayerOrganizer;
 class DisplaySupportProvider;
 
 class HWC10Device : public HWCCommonDevice

=== modified file 'src/server/graphics/android/hwc11_device.cpp'
--- src/server/graphics/android/hwc11_device.cpp	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/hwc11_device.cpp	2013-09-26 15:36:41 +0000
@@ -20,6 +20,7 @@
 #include "hwc11_device.h"
 #include "hwc_layerlist.h"
 #include "hwc_vsync_coordinator.h"
+#include "mir/graphics/android/syncfence.h"
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
 
@@ -28,13 +29,12 @@
 namespace geom=mir::geometry;
 
 mga::HWC11Device::HWC11Device(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
-                              std::shared_ptr<HWCLayerOrganizer> const& organizer,
+                              std::shared_ptr<HWCLayerList> const& layer_list,
                               std::shared_ptr<DisplaySupportProvider> const& fbdev,
                               std::shared_ptr<HWCVsyncCoordinator> const& coordinator)
     : HWCCommonDevice(hwc_device, coordinator),
-      layer_organizer(organizer),
-      fb_device(fbdev),
-      wait_for_vsync(true)
+      layer_list(layer_list),
+      fb_device(fbdev)
 {
     size_t num_configs = 1;
     auto rc = hwc_device->getDisplayConfigs(hwc_device.get(), HWC_DISPLAY_PRIMARY, &primary_display_config, &num_configs);
@@ -55,8 +55,6 @@
                                         HWC_DISPLAY_NO_ATTRIBUTE};
 
     int size_values[2];
-    /* note: some hwc modules (adreno320) do not accept any request list other than what surfaceflinger's requests,
-     * despite what the hwc header says. from what I've seen so far, this is harmless, other than a logcat msg */ 
     hwc_device->getDisplayAttributes(hwc_device.get(), HWC_DISPLAY_PRIMARY, primary_display_config,
                                      size_request, size_values);
 
@@ -77,52 +75,39 @@
 
 void mga::HWC11Device::set_next_frontbuffer(std::shared_ptr<mg::Buffer> const& buffer)
 {
-    layer_organizer->set_fb_target(buffer);
-
-    if (wait_for_vsync)
-    {
-        fb_device->set_next_frontbuffer(buffer);
-    }
+    layer_list->set_fb_target(buffer);
 }
 
 void mga::HWC11Device::commit_frame(EGLDisplay dpy, EGLSurface sur)
 {
-    /* note, swapbuffers will go around through the driver and call set_next_frontbuffer */
+    auto lg = lock_unblanked();
+
+    //note, although we only have a primary display right now,
+    //      set the second display to nullptr, as exynos hwc always derefs displays[1]
+    hwc_display_contents_1_t* displays[HWC_NUM_DISPLAY_TYPES] {layer_list->native_list(), nullptr};
+
+    if (hwc_device->prepare(hwc_device.get(), 1, displays))
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error("error during hwc prepare()"));
+    }
+
+    /* note, swapbuffers will go around through the driver and call
+       set_next_frontbuffer, updating the fb target before committing */
     if (eglSwapBuffers(dpy, sur) == EGL_FALSE)
     {
         BOOST_THROW_EXCEPTION(std::runtime_error("error during eglSwapBuffers"));
     }
 
-    auto& list = layer_organizer->native_list();
-
-    auto struct_size = sizeof(hwc_display_contents_1_t) + sizeof(hwc_layer_1_t)*(list.size());
-    auto hwc_display_raw = static_cast<hwc_display_contents_1_t*>( ::operator new( struct_size));
-    auto hwc_display = std::unique_ptr<hwc_display_contents_1_t>(hwc_display_raw); 
-
-    auto i = 0u;
-    for( auto& layer : list)
-    {
-        hwc_display->hwLayers[i++] = *layer;
-    }
-    hwc_display->numHwLayers = list.size();
-    hwc_display->retireFenceFd = -1;
-
-    auto rc = hwc_device->set(hwc_device.get(), HWC_NUM_DISPLAY_TYPES, &hwc_display_raw);
-    if (rc != 0)
+    if (hwc_device->set(hwc_device.get(), 1, displays))
     {
         BOOST_THROW_EXCEPTION(std::runtime_error("error during hwc set()"));
     }
 
-    if (hwc_display->retireFenceFd > 0)
-        close(hwc_display->retireFenceFd);
-
-    if (wait_for_vsync)
-    {
-        coordinator->wait_for_vsync();
-    }
+    mga::SyncFence fence(displays[HWC_DISPLAY_PRIMARY]->retireFenceFd);
+    fence.wait();
 }
 
-void mga::HWC11Device::sync_to_display(bool sync)
+void mga::HWC11Device::sync_to_display(bool)
 {
-    wait_for_vsync = sync;
+    //TODO return error code, running not synced to vsync is not supported
 }

=== modified file 'src/server/graphics/android/hwc11_device.h'
--- src/server/graphics/android/hwc11_device.h	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/hwc11_device.h	2013-09-26 15:36:41 +0000
@@ -29,14 +29,14 @@
 
 namespace android
 {
-class HWCLayerOrganizer;
+class HWCLayerList;
 class HWCVsyncCoordinator;
 
 class HWC11Device : public HWCCommonDevice
 {
 public:
     HWC11Device(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
-                std::shared_ptr<HWCLayerOrganizer> const& organizer,
+                std::shared_ptr<HWCLayerList> const& layer_list,
                 std::shared_ptr<DisplaySupportProvider> const& fbdev,
                 std::shared_ptr<HWCVsyncCoordinator> const& coordinator);
     ~HWC11Device() noexcept;
@@ -50,10 +50,9 @@
     void commit_frame(EGLDisplay dpy, EGLSurface sur);
 
 private:
-    std::shared_ptr<HWCLayerOrganizer> const layer_organizer;
+    std::shared_ptr<HWCLayerList> const layer_list;
     std::shared_ptr<DisplaySupportProvider> const fb_device;
     unsigned int primary_display_config;
-    bool wait_for_vsync;
 };
 
 }

=== modified file 'src/server/graphics/android/hwc_common_device.cpp'
--- src/server/graphics/android/hwc_common_device.cpp	2013-06-11 10:00:48 +0000
+++ src/server/graphics/android/hwc_common_device.cpp	2013-09-26 15:36:41 +0000
@@ -46,7 +46,8 @@
 mga::HWCCommonDevice::HWCCommonDevice(std::shared_ptr<hwc_composer_device_1> const& hwc_device,
                                       std::shared_ptr<mga::HWCVsyncCoordinator> const& coordinator)
     : hwc_device(hwc_device),
-      coordinator(coordinator) 
+      coordinator(coordinator),
+      blanked(false)
 {
     callbacks.hooks.invalidate = invalidate_hook;
     callbacks.hooks.vsync = vsync_hook;
@@ -95,3 +96,29 @@
 {
     coordinator->notify_vsync();
 }
+
+void mga::HWCCommonDevice::blank_or_unblank_screen(bool blank)
+{
+    std::unique_lock<std::mutex> lg(blanked_mutex);
+                                             
+    int err = hwc_device->blank(hwc_device.get(), HWC_DISPLAY_PRIMARY, blank);
+    if (err)
+    {
+        std::string blanking_status_msg = "Could not " + 
+            (blank ? std::string("blank") : std::string("unblank")) + " display";
+        BOOST_THROW_EXCEPTION(
+            boost::enable_error_info(
+                std::runtime_error(blanking_status_msg)) <<
+            boost::errinfo_errno(-err));
+    }    
+    blanked = blank;
+    blanked_cond.notify_all();
+}
+
+std::unique_lock<std::mutex> mga::HWCCommonDevice::lock_unblanked()
+{
+    std::unique_lock<std::mutex> lg(blanked_mutex);
+    while(blanked)
+        blanked_cond.wait(lg);
+    return std::move(lg);
+}

=== modified file 'src/server/graphics/android/hwc_common_device.h'
--- src/server/graphics/android/hwc_common_device.h	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/hwc_common_device.h	2013-09-26 15:36:41 +0000
@@ -22,6 +22,9 @@
 
 #include <hardware/hwcomposer.h>
 
+#include <mutex>
+#include <condition_variable>
+
 namespace mir
 {
 namespace graphics
@@ -49,6 +52,8 @@
     virtual geometry::Size display_size() const = 0;
     virtual void set_next_frontbuffer(std::shared_ptr<Buffer> const& buffer) = 0;
     virtual void commit_frame(EGLDisplay dpy, EGLSurface sur) = 0;
+    
+    void blank_or_unblank_screen(bool blank);
 
     void notify_vsync();
 protected:
@@ -57,8 +62,15 @@
 
     std::shared_ptr<hwc_composer_device_1> const hwc_device;
     std::shared_ptr<HWCVsyncCoordinator> const coordinator;
+protected:
+    std::unique_lock<std::mutex> lock_unblanked();
+
 private:
     HWCCallbacks callbacks;
+
+    std::mutex blanked_mutex;
+    std::condition_variable blanked_cond;
+    bool blanked;
 };
 
 }

=== modified file 'src/server/graphics/android/hwc_device.h'
--- src/server/graphics/android/hwc_device.h	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/hwc_device.h	2013-09-26 15:36:41 +0000
@@ -42,6 +42,8 @@
     virtual void set_next_frontbuffer(std::shared_ptr<Buffer> const& buffer) = 0;
 
     virtual void commit_frame(EGLDisplay dpy, EGLSurface sur) = 0;
+    
+    virtual void blank_or_unblank_screen(bool blank) = 0;
 private:
     HWCDevice(HWCDevice const&) = delete;
     HWCDevice& operator=(HWCDevice const&) = delete;

=== modified file 'src/server/graphics/android/hwc_layerlist.cpp'
--- src/server/graphics/android/hwc_layerlist.cpp	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/hwc_layerlist.cpp	2013-09-26 15:36:41 +0000
@@ -41,7 +41,7 @@
 mga::HWCDefaultLayer::HWCDefaultLayer(std::initializer_list<mga::HWCRect> list)
 {
     /* default values.*/
-    self.compositionType = HWC_FRAMEBUFFER;
+    self.compositionType = HWC_FRAMEBUFFER_TARGET;
     self.hints = 0;
     self.flags = 0;
     self.transform = 0;
@@ -75,27 +75,31 @@
 }
 
 mga::HWCFBLayer::HWCFBLayer(
-        std::shared_ptr<ANativeWindowBuffer> const& native_buf,
-        HWCRect& display_frame_rect)
+        buffer_handle_t native_handle,
+        HWCRect display_frame_rect)
     : HWCDefaultLayer{display_frame_rect}
 {
     self.compositionType = HWC_FRAMEBUFFER_TARGET;
-    self.handle = native_buf->handle;
 
+    self.handle = native_handle;
     self.sourceCrop = display_frame_rect;
     self.displayFrame = display_frame_rect;
 }
 
-mga::HWCLayerList::HWCLayerList()
-{
-}
-
-const mga::LayerList& mga::HWCLayerList::native_list() const
-{
-    return layer_list;
-}
-
-void mga::HWCLayerList::set_fb_target(std::shared_ptr<mg::Buffer> const& buffer)
+mga::HWCFBLayer::HWCFBLayer()
+    : HWCFBLayer{nullptr, mga::HWCRect{}}
+{
+}
+
+mga::LayerList::LayerList()
+    : layer_list{std::make_shared<HWCFBLayer>()},
+      hwc_representation{std::make_shared<hwc_display_contents_1_t>()}
+{
+    memset(hwc_representation.get(), 0, sizeof(hwc_display_contents_1_t));
+    update_list();
+}
+
+void mga::LayerList::set_fb_target(std::shared_ptr<mg::Buffer> const& buffer)
 {
     auto handle = buffer->native_buffer_handle();
 
@@ -103,13 +107,32 @@
     geom::Rectangle rect{pt, buffer->size()};
     HWCRect display_rect(rect);
 
-    auto fb_layer = std::make_shared<HWCFBLayer>(handle, display_rect);
-    if (layer_list.empty())
-    {
-        layer_list.push_back(fb_layer);
-    }
-    else
-    {
-        layer_list[0] = fb_layer;
-    }
+    auto fb_layer = std::make_shared<HWCFBLayer>(handle->handle, display_rect);
+    layer_list[fb_position] = fb_layer;
+
+    update_list();
 } 
+
+void mga::LayerList::update_list()
+{
+    if (layer_list.size() != hwc_representation->numHwLayers)
+    {
+        auto struct_size = sizeof(hwc_display_contents_1_t) + sizeof(hwc_layer_1_t)*(layer_list.size());
+        hwc_representation = std::shared_ptr<hwc_display_contents_1_t>(
+            static_cast<hwc_display_contents_1_t*>( ::operator new(struct_size)));
+
+        hwc_representation->numHwLayers = layer_list.size();
+    }
+
+    auto i = 0u;
+    for( auto& layer : layer_list)
+    {
+        hwc_representation->hwLayers[i++] = *layer;
+    }
+    hwc_representation->retireFenceFd = -1;
+}
+
+hwc_display_contents_1_t* mga::LayerList::native_list() const
+{
+    return hwc_representation.get();
+}

=== modified file 'src/server/graphics/android/hwc_layerlist.h'
--- src/server/graphics/android/hwc_layerlist.h	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/hwc_layerlist.h	2013-09-26 15:36:41 +0000
@@ -32,8 +32,6 @@
 
 namespace android
 {
-class HWCDefaultLayer;
-typedef struct std::vector<std::shared_ptr<HWCDefaultLayer>> LayerList;
  
 struct HWCRect
 {
@@ -63,34 +61,40 @@
 
 struct HWCFBLayer : public HWCDefaultLayer
 {
-    HWCFBLayer(std::shared_ptr<ANativeWindowBuffer> const& native_buf,
-               HWCRect& display_frame_rect);
+    HWCFBLayer();
+    HWCFBLayer(buffer_handle_t native_buf,
+               HWCRect display_frame_rect);
 };
 
-class HWCLayerOrganizer
+class HWCLayerList
 {
 public:
-    virtual ~HWCLayerOrganizer() = default;
-    virtual const LayerList& native_list() const = 0;
+    virtual ~HWCLayerList() = default;
+
+    virtual hwc_display_contents_1_t* native_list() const = 0;
     virtual void set_fb_target(std::shared_ptr<Buffer> const&) = 0;
 
 protected:
-    HWCLayerOrganizer() = default;
-    HWCLayerOrganizer& operator=(HWCLayerOrganizer const&) = delete;
-    HWCLayerOrganizer(HWCLayerOrganizer const&) = delete;
+    HWCLayerList() = default;
+    HWCLayerList& operator=(HWCLayerList const&) = delete;
+    HWCLayerList(HWCLayerList const&) = delete;
 
 };
 
-class HWCLayerList : public HWCLayerOrganizer
+class LayerList : public HWCLayerList
 {
 public:
-    HWCLayerList();
-    const LayerList& native_list() const;
+    LayerList();
 
     void set_fb_target(std::shared_ptr<Buffer> const&);
+    hwc_display_contents_1_t* native_list() const;
 
 private:
-    LayerList layer_list;
+    std::vector<std::shared_ptr<HWCDefaultLayer>> layer_list;
+    void update_list();
+
+    static size_t const fb_position = 0u;
+    std::shared_ptr<hwc_display_contents_1_t> hwc_representation;
 };
 
 }

=== modified file 'src/server/graphics/android/internal_client.cpp'
--- src/server/graphics/android/internal_client.cpp	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/internal_client.cpp	2013-09-26 15:36:41 +0000
@@ -24,7 +24,6 @@
 namespace mga=mir::graphics::android;
 
 mga::InternalClient::InternalClient()
-    : client_window(0)
 {
 }
 
@@ -35,12 +34,12 @@
 
 EGLNativeWindowType mga::InternalClient::egl_native_window(std::shared_ptr<InternalSurface> const& surface)
 {
-    if (!client_window)
+    if (!client_windows[surface])
     {
         auto cache = std::make_shared<mga::InterpreterCache>();
         auto interpreter = std::make_shared<mga::InternalClientWindow>(surface, cache); 
-        client_window = std::make_shared<mga::MirNativeWindow>(interpreter);
+        client_windows[surface] = std::make_shared<mga::MirNativeWindow>(interpreter);
     }
 
-    return client_window.get();
+    return client_windows[surface].get();
 }

=== modified file 'src/server/graphics/android/internal_client.h'
--- src/server/graphics/android/internal_client.h	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/internal_client.h	2013-09-26 15:36:41 +0000
@@ -21,6 +21,7 @@
 
 #include "mir/graphics/internal_client.h"
 #include <memory>
+#include <map>
 
 namespace mir
 {
@@ -37,7 +38,7 @@
     EGLNativeWindowType egl_native_window(std::shared_ptr<InternalSurface> const&);
 
 private:
-    std::shared_ptr<MirNativeWindow> client_window;
+    std::map<std::shared_ptr<InternalSurface>, std::shared_ptr<MirNativeWindow>> client_windows;
 };
 }
 }

=== modified file 'src/server/graphics/android/internal_client_window.cpp'
--- src/server/graphics/android/internal_client_window.cpp	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/internal_client_window.cpp	2013-09-26 15:36:41 +0000
@@ -44,8 +44,9 @@
 }
 
 void mga::InternalClientWindow::driver_returns_buffer(ANativeWindowBuffer* handle,
-                                                      std::shared_ptr<SyncObject> const&)
+                                                      std::shared_ptr<SyncObject> const& fence)
 {
+    fence->wait();
     resource_cache->retrieve_buffer(handle);
     /* here, the mc::TemporaryBuffer will destruct, triggering buffer advance */
 }

=== modified file 'src/server/graphics/android/server_render_window.cpp'
--- src/server/graphics/android/server_render_window.cpp	2013-08-28 03:41:48 +0000
+++ src/server/graphics/android/server_render_window.cpp	2013-09-26 15:36:41 +0000
@@ -53,8 +53,9 @@
 }
 
 //sync object could be passed to hwc. we don't need to that yet though
-void mga::ServerRenderWindow::driver_returns_buffer(ANativeWindowBuffer* returned_handle, std::shared_ptr<SyncObject> const&)
+void mga::ServerRenderWindow::driver_returns_buffer(ANativeWindowBuffer* returned_handle, std::shared_ptr<SyncObject> const& fence)
 {
+    fence->wait();
     auto buffer = resource_cache->retrieve_buffer(returned_handle); 
     poster->set_next_frontbuffer(buffer);
     swapper->compositor_release(buffer);

=== modified file 'src/server/graphics/gbm/gbm_buffer_allocator.cpp'
--- src/server/graphics/gbm/gbm_buffer_allocator.cpp	2013-09-11 13:50:10 +0000
+++ src/server/graphics/gbm/gbm_buffer_allocator.cpp	2013-09-26 15:36:41 +0000
@@ -114,6 +114,9 @@
           egl_extensions(std::make_shared<mg::EGLExtensions>())
 {
     assert(buffer_initializer.get() != 0);
+
+    const char *env = getenv("MIR_BYPASS");
+    bypass_env = env ? env[0] != '0' : true;
 }
 
 std::shared_ptr<mg::Buffer> mgg::GBMBufferAllocator::alloc_buffer(BufferProperties const& buffer_properties)
@@ -145,7 +148,8 @@
      *       resizing). We may also want to check for
      *       mir_surface_state_fullscreen later when it's fully wired up.
      */
-    if (buffer_properties.usage == BufferUsage::hardware &&
+    if (bypass_env &&
+        buffer_properties.usage == BufferUsage::hardware &&
         buffer_properties.size.width.as_uint32_t() >= 800 &&
         buffer_properties.size.height.as_uint32_t() >= 600)
     {

=== modified file 'src/server/graphics/gbm/gbm_buffer_allocator.h'
--- src/server/graphics/gbm/gbm_buffer_allocator.h	2013-08-29 03:48:16 +0000
+++ src/server/graphics/gbm/gbm_buffer_allocator.h	2013-09-26 15:36:41 +0000
@@ -55,6 +55,8 @@
     gbm_device* const device;
     std::shared_ptr<graphics::BufferInitializer> buffer_initializer;
     std::shared_ptr<EGLExtensions> const egl_extensions;
+
+    bool bypass_env;
 };
 
 }

=== modified file 'src/server/graphics/gbm/gbm_display.cpp'
--- src/server/graphics/gbm/gbm_display.cpp	2013-09-11 17:00:39 +0000
+++ src/server/graphics/gbm/gbm_display.cpp	2013-09-26 15:36:41 +0000
@@ -129,6 +129,16 @@
         auto const& kms_conf = dynamic_cast<RealKMSDisplayConfiguration const&>(conf);
         std::vector<std::unique_ptr<GBMDisplayBuffer>> display_buffers_new;
 
+        /* Reset the state of all outputs */
+        kms_conf.for_each_output([&](DisplayConfigurationOutput const& conf_output)
+        {
+            uint32_t const connector_id = current_display_configuration.get_kms_connector_id(conf_output.id);
+            auto kms_output = output_container.get_kms_output_for(connector_id);
+            kms_output->clear_cursor();
+            kms_output->reset();
+        });
+
+        /* Set up used outputs */
         OverlappingOutputGrouping grouping{conf};
 
         grouping.for_each_group([&](OverlappingOutputGroup const& group)
@@ -143,8 +153,8 @@
 
                 auto const mode_index = kms_conf.get_kms_mode_index(conf_output.id,
                                                                     conf_output.current_mode_index);
-                kms_output->reset();
                 kms_output->configure(conf_output.top_left - bounding_rect.top_left, mode_index);
+                kms_output->set_power_mode(conf_output.power_mode);
                 kms_outputs.push_back(kms_output);
             });
 
@@ -164,6 +174,9 @@
 
         /* Store applied configuration */
         current_display_configuration = kms_conf;
+
+        /* Clear connected but unused outputs */
+        clear_connected_unused_outputs();
     }
 
     if (cursor) cursor->show_at_last_known_position();
@@ -205,7 +218,6 @@
     try
     {
         platform->drm.set_master();
-        if (cursor) cursor->show_at_last_known_position();
     }
     catch(std::runtime_error const& e)
     {
@@ -213,10 +225,21 @@
         throw;
     }
 
-    std::lock_guard<std::mutex> lg{configuration_mutex};
-
-    for (auto& db_ptr : display_buffers)
-        db_ptr->schedule_set_crtc();
+    {
+        std::lock_guard<std::mutex> lg{configuration_mutex};
+
+        /*
+         * After resuming (e.g. because we switched back to the display server VT)
+         * we need to reset the CRTCs. For active displays we schedule a CRTC reset
+         * on the next swap. For connected but unused outputs we clear the CRTC.
+         */
+        for (auto& db_ptr : display_buffers)
+            db_ptr->schedule_set_crtc();
+
+        clear_connected_unused_outputs();
+    }
+
+    if (cursor) cursor->show_at_last_known_position();
 }
 
 auto mgg::GBMDisplay::the_cursor() -> std::weak_ptr<Cursor>
@@ -254,3 +277,16 @@
     return std::unique_ptr<GBMGLContext>{
         new GBMGLContext{platform->gbm, shared_egl.context()}};
 }
+
+void mgg::GBMDisplay::clear_connected_unused_outputs()
+{
+    current_display_configuration.for_each_output([&](DisplayConfigurationOutput const& conf_output)
+    {
+        if (conf_output.connected && !conf_output.used)
+        {
+            uint32_t const connector_id = current_display_configuration.get_kms_connector_id(conf_output.id);
+            auto kms_output = output_container.get_kms_output_for(connector_id);
+            kms_output->clear_crtc();
+        }
+    });
+}

=== modified file 'src/server/graphics/gbm/gbm_display.h'
--- src/server/graphics/gbm/gbm_display.h	2013-08-28 03:41:48 +0000
+++ src/server/graphics/gbm/gbm_display.h	2013-09-26 15:36:41 +0000
@@ -82,6 +82,8 @@
     std::unique_ptr<GLContext> create_gl_context();
 
 private:
+    void clear_connected_unused_outputs();
+
     std::mutex configuration_mutex;
     std::shared_ptr<GBMPlatform> const platform;
     std::shared_ptr<VideoDevices> const video_devices;

=== modified file 'src/server/graphics/gbm/gbm_display_buffer.h'
--- src/server/graphics/gbm/gbm_display_buffer.h	2013-08-28 03:41:48 +0000
+++ src/server/graphics/gbm/gbm_display_buffer.h	2013-09-26 15:36:41 +0000
@@ -58,7 +58,6 @@
 
     bool can_bypass() const override;
     void post_update(std::shared_ptr<graphics::Buffer> bypass_buf) override;
-
     void schedule_set_crtc();
 
 private:

=== modified file 'src/server/graphics/gbm/kms_output.h'
--- src/server/graphics/gbm/kms_output.h	2013-09-11 17:00:39 +0000
+++ src/server/graphics/gbm/kms_output.h	2013-09-26 15:36:41 +0000
@@ -22,6 +22,8 @@
 #include "mir/geometry/size.h"
 #include "mir/geometry/point.h"
 #include "mir/geometry/displacement.h"
+#include "mir/graphics/display_configuration.h"
+#include "mir_toolkit/common.h"
 
 #include <gbm.h>
 
@@ -42,6 +44,7 @@
     virtual geometry::Size size() const = 0;
 
     virtual bool set_crtc(uint32_t fb_id) = 0;
+    virtual void clear_crtc() = 0;
     virtual bool schedule_page_flip(uint32_t fb_id) = 0;
     virtual void wait_for_page_flip() = 0;
 
@@ -49,6 +52,8 @@
     virtual void move_cursor(geometry::Point destination) = 0;
     virtual void clear_cursor() = 0;
     virtual bool has_cursor() const = 0;
+    
+    virtual void set_power_mode(MirPowerMode mode) = 0;
 
 protected:
     KMSOutput() = default;

=== modified file 'src/server/graphics/gbm/real_kms_display_configuration.cpp'
--- src/server/graphics/gbm/real_kms_display_configuration.cpp	2013-09-11 17:00:39 +0000
+++ src/server/graphics/gbm/real_kms_display_configuration.cpp	2013-09-26 15:36:41 +0000
@@ -108,7 +108,8 @@
 
 void mgg::RealKMSDisplayConfiguration::configure_output(
     DisplayConfigurationOutputId id, bool used,
-    geometry::Point top_left, size_t mode_index)
+    geometry::Point top_left, size_t mode_index,
+    MirPowerMode power_mode)
 {
     auto iter = find_output_with_id(id);
 
@@ -122,6 +123,7 @@
         output.used = used;
         output.top_left = top_left;
         output.current_mode_index = mode_index;
+        output.power_mode = power_mode;
     }
     else
     {
@@ -222,12 +224,12 @@
     {
         outputs.push_back({id, card_id, type, formats, modes, preferred_mode_index,
                            physical_size, connected, false, geom::Point(),
-                           current_mode_index, 0u});
+                           current_mode_index, 0u, mir_power_mode_on});
     }
     else
     {
         auto& output = *iter;
-
+        
         output.modes = modes;
         output.preferred_mode_index = preferred_mode_index;
         output.physical_size_mm = physical_size;

=== modified file 'src/server/graphics/gbm/real_kms_display_configuration.h'
--- src/server/graphics/gbm/real_kms_display_configuration.h	2013-09-11 17:00:39 +0000
+++ src/server/graphics/gbm/real_kms_display_configuration.h	2013-09-26 15:36:41 +0000
@@ -40,7 +40,7 @@
     void for_each_card(std::function<void(DisplayConfigurationCard const&)> f) const;
     void for_each_output(std::function<void(DisplayConfigurationOutput const&)> f) const;
     void configure_output(DisplayConfigurationOutputId id, bool used,
-                          geometry::Point top_left, size_t mode_index);
+                          geometry::Point top_left, size_t mode_index, MirPowerMode power_mode);
 
     uint32_t get_kms_connector_id(DisplayConfigurationOutputId id) const;
     size_t get_kms_mode_index(DisplayConfigurationOutputId id, size_t conf_mode_index) const;

=== modified file 'src/server/graphics/gbm/real_kms_output.cpp'
--- src/server/graphics/gbm/real_kms_output.cpp	2013-09-11 17:00:39 +0000
+++ src/server/graphics/gbm/real_kms_output.cpp	2013-09-26 15:36:41 +0000
@@ -25,7 +25,8 @@
 #include <stdexcept>
 #include <vector>
 
-namespace mgg = mir::graphics::gbm;
+namespace mg = mir::graphics;
+namespace mgg = mg::gbm;
 namespace geom = mir::geometry;
 
 namespace
@@ -37,7 +38,8 @@
 
     resources.for_each_connector([&](mgg::DRMModeConnectorUPtr connector)
     {
-        if (connector->encoder_id == encoder_id)
+        if (connector->encoder_id == encoder_id &&
+            connector->connection == DRM_MODE_CONNECTED)
         {
             auto encoder = resources.encoder(connector->encoder_id);
             if (encoder)
@@ -58,11 +60,14 @@
 
     resources.for_each_connector([&](mgg::DRMModeConnectorUPtr connector)
     {
-        auto encoder = resources.encoder(connector->encoder_id);
-        if (encoder)
+        if (connector->connection == DRM_MODE_CONNECTED)
         {
-            if (encoder->crtc_id == crtc_id)
-                crtc_used = true;
+            auto encoder = resources.encoder(connector->encoder_id);
+            if (encoder)
+            {
+                if (encoder->crtc_id == crtc_id)
+                    crtc_used = true;
+            }
         }
     });
 
@@ -131,7 +136,8 @@
                                   std::shared_ptr<PageFlipper> const& page_flipper)
     : drm_fd{drm_fd}, connector_id{connector_id}, page_flipper{page_flipper},
       connector(), mode_index{0}, current_crtc(), saved_crtc(),
-      using_saved_crtc{true}, has_cursor_{false}
+      using_saved_crtc{true}, has_cursor_{false},
+      power_mode(mir_power_mode_on)
 {
     reset();
 
@@ -161,6 +167,21 @@
     if (!connector)
         BOOST_THROW_EXCEPTION(std::runtime_error("No DRM connector found\n"));
 
+    // TODO: What if we can't locate the DPMS property?
+    for (int i = 0; i < connector->count_props; i++)
+    {
+        auto prop = drmModeGetProperty(drm_fd, connector->props[i]);
+        if (prop && (prop->flags & DRM_MODE_PROP_ENUM)) {
+            if (!strcmp(prop->name, "DPMS"))
+            {
+                dpms_enum_id = connector->props[i];
+                drmModeFreeProperty(prop);
+                break;
+            }
+            drmModeFreeProperty(prop);
+        }
+    }
+
     /* Discard previously current crtc */
     current_crtc = nullptr;
 }
@@ -198,8 +219,37 @@
     return true;
 }
 
+void mgg::RealKMSOutput::clear_crtc()
+{
+    /*
+     * In order to actually clear the output, we need to have a crtc
+     * connected to the output/connector so that we can disconnect
+     * it. However, not being able to get a crtc is OK, since it means
+     * that the output cannot be displaying anything anyway.
+     */
+    if (!ensure_crtc())
+        return;
+
+    auto result = drmModeSetCrtc(drm_fd, current_crtc->crtc_id,
+                                 0, 0, 0, nullptr, 0, nullptr);
+    if (result)
+    {
+        std::string const msg =
+            "Couldn't clear output " + connector_name(connector.get());
+
+        BOOST_THROW_EXCEPTION(
+            ::boost::enable_error_info(std::runtime_error(msg))
+                << (boost::error_info<KMSOutput, decltype(result)>(result)));
+    }
+
+    current_crtc = nullptr;
+}
+
 bool mgg::RealKMSOutput::schedule_page_flip(uint32_t fb_id)
 {
+    std::unique_lock<std::mutex> lg(power_mutex);
+    if (power_mode != mir_power_mode_on)
+        return true;
     if (!current_crtc)
         BOOST_THROW_EXCEPTION(std::runtime_error("Output " +
             connector_name(connector.get()) +
@@ -210,6 +260,9 @@
 
 void mgg::RealKMSOutput::wait_for_page_flip()
 {
+    std::unique_lock<std::mutex> lg(power_mutex);
+    if (power_mode != mir_power_mode_on)
+        return;
     if (!current_crtc)
         BOOST_THROW_EXCEPTION(std::runtime_error("Output " +
             connector_name(connector.get()) +
@@ -323,3 +376,15 @@
         using_saved_crtc = true;
     }
 }
+
+void mgg::RealKMSOutput::set_power_mode(MirPowerMode mode)
+{
+    std::lock_guard<std::mutex> lg(power_mutex);
+
+    if (power_mode != mode)
+    {
+        power_mode = mode;
+        drmModeConnectorSetProperty(drm_fd, connector_id,
+                                   dpms_enum_id, mode);
+    }
+}

=== modified file 'src/server/graphics/gbm/real_kms_output.h'
--- src/server/graphics/gbm/real_kms_output.h	2013-09-11 17:00:39 +0000
+++ src/server/graphics/gbm/real_kms_output.h	2013-09-26 15:36:41 +0000
@@ -23,6 +23,7 @@
 #include "drm_mode_resources.h"
 
 #include <memory>
+#include <mutex>
 
 namespace mir
 {
@@ -45,6 +46,7 @@
     geometry::Size size() const;
 
     bool set_crtc(uint32_t fb_id);
+    void clear_crtc();
     bool schedule_page_flip(uint32_t fb_id);
     void wait_for_page_flip();
 
@@ -52,6 +54,8 @@
     void move_cursor(geometry::Point destination);
     void clear_cursor();
     bool has_cursor() const;
+    
+    void set_power_mode(MirPowerMode mode);
 
 private:
     bool ensure_crtc();
@@ -68,6 +72,11 @@
     drmModeCrtc saved_crtc;
     bool using_saved_crtc;
     bool has_cursor_;
+
+    MirPowerMode power_mode;
+    int dpms_enum_id;
+    
+    std::mutex power_mutex;
 };
 
 }

=== modified file 'src/server/graphics/nested/nested_display_configuration.cpp'
--- src/server/graphics/nested/nested_display_configuration.cpp	2013-09-11 17:00:39 +0000
+++ src/server/graphics/nested/nested_display_configuration.cpp	2013-09-26 15:36:41 +0000
@@ -18,6 +18,9 @@
 
 #include "nested_display_configuration.h"
 
+namespace mg = mir::graphics;
+namespace mgn = mg::nested;
+
 #include <boost/throw_exception.hpp>
 
 #include <stdexcept>
@@ -74,14 +77,16 @@
                 !!mir_output.used,
                 geometry::Point{mir_output.position_x, mir_output.position_y},
                 mir_output.current_mode,
-                mir_output.current_output_format
+                mir_output.current_output_format,
+                mir_output.power_mode
             };
 
             f(output);
         });
 }
 
-void mgn::NestedDisplayConfiguration::configure_output(DisplayConfigurationOutputId id, bool used, geometry::Point top_left, size_t mode_index)
+void mgn::NestedDisplayConfiguration::configure_output(DisplayConfigurationOutputId id, bool used, 
+    geometry::Point top_left, size_t mode_index, MirPowerMode power_mode)
 {
     for (auto mir_output = display_config->outputs;
         mir_output != display_config->outputs+display_config->num_outputs;
@@ -96,6 +101,7 @@
             mir_output->position_x = top_left.x.as_uint32_t();
             mir_output->position_y = top_left.y.as_uint32_t();
             mir_output->current_mode = mode_index;
+            mir_output->power_mode = static_cast<MirPowerMode>(power_mode);
             return;
         }
     }

=== modified file 'src/server/graphics/nested/nested_display_configuration.h'
--- src/server/graphics/nested/nested_display_configuration.h	2013-09-11 17:00:39 +0000
+++ src/server/graphics/nested/nested_display_configuration.h	2013-09-26 15:36:41 +0000
@@ -37,7 +37,8 @@
     void for_each_card(std::function<void(DisplayConfigurationCard const&)>) const;
     void for_each_output(std::function<void(DisplayConfigurationOutput const&)>) const;
 
-    void configure_output(DisplayConfigurationOutputId id, bool used, geometry::Point top_left, size_t mode_index);
+    void configure_output(DisplayConfigurationOutputId id, bool used, geometry::Point top_left, size_t mode_index,
+                          MirPowerMode power_mode);
 
     operator MirDisplayConfiguration*() const { return display_config; }
 private:

=== modified file 'src/server/logging/CMakeLists.txt'
--- src/server/logging/CMakeLists.txt	2013-08-28 03:41:48 +0000
+++ src/server/logging/CMakeLists.txt	2013-09-26 15:36:41 +0000
@@ -6,6 +6,7 @@
   message_processor_report.cpp
   display_report.cpp
   input_report.cpp
+  messenger_report.cpp
 )
 
 add_library(

=== added file 'src/server/logging/messenger_report.cpp'
--- src/server/logging/messenger_report.cpp	1970-01-01 00:00:00 +0000
+++ src/server/logging/messenger_report.cpp	2013-09-26 15:36:41 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alan Griffiths <[e-mail]>
+ */
+
+#include "mir/logging/messenger_report.h"
+#include "mir/logging/logger.h"
+
+#include "std/MirLog.h"
+#include <std/Log.h>
+
+
+#include <sstream>
+#include <cstring>
+#include <mutex>
+
+namespace ml = mir::logging;
+
+ml::MessengerReport::MessengerReport(const std::shared_ptr<Logger>& logger) 
+    : logger(logger)
+{
+}
+
+const char* ml::MessengerReport::component()
+{
+    static const char* s = "messenger";
+    return s;
+}
+
+void ml::MessengerReport::error(std::string const& error_message)
+{
+    logger->log<Logger::informational>(error_message, component());
+}

=== modified file 'src/server/logging/session_mediator_report.cpp'
--- src/server/logging/session_mediator_report.cpp	2013-05-30 03:50:54 +0000
+++ src/server/logging/session_mediator_report.cpp	2013-09-26 15:36:41 +0000
@@ -68,6 +68,11 @@
     log->log<Logger::informational>("session_configure_surface_called(\"" + app_name + "\")", component);
 }
 
+void ml::SessionMediatorReport::session_configure_display_called(std::string const& app_name)
+{
+    log->log<Logger::informational>("session_configure_display_called(\"" + app_name + "\")", component);
+}
+
 void ml::SessionMediatorReport::session_error(
         std::string const& app_name,
         char const* method,

=== modified file 'src/server/options/program_option.cpp'
--- src/server/options/program_option.cpp	2013-06-13 06:00:21 +0000
+++ src/server/options/program_option.cpp	2013-09-26 15:36:41 +0000
@@ -87,7 +87,7 @@
     /* Read options from config files */
     for (std::string config_root; getline(config_stream, config_root, ':');)
     {
-        auto const& filename = config_root + name;
+        auto const& filename = config_root + "/" + name;
 
         try
         {

=== modified file 'src/server/shell/mediating_display_changer.cpp'
--- src/server/shell/mediating_display_changer.cpp	2013-09-16 21:37:49 +0000
+++ src/server/shell/mediating_display_changer.cpp	2013-09-26 15:36:41 +0000
@@ -23,6 +23,7 @@
 #include "mir/graphics/display.h"
 #include "mir/compositor/compositor.h"
 #include "mir/graphics/display_configuration_policy.h"
+#include "mir/graphics/display_configuration.h"
 
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
@@ -115,6 +116,32 @@
 
 }
 
+void msh::MediatingDisplayChanger::ensure_display_powered(std::shared_ptr<mf::Session> const& session)
+{
+    std::lock_guard<std::mutex> lg{configuration_mutex};
+    bool switched = false;
+
+    auto it = config_map.find(session);
+    if (it == config_map.end())
+        return;
+    auto conf = it->second;
+    conf->for_each_output([&](mg::DisplayConfigurationOutput const& output) -> void
+    {
+        if (!output.used) return;
+        
+        if (output.power_mode != mir_power_mode_on)
+        {
+            switched = true;
+            conf->configure_output(output.id, output.used,
+                                   output.top_left, 
+                                   output.current_mode_index,
+                                   mir_power_mode_on);
+        }
+    });
+    if (switched)
+        configure(session, conf);
+}
+
 void msh::MediatingDisplayChanger::configure(
     std::shared_ptr<mf::Session> const& session,
     std::shared_ptr<mg::DisplayConfiguration> const& conf)

=== modified file 'src/server/shell/unauthorized_display_changer.cpp'
--- src/server/shell/unauthorized_display_changer.cpp	2013-08-28 03:41:48 +0000
+++ src/server/shell/unauthorized_display_changer.cpp	2013-09-26 15:36:41 +0000
@@ -38,3 +38,8 @@
 {
     BOOST_THROW_EXCEPTION(std::runtime_error("not authorized to apply display configurations"));
 }
+
+void msh::UnauthorizedDisplayChanger::ensure_display_powered(std::shared_ptr<mf::Session> const&)
+{
+    BOOST_THROW_EXCEPTION(std::runtime_error("not authorized to apply display configurations"));
+}

=== modified file 'src/shared/graphics/android/mir_native_window.cpp'
--- src/shared/graphics/android/mir_native_window.cpp	2013-05-20 15:29:28 +0000
+++ src/shared/graphics/android/mir_native_window.cpp	2013-09-26 15:36:41 +0000
@@ -18,28 +18,14 @@
 
 #include "mir/graphics/android/mir_native_window.h"
 #include "mir/graphics/android/android_driver_interpreter.h"
-#include "syncfence.h"
+#include "mir/graphics/android/syncfence.h"
 
-#include <unistd.h>
-#include <sys/ioctl.h>
 
 namespace mga=mir::graphics::android;
 
 namespace
 {
 
-class IoctlControl : public mga::IoctlWrapper
-{
-public:
-    int ioctl(int fd, unsigned long int request, int* timeout) const
-    {
-        return ::ioctl(fd, request, timeout);
-    }
-    int close(int fd) const
-    {
-        return ::close(fd);
-    }
-};
 
 static int query_static(const ANativeWindow* anw, int key, int* value);
 static int perform_static(ANativeWindow* anw, int key, ...);
@@ -99,8 +85,7 @@
                        struct ANativeWindowBuffer* buffer)
 {
     auto self = static_cast<mga::MirNativeWindow*>(window);
-    auto ioctl_control = std::make_shared<IoctlControl>();
-    auto fence = std::make_shared<mga::SyncFence>(-1, ioctl_control);
+    auto fence = std::make_shared<mga::SyncFence>();
     return self->queueBuffer(buffer, fence);
 }
 
@@ -108,8 +93,7 @@
                        struct ANativeWindowBuffer* buffer, int fence_fd)
 {
     auto self = static_cast<mga::MirNativeWindow*>(window);
-    auto ioctl_control = std::make_shared<IoctlControl>();
-    auto fence = std::make_shared<mga::SyncFence>(fence_fd, ioctl_control);
+    auto fence = std::make_shared<mga::SyncFence>(fence_fd);
     return self->queueBuffer(buffer, fence);
 
 }

=== modified file 'src/shared/graphics/android/syncfence.cpp'
--- src/shared/graphics/android/syncfence.cpp	2013-04-24 05:22:20 +0000
+++ src/shared/graphics/android/syncfence.cpp	2013-09-26 15:36:41 +0000
@@ -16,13 +16,23 @@
  * Authored by: Kevin DuBois <[e-mail]>
  */
 
-#include "syncfence.h"
+#include "mir/graphics/android/syncfence.h"
+
+#include <unistd.h>
+#include <sys/ioctl.h>
+
+//FIXME: (lp-1229884) this ioctl code should be taken from kernel headers
+#define SYNC_IOC_WAIT 0x40043E00
 
 namespace mga = mir::graphics::android;
 
-mga::SyncFence::SyncFence(int fd, std::shared_ptr<IoctlWrapper> const& wrapper)
- : ioctl_wrapper(wrapper),
-   fence_fd(fd)
+mga::SyncFence::SyncFence()
+    : fence_fd(-1)
+{
+}
+
+mga::SyncFence::SyncFence(int fd)
+   : fence_fd(fd)
 {
 }
 
@@ -30,7 +40,7 @@
 {
     if (fence_fd > 0)
     {
-        ioctl_wrapper->close(fence_fd);
+        ::close(fence_fd);
     }
 }
 
@@ -39,6 +49,6 @@
     if (fence_fd > 0)
     {
         int timeout = -1;
-        ioctl_wrapper->ioctl(fence_fd, SYNC_IOC_WAIT, &timeout);
+        ::ioctl(fence_fd, SYNC_IOC_WAIT, &timeout);
     }
 }

=== modified file 'src/shared/protobuf/mir_protobuf.proto'
--- src/shared/protobuf/mir_protobuf.proto	2013-09-12 08:05:56 +0000
+++ src/shared/protobuf/mir_protobuf.proto	2013-09-26 15:36:41 +0000
@@ -73,6 +73,7 @@
   optional uint32 physical_height_mm = 12;
   optional uint32 type = 13;
   optional uint32 preferred_mode = 14;
+  optional uint32 power_mode = 15;
 }
 
 // DEPRECATED

=== modified file 'tests/acceptance-tests/test_client_input.cpp'
--- tests/acceptance-tests/test_client_input.cpp	2013-09-17 14:31:42 +0000
+++ tests/acceptance-tests/test_client_input.cpp	2013-09-26 15:36:41 +0000
@@ -151,7 +151,7 @@
 
         try
         {
-            input_cb_setup_fence.try_signal_ready_for(std::chrono::milliseconds(1000));
+            input_cb_setup_fence.try_signal_ready_for();
         } catch (const std::runtime_error& e)
         {
             std::cout << e.what() << std::endl;
@@ -859,7 +859,7 @@
     
     static std::string const test_client_name = "1";
     static std::string const test_client_2_name = "2";
-    mtf::CrossProcessSync fence, second_client_done_fence;
+    mtf::CrossProcessSync fence, first_client_ready_fence, second_client_done_fence;
 
     struct ServerConfiguration : public mtf::InputTestingServerConfiguration
     {
@@ -916,20 +916,23 @@
             EXPECT_CALL(*handler, handle_input(MotionEventWithPosition(2, 2))).Times(1)
                 .WillOnce(mt::WakeUp(&events_received));
         }
-    } client_1{fence};
+    } client_1{first_client_ready_fence};
     struct ButtonClientTwo : InputClient
     {
+        mtf::CrossProcessSync first_client_ready;
         mtf::CrossProcessSync done_fence;
 
-        ButtonClientTwo(mtf::CrossProcessSync const& fence, mtf::CrossProcessSync const& done_fence) 
+        ButtonClientTwo(mtf::CrossProcessSync const& fence, mtf::CrossProcessSync const& first_client_ready,
+                        mtf::CrossProcessSync const& done_fence) 
             : InputClient(fence, test_client_2_name),
+              first_client_ready(first_client_ready),
               done_fence(done_fence)
         {
         }
         void exec()
         {
             // Ensure we stack on top of the first client
-            input_cb_setup_fence.wait_for_signal_ready_for(std::chrono::milliseconds(4000));
+            first_client_ready.wait_for_signal_ready_for();
             InputClient::exec();
         }
 
@@ -940,7 +943,7 @@
             EXPECT_CALL(*handler, handle_input(MotionEventWithPosition(1, 1))).Times(1)
                 .WillOnce(DoAll(SignalFence(&done_fence), mt::WakeUp(&events_received)));
         }
-    } client_2{fence, second_client_done_fence};
+    } client_2{fence, first_client_ready_fence, second_client_done_fence};
 
     // Client 2 is launched second so will be the first to receive input
 

=== modified file 'tests/acceptance-tests/test_client_library.cpp'
--- tests/acceptance-tests/test_client_library.cpp	2013-09-17 14:31:42 +0000
+++ tests/acceptance-tests/test_client_library.cpp	2013-09-26 15:36:41 +0000
@@ -22,7 +22,7 @@
 #include "mir_toolkit/mir_client_library_debug.h"
 #include "src/client/client_buffer.h"
 
-#include "mir/frontend/communicator.h"
+#include "mir/frontend/connector.h"
 
 #include "mir_protobuf.pb.h"
 

=== modified file 'tests/acceptance-tests/test_server_shutdown.cpp'
--- tests/acceptance-tests/test_server_shutdown.cpp	2013-09-17 14:31:42 +0000
+++ tests/acceptance-tests/test_server_shutdown.cpp	2013-09-26 15:36:41 +0000
@@ -326,19 +326,19 @@
      */
     std::weak_ptr<mir::graphics::Display> display = server_config->the_display();
     std::weak_ptr<mir::compositor::Compositor> compositor = server_config->the_compositor();
-    std::weak_ptr<mir::frontend::Communicator> communicator = server_config->the_communicator();
+    std::weak_ptr<mir::frontend::Connector> connector = server_config->the_connector();
     std::weak_ptr<mir::input::InputManager> input_manager = server_config->the_input_manager();
 
     server_config.reset();
 
     EXPECT_EQ(0, display.use_count());
     EXPECT_EQ(0, compositor.use_count());
-    EXPECT_EQ(0, communicator.use_count());
+    EXPECT_EQ(0, connector.use_count());
     EXPECT_EQ(0, input_manager.use_count());
 
     if (display.use_count() != 0 ||
         compositor.use_count() != 0 ||
-        communicator.use_count() != 0 ||
+        connector.use_count() != 0 ||
         input_manager.use_count() != 0)
     {
         resources_freed_failure.set();

=== modified file 'tests/acceptance-tests/test_test_framework.cpp'
--- tests/acceptance-tests/test_test_framework.cpp	2013-04-24 05:22:20 +0000
+++ tests/acceptance-tests/test_test_framework.cpp	2013-09-26 15:36:41 +0000
@@ -18,7 +18,7 @@
 
 #include "mir_test_framework/display_server_test_fixture.h"
 
-#include "mir/frontend/communicator.h"
+#include "mir/frontend/connector.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>

=== modified file 'tests/integration-tests/client/test_client_render.cpp'
--- tests/integration-tests/client/test_client_render.cpp	2013-08-28 03:41:48 +0000
+++ tests/integration-tests/client/test_client_render.cpp	2013-09-26 15:36:41 +0000
@@ -27,7 +27,7 @@
 #include "mir_test/stub_server_tool.h"
 #include "mir_test/test_protobuf_server.h"
 
-#include "mir/frontend/communicator.h"
+#include "mir/frontend/connector.h"
 
 #include <gmock/gmock.h>
 #include <thread>

=== modified file 'tests/integration-tests/graphics/android/test_display_integration.cpp'
--- tests/integration-tests/graphics/android/test_display_integration.cpp	2013-08-28 03:41:48 +0000
+++ tests/integration-tests/graphics/android/test_display_integration.cpp	2013-09-26 15:36:41 +0000
@@ -111,8 +111,7 @@
     auto fb_window = fb_factory->create_fb_native_window(fb_device);
     auto window_query = std::make_shared<mga::AndroidFramebufferWindow>(fb_window);
     auto db_factory = std::make_shared<mga::GPUAndroidDisplayBufferFactory>();
-    auto display = std::make_shared<mga::AndroidDisplay>(window_query, db_factory,
-                                                         mock_display_report);
+    auto display = std::make_shared<mga::AndroidDisplay>(window_query, db_factory, fb_device, mock_display_report);
 
     display->for_each_display_buffer([this](mg::DisplayBuffer& buffer)
     {
@@ -141,12 +140,12 @@
     auto mock_display_report = std::make_shared<testing::NiceMock<mtd::MockDisplayReport>>();
     auto fb_window = fb_factory->create_fb_native_window(fb_device);
     auto window_query = std::make_shared<mga::AndroidFramebufferWindow>(fb_window);
-    auto layerlist = std::make_shared<mga::HWCLayerList>();
+    auto layerlist = std::make_shared<mga::LayerList>();
 
     auto syncer = std::make_shared<mga::HWCVsync>();
     auto hwc = std::make_shared<mga::HWC10Device>(hwc_device, fb_device, syncer);
     auto db_factory = std::make_shared<mga::HWCAndroidDisplayBufferFactory>(hwc);
-    auto display = std::make_shared<mga::AndroidDisplay>(window_query, db_factory,
+    auto display = std::make_shared<mga::AndroidDisplay>(window_query, db_factory, hwc,
                                                          mock_display_report);
 
     display->for_each_display_buffer([this](mg::DisplayBuffer& buffer)
@@ -169,13 +168,12 @@
     auto mock_display_report = std::make_shared<testing::NiceMock<mtd::MockDisplayReport>>();
     auto fb_window = fb_factory->create_fb_native_window(fb_device);
     auto window_query = std::make_shared<mga::AndroidFramebufferWindow>(fb_window);
-    auto layerlist = std::make_shared<mga::HWCLayerList>();
+    auto layerlist = std::make_shared<mga::LayerList>();
 
     auto syncer = std::make_shared<mga::HWCVsync>();
     auto hwc = std::make_shared<mga::HWC11Device>(hwc_device, layerlist, fb_device, syncer);
     auto db_factory = std::make_shared<mga::HWCAndroidDisplayBufferFactory>(hwc);
-    auto display = std::make_shared<mga::AndroidDisplay>(window_query, db_factory,
-                                                         mock_display_report);
+    auto display = std::make_shared<mga::AndroidDisplay>(window_query, db_factory, hwc, mock_display_report);
 
     display->for_each_display_buffer([this](mg::DisplayBuffer& buffer)
     {

=== modified file 'tests/integration-tests/shell/test_session.cpp'
--- tests/integration-tests/shell/test_session.cpp	2013-08-28 03:41:48 +0000
+++ tests/integration-tests/shell/test_session.cpp	2013-09-26 15:36:41 +0000
@@ -29,7 +29,7 @@
 #include "mir/surfaces/buffer_stream.h"
 #include "mir/compositor/renderer.h"
 #include "mir/compositor/renderer_factory.h"
-#include "mir/frontend/communicator.h"
+#include "mir/frontend/connector.h"
 
 #include "mir_test_doubles/stub_buffer.h"
 #include "mir_test_doubles/null_display.h"
@@ -61,15 +61,16 @@
         return input_configuration;
     }
 
-    std::shared_ptr<mf::Communicator> the_communicator() override
+    std::shared_ptr<mf::Connector> the_connector() override
     {
-        struct NullCommunicator : public mf::Communicator
+        struct NullConnector : public mf::Connector
         {
             void start() {}
             void stop() {}
+            int client_socket_fd() const override { return 0; }
         };
 
-        return std::make_shared<NullCommunicator>();
+        return std::make_shared<NullConnector>();
     }
 
     std::shared_ptr<mg::GraphicBufferAllocator> the_buffer_allocator() override

=== modified file 'tests/integration-tests/test_display_server_main_loop_events.cpp'
--- tests/integration-tests/test_display_server_main_loop_events.cpp	2013-08-28 03:41:48 +0000
+++ tests/integration-tests/test_display_server_main_loop_events.cpp	2013-09-26 15:36:41 +0000
@@ -17,17 +17,19 @@
  */
 
 #include "mir/compositor/compositor.h"
-#include "mir/frontend/communicator.h"
+#include "mir/frontend/connector.h"
 #include "mir/graphics/display_configuration.h"
 #include "mir/graphics/display_configuration_policy.h"
 #include "mir/main_loop.h"
 #include "mir/display_changer.h"